fix: Preserve compile diagnostics across Unity reloads

Packages/src/Editor/Domain/CliConstants.cs

@@ -6,7 +6,7 @@ namespace io.github.hatayama.UnityCliLoop.Domain
     public static class CliConstants
     {
         public const string EXECUTABLE_NAME = "uloop";
-        public const string MINIMUM_REQUIRED_CLI_VERSION = "3.0.0-beta.24";
+        public const string MINIMUM_REQUIRED_CLI_VERSION = "3.0.0-beta.25";
         public const string MINIMUM_REQUIRED_CLI_RELEASE_TAG = CLI_RELEASE_TAG_PREFIX + MINIMUM_REQUIRED_CLI_VERSION;
         public const string VERSION_FLAG = "--version";
         public const string SHORT_VERSION_FLAG = "-v";

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.
@@ -134,6 +135,7 @@ public async Task<CompileResult> TryCompileAsync(bool forceRecompile, Cancellati
 
             _isCompiling = true;
             _compileMessages.Clear();
+            _compileStartedAtUtc = DateTime.UtcNow;
             TaskCompletionSource<CompileResult> compileTask = new();
             _currentCompileTask = compileTask;
             _isForceCompile = forceRecompile;
@@ -198,6 +200,7 @@ public async Task<CompileResult> TryCompileAsync(bool forceRecompile, Cancellati
                     _currentCompileTask = null;
                     _isCompiling = false;
                     _isForceCompile = false;
+                    _compileStartedAtUtc = DateTime.MinValue;
                     compileTask.TrySetCanceled();
                 }
             }
@@ -486,6 +489,7 @@ private void CompleteCompileRequest(CompileResult result, bool unregisterEvents)
                     _isCompiling = false;
                     _isForceCompile = false;
                     _resultRecordingContext = CompileResultRecordingContext.Disabled();
+                    _compileStartedAtUtc = DateTime.MinValue;
                 }
 
                 task?.TrySetResult(result);
@@ -542,9 +546,42 @@ public void ClearMessages()
         private void HandleCompileFinished(object context)
         {
             CompileResult result = CreateCompileResult();
+            LogCompileFinishCallbackReceived(result);
             CompleteCompileRequest(result, unregisterEvents: true);
         }
 
+        private void LogCompileFinishCallbackReceived(CompileResult result)
+        {
+            UnityEngine.Debug.Assert(result != null, "result must not be null");
+
+            string requestId = _resultRecordingContext.Enabled
+                ? _resultRecordingContext.RequestId
+                : "";
+            VibeLogger.LogInfo(
+                "compile_finish_callback_received",
+                "Unity compilationFinished callback was received.",
+                new
+                {
+                    request_id = requestId,
+                    success = result.Success,
+                    error_count = result.ErrorCount,
+                    warning_count = result.WarningCount,
+                    is_indeterminate = result.IsIndeterminate,
+                    elapsed_ms = CompileElapsedMilliseconds()
+                },
+                requestId);
+        }
+
+        private long CompileElapsedMilliseconds()
+        {
+            if (_compileStartedAtUtc == DateTime.MinValue)
+            {
+                return 0;
+            }
+
+            return (long)(DateTime.UtcNow - _compileStartedAtUtc).TotalMilliseconds;
+        }
+
         /// <summary>
         /// Handler for when assembly compilation is complete.
         /// </summary>
@@ -755,6 +792,7 @@ public void Cleanup()
             _isForceCompile = false;
             _reloadExternalSceneChanges = true;
             _resultRecordingContext = CompileResultRecordingContext.Disabled();
+            _compileStartedAtUtc = DateTime.MinValue;
         }
 
         /// <summary>

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

@@ -62,6 +62,10 @@ internal static void StoreCompileResult(
 
             result.ProjectRoot = UnityCliLoopPathResolver.GetProjectRoot();
             string resultJson = JsonConvert.SerializeObject(result, Formatting.None);
+            UnityCliLoopStoredCompileResult previousResult =
+                sessionStateService.GetCompileResult(requestId);
+            UnityCliLoopPendingCompileRequest pendingRequest =
+                sessionStateService.GetPendingCompileRequestForRequestId(requestId);
             sessionStateService.StoreCompileResult(
                 requestId,
                 forceRecompile,
@@ -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 = previousResult.HasResult ? 2 : 1,
+                    pending_request_before = pendingRequest.HasRequest,
+                    pending_request_cleared = pendingRequestCleared,
+                    duplicate_result_for_request = previousResult.HasResult
                 },
                 correlationId);
         }

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

@@ -42,11 +42,12 @@ public async Task<UnityCliLoopCompileResult> CompileAsync(UnityCliLoopCompileReq
 
             PrepareResultStorage(request);
             string correlationId = ResolveCorrelationId(request);
+            LogCompileRequestReceived(request, correlationId);
 
             DateTime utcNow = DateTime.UtcNow;
             _sessionStateService.ClearExpiredCompileResult(utcNow);
             _sessionStateService.ClearExpiredPendingCompileRequest(utcNow);
-            MarkPendingCompileRequestIfNeeded(request, utcNow);
+            MarkPendingCompileRequestIfNeeded(request, utcNow, correlationId);
 
             // 1. Play Mode preparation check
             PlayModeCompilationPreparationService preparationService = new();
@@ -234,7 +235,8 @@ private UnityCliLoopCompileResult StoreResponseIfNeeded(
 
         private void MarkPendingCompileRequestIfNeeded(
             UnityCliLoopCompileRequest request,
-            DateTime markedAtUtc)
+            DateTime markedAtUtc,
+            string correlationId)
         {
             Debug.Assert(request != null, "request must not be null");
             Debug.Assert(markedAtUtc.Kind == DateTimeKind.Utc, "markedAtUtc must be UTC");
@@ -245,10 +247,47 @@ private void MarkPendingCompileRequestIfNeeded(
             }
 
             Debug.Assert(!string.IsNullOrWhiteSpace(request.RequestId), "request.RequestId must not be null or whitespace");
+            UnityCliLoopPendingCompileRequest[] previousPendingRequests =
+                _sessionStateService.GetPendingCompileRequests();
             _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,
+                    force_recompile = request.ForceRecompile,
+                    pending_request_replaced = false,
+                    pending_request_count_before = previousPendingRequests.Length,
+                    previous_request_id = previousPendingRequests.Length > 0
+                        ? previousPendingRequests[0].RequestId
+                        : ""
+                },
+                correlationId);
+        }
+
+        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 ResolveCorrelationId(UnityCliLoopCompileRequest request)

Packages/src/Editor/Infrastructure/Api/CompileStatusBridgeCommand.cs

@@ -30,12 +30,14 @@ public static GetCompileStatusResponse Execute(JToken paramsToken)
             bool isDomainReloadInProgress =
                 sessionStateService.GetIsDomainReloadInProgress() ||
                 DomainReloadStateRegistry.IsDomainReloadInProgress();
-            return BuildResponse(
+            GetCompileStatusResponse response = BuildResponse(
                 requestId,
                 isCompiling,
                 isUpdating,
                 isDomainReloadInProgress,
                 sessionStateService);
+            LogCompileStatusQueryReceived(requestId, response);
+            return response;
         }
 
         internal static GetCompileStatusResponse BuildResponse(
@@ -81,6 +83,28 @@ private static string ReadRequestId(JToken paramsToken)
             return requestIdToken?.ToString() ?? "";
         }
 
+        private static void LogCompileStatusQueryReceived(
+            string requestId,
+            GetCompileStatusResponse response)
+        {
+            Debug.Assert(response != null, "response must not be null");
+
+            VibeLogger.LogInfo(
+                "compile_status_query_received",
+                "Received compile status polling request from CLI.",
+                new
+                {
+                    request_id = requestId,
+                    ready = response.Ready,
+                    has_result = response.HasResult,
+                    is_compiling = response.IsCompiling,
+                    is_updating = response.IsUpdating,
+                    is_domain_reload_in_progress = response.IsDomainReloadInProgress,
+                    message = response.Message
+                },
+                requestId);
+        }
+
         private static UnityCliLoopStoredCompileResult RecoverPendingCompileResult(
             string requestId,
             UnityCliLoopEditorSessionStateService sessionStateService)

Packages/src/Editor/Infrastructure/Server/DomainReloadDetectionFileService.cs

@@ -58,6 +58,8 @@ public void StartDomainReload(string correlationId, bool serverIsRunning)
                 return;
             }
 
+            UnityCliLoopPendingCompileRequest[] pendingCompileRequests =
+                _sessionStateService.GetPendingCompileRequests();
             _sessionStateService.MarkDomainReloadStarted(serverIsRunning);
 
             UnityCliLoopEditorDomainReloadStateProvider.SetDomainReloadInProgressFromMainThread(true);
@@ -68,7 +70,9 @@ public void StartDomainReload(string correlationId, bool serverIsRunning)
                 "Domain reload starting",
                 new
                 {
-                    server_running = serverIsRunning
+                    server_running = serverIsRunning,
+                    pending_compile_request_count = pendingCompileRequests.Length,
+                    pending_compile_request_ids = ToPendingCompileRequestIds(pendingCompileRequests)
                 },
                 correlationId
             );
@@ -88,6 +92,8 @@ public void CompleteDomainReload(string correlationId)
 
             MigrateLegacySessionStateIfNeeded();
             bool serverWillRecover = !_sessionStateService.GetIsServerManuallyStopped();
+            UnityCliLoopPendingCompileRequest[] pendingCompileRequests =
+                _sessionStateService.GetPendingCompileRequests();
 
             // Clear Domain Reload completion flag
             _sessionStateService.ClearDomainReloadFlag();
@@ -99,7 +105,12 @@ public void CompleteDomainReload(string correlationId)
                 serverWillRecover
                     ? "Domain reload completed - starting server recovery process"
                     : "Domain reload completed - server was manually stopped before recovery",
-                new { transport = "project_ipc" },
+                new
+                {
+                    transport = "project_ipc",
+                    pending_compile_request_count = pendingCompileRequests.Length,
+                    pending_compile_request_ids = ToPendingCompileRequestIds(pendingCompileRequests)
+                },
                 correlationId
             );
         }
@@ -171,5 +182,19 @@ private void MigrateLegacySessionStateIfNeeded()
 
             _legacySessionStateReader.Clear();
         }
+
+        private static string[] ToPendingCompileRequestIds(
+            UnityCliLoopPendingCompileRequest[] pendingCompileRequests)
+        {
+            UnityEngine.Debug.Assert(pendingCompileRequests != null, "pendingCompileRequests must not be null");
+
+            string[] requestIds = new string[pendingCompileRequests.Length];
+            for (int i = 0; i < pendingCompileRequests.Length; i++)
+            {
+                requestIds[i] = pendingCompileRequests[i].RequestId;
+            }
+
+            return requestIds;
+        }
     }
 }

Packages/src/Editor/Infrastructure/Server/UnityCliLoopServerController.cs

@@ -629,7 +629,10 @@ private async Task<bool> TryBindWithWaitAsync(
                     server = _serverInstanceFactory.Create();
                     server.StartServer();
                     _bridgeServer = server;
-                    VibeLogger.LogInfo("binding_success", $"endpoint={server.Endpoint}");
+                    VibeLogger.LogInfo(
+                        "binding_success",
+                        "Unity CLI Loop server bound the project IPC endpoint.",
+                        new { endpoint = server.Endpoint });
                     return true;
                 }
                 catch (Exception ex)

cli/contract.json

@@ -1,4 +1,4 @@
 {
   "schemaVersion": 1,
-  "cliVersion": "3.0.0-beta.24"
+  "cliVersion": "3.0.0-beta.25"
 }

cli/internal/cli/cli_vibe.go

@@ -1,6 +1,8 @@
 package cli
 
 import (
+	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"os"
@@ -13,6 +15,8 @@ const (
 	cliVibeLogDirectory = ".uloop/outputs/VibeLogs"
 	cliVibeLogPrefix    = "cli_vibe"
 	cliVibeLogEnvName   = "ULOOP_DEBUG"
+
+	cliProjectIdentityHashLength = 16
 )
 
 type cliVibeLogEntry struct {
@@ -81,3 +85,16 @@ func isCliVibeLogEnabled() bool {
 	}
 	return !strings.EqualFold(value, "false")
 }
+
+func projectIdentity(projectRoot string) string {
+	if projectRoot == "" {
+		return ""
+	}
+
+	canonicalProjectRoot, err := filepath.EvalSymlinks(projectRoot)
+	if err != nil {
+		canonicalProjectRoot = projectRoot
+	}
+	sum := sha256.Sum256([]byte(canonicalProjectRoot))
+	return "project_" + hex.EncodeToString(sum[:])[:cliProjectIdentityHashLength]
+}