@atelierai/uco 1.0.9 → 1.0.10

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.0.10 - 2026-09-19
+
+- Vendored plugin refreshed to **1.0.8** — fixes an editor-native crash on
+  domain reload (UmaViewer issue uco-domain-reload-crash-20260919, 2/2
+  reproducible during script recompile). The plugin no longer defines a
+  finalizer: the historical one ran the full teardown (token cancellation
+  with synchronous Task continuations and ExecutionContext restores) on the
+  GC finalizer thread during domain unload, which mono cannot execute.
+  Assembly-reload/unload/quit cleanup now disposes the plugin instance
+  deterministically on the safe background-thread path. Ten other
+  same-pattern finalizers (request DTOs, log storage/collector) removed with
+  it. Framework tests 831x2; 2022.3 gate unchanged.
+
+
 ## 1.0.9 - 2026-09-19
 
 - Vendored plugin refreshed to **1.0.7**: the complete legacy-naming sweep —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atelierai/uco",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "uco — Unity Copilot CLI. Drive Unity Editor (and runtime game builds) from any AI agent via plain HTTP.",
   "type": "module",
   "bin": {

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/Startup.Editor.cs

@@ -84,6 +84,22 @@ namespace com.AtelierAI.Unity.Copilot.Editor
                             nameof(Startup), callerName, e.Message);
                     }
                 }
+
+                // Deterministic teardown on reload/unload/quit: dispose the plugin
+                // instance on a background thread (the safe context for the token
+                // cancellation callbacks — same reasoning as
+                // DisposeUcoPluginInstance). Without this, the instance survived
+                // domain unload undisposed and relied on GC finalization — the
+                // crash path fixed in uco-domain-reload-crash-20260919.
+                try
+                {
+                    plugin.DisposeUcoPluginInstance();
+                }
+                catch (System.Exception e)
+                {
+                    _logger.LogWarning(e, "{class} {method}: Exception during plugin disposal (non-blocking): {message}",
+                        nameof(Startup), callerName, e.Message);
+                }
             }
 
             try

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/Unity/Logs/BufferedFileLogStorage.cs

@@ -1,207 +1,208 @@
-/*
-┌──────────────────────────────────────────────────────────────────┐
-│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
-│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
-│  Copyright (c) 2025 Ivan Murzak                                  │
-│  Licensed under the Apache License, Version 2.0.                 │
-│  See the LICENSE file in the project root for more information.  │
-└──────────────────────────────────────────────────────────────────┘
-*/
-
-#nullable enable
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
-using UnityEngine;
-
-namespace com.AtelierAI.Unity.Copilot
-{
-    using ILogger = Microsoft.Extensions.Logging.ILogger;
-    public class BufferedFileLogStorage : FileLogStorage
-    {
-        protected readonly int _flushEntriesThreshold;
-        protected readonly LogEntry[] _logEntriesBuffer;
-        protected int _logEntriesBufferLength;
-
-        public BufferedFileLogStorage(
-            ILogger? logger = null,
-            int flushEntriesThreshold = 100,
-            string? cacheFilePath = null,
-            string? cacheFileName = null,
-            int fileBufferSize = 4096,
-            int maxFileSizeMB = DefaultMaxFileSizeMB,
-            JsonSerializerOptions? jsonOptions = null)
-            : base(logger, cacheFilePath, cacheFileName, fileBufferSize, maxFileSizeMB, jsonOptions)
-        {
-            if (flushEntriesThreshold <= 0)
-                throw new ArgumentOutOfRangeException(nameof(flushEntriesThreshold), "Flush entries threshold must be greater than zero.");
-
-            _flushEntriesThreshold = flushEntriesThreshold;
-            _logEntriesBuffer = new LogEntry[flushEntriesThreshold];
-            _logEntriesBufferLength = 0;
-        }
-
-        public override void Flush()
-        {
-            if (_isDisposed.Value)
-            {
-                _logger.LogWarning("{method} called but already disposed, ignored.",
-                    nameof(Flush));
-                return;
-            }
-            lock (_fileMutex)
-            {
-                // Flush buffered entries to file
-                if (_logEntriesBufferLength > 0)
-                {
-                    var entriesToFlush = new LogEntry[_logEntriesBufferLength];
-                    Array.Copy(_logEntriesBuffer, entriesToFlush, _logEntriesBufferLength);
-                    base.AppendInternal(entriesToFlush);
-                    _logEntriesBufferLength = 0;
-                }
-                fileWriteStream?.Flush();
-            }
-        }
-        public override Task FlushAsync()
-        {
-            if (_isDisposed.Value)
-            {
-                _logger.LogWarning("{method} called but already disposed, ignored.",
-                    nameof(FlushAsync));
-                return Task.CompletedTask;
-            }
-            lock (_fileMutex)
-            {
-                // Flush buffered entries to file
-                if (_logEntriesBufferLength > 0)
-                {
-                    var entriesToFlush = new LogEntry[_logEntriesBufferLength];
-                    Array.Copy(_logEntriesBuffer, entriesToFlush, _logEntriesBufferLength);
-                    base.AppendInternal(entriesToFlush);
-                    _logEntriesBufferLength = 0;
-                }
-                fileWriteStream?.Flush();
-            }
-            return Task.CompletedTask;
-        }
-
-        protected override void AppendInternal(params LogEntry[] entries)
-        {
-            if (_isDisposed.Value)
-            {
-                _logger.LogWarning("{method} called but already disposed, ignored.",
-                    nameof(AppendInternal));
-                return;
-            }
-            if (_logEntriesBufferLength >= _flushEntriesThreshold)
-            {
-                base.AppendInternal(_logEntriesBuffer);
-                _logEntriesBufferLength = 0;
-            }
-            foreach (var entry in entries)
-            {
-                _logEntriesBuffer[_logEntriesBufferLength] = entry;
-                _logEntriesBufferLength++;
-
-                if (_logEntriesBufferLength >= _flushEntriesThreshold)
-                {
-                    base.AppendInternal(_logEntriesBuffer);
-                    _logEntriesBufferLength = 0;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Closes and disposes the current file stream if open. Clears the log cache file.
-        /// </summary>
-        public override LogClearResult Clear()
-        {
-            if (_isDisposed.Value)
-            {
-                _logger.LogWarning("{method} called but already disposed, ignored.",
-                    nameof(Clear));
-                return new LogClearResult
-                {
-                    Ok = false,
-                    Strategy = "storage-disposed",
-                    Path = filePath,
-                    Error = "The log storage is disposed."
-                };
-            }
-            lock (_fileMutex)
-            {
-                _logEntriesBufferLength = 0;
-                return ClearFileLocked();
-            }
-        }
-
-        public override LogEntry[] Query(
-            int maxEntries = 100,
-            LogType? logTypeFilter = null,
-            bool includeStackTrace = false,
-            int lastMinutes = 0)
-        {
-            if (_isDisposed.Value)
-            {
-                _logger.LogWarning("{method} called but already disposed, ignored.",
-                    nameof(Query));
-                return Array.Empty<LogEntry>();
-            }
-            lock (_fileMutex)
-            {
-                return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
-            }
-        }
-
-        protected override LogEntry[] QueryInternal(
-            int maxEntries = 100,
-            LogType? logTypeFilter = null,
-            bool includeStackTrace = false,
-            int lastMinutes = 0)
-        {
-            var result = new List<LogEntry>();
-            var cutoffTime = lastMinutes > 0
-                ? System.DateTime.Now.AddMinutes(-lastMinutes)
-                : System.DateTime.MinValue;
-
-            // 1. Get from buffer (Newest are at the end of buffer)
-            for (int i = _logEntriesBufferLength - 1; i >= 0; i--)
-            {
-                var entry = _logEntriesBuffer[i];
-                if (logTypeFilter.HasValue && entry.LogType != logTypeFilter.Value)
-                    continue;
-
-                if (lastMinutes > 0)
-                {
-                    if (entry.Timestamp < cutoffTime)
-                    {
-                        return result.AsEnumerable().Reverse().ToArray();
-                    }
-                }
-
-                result.Add(entry);
-                if (result.Count >= maxEntries)
-                    return result.AsEnumerable().Reverse().ToArray();
-            }
-
-            // 2. Exit if we already have enough entries
-            var neededLogsCount = maxEntries - result.Count;
-            if (neededLogsCount <= 0)
-                return result.AsEnumerable().Reverse().ToArray();
-
-            result.Reverse();
-
-            // 3. Get from file
-            var fileEntries = base.QueryInternal(neededLogsCount, logTypeFilter, includeStackTrace, lastMinutes);
-            result.AddRange(fileEntries);
-
-            return result.ToArray();
-        }
-
-        ~BufferedFileLogStorage() => Dispose();
-    }
-}
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot
+{
+    using ILogger = Microsoft.Extensions.Logging.ILogger;
+    public class BufferedFileLogStorage : FileLogStorage
+    {
+        protected readonly int _flushEntriesThreshold;
+        protected readonly LogEntry[] _logEntriesBuffer;
+        protected int _logEntriesBufferLength;
+
+        public BufferedFileLogStorage(
+            ILogger? logger = null,
+            int flushEntriesThreshold = 100,
+            string? cacheFilePath = null,
+            string? cacheFileName = null,
+            int fileBufferSize = 4096,
+            int maxFileSizeMB = DefaultMaxFileSizeMB,
+            JsonSerializerOptions? jsonOptions = null)
+            : base(logger, cacheFilePath, cacheFileName, fileBufferSize, maxFileSizeMB, jsonOptions)
+        {
+            if (flushEntriesThreshold <= 0)
+                throw new ArgumentOutOfRangeException(nameof(flushEntriesThreshold), "Flush entries threshold must be greater than zero.");
+
+            _flushEntriesThreshold = flushEntriesThreshold;
+            _logEntriesBuffer = new LogEntry[flushEntriesThreshold];
+            _logEntriesBufferLength = 0;
+        }
+
+        public override void Flush()
+        {
+            if (_isDisposed.Value)
+            {
+                _logger.LogWarning("{method} called but already disposed, ignored.",
+                    nameof(Flush));
+                return;
+            }
+            lock (_fileMutex)
+            {
+                // Flush buffered entries to file
+                if (_logEntriesBufferLength > 0)
+                {
+                    var entriesToFlush = new LogEntry[_logEntriesBufferLength];
+                    Array.Copy(_logEntriesBuffer, entriesToFlush, _logEntriesBufferLength);
+                    base.AppendInternal(entriesToFlush);
+                    _logEntriesBufferLength = 0;
+                }
+                fileWriteStream?.Flush();
+            }
+        }
+        public override Task FlushAsync()
+        {
+            if (_isDisposed.Value)
+            {
+                _logger.LogWarning("{method} called but already disposed, ignored.",
+                    nameof(FlushAsync));
+                return Task.CompletedTask;
+            }
+            lock (_fileMutex)
+            {
+                // Flush buffered entries to file
+                if (_logEntriesBufferLength > 0)
+                {
+                    var entriesToFlush = new LogEntry[_logEntriesBufferLength];
+                    Array.Copy(_logEntriesBuffer, entriesToFlush, _logEntriesBufferLength);
+                    base.AppendInternal(entriesToFlush);
+                    _logEntriesBufferLength = 0;
+                }
+                fileWriteStream?.Flush();
+            }
+            return Task.CompletedTask;
+        }
+
+        protected override void AppendInternal(params LogEntry[] entries)
+        {
+            if (_isDisposed.Value)
+            {
+                _logger.LogWarning("{method} called but already disposed, ignored.",
+                    nameof(AppendInternal));
+                return;
+            }
+            if (_logEntriesBufferLength >= _flushEntriesThreshold)
+            {
+                base.AppendInternal(_logEntriesBuffer);
+                _logEntriesBufferLength = 0;
+            }
+            foreach (var entry in entries)
+            {
+                _logEntriesBuffer[_logEntriesBufferLength] = entry;
+                _logEntriesBufferLength++;
+
+                if (_logEntriesBufferLength >= _flushEntriesThreshold)
+                {
+                    base.AppendInternal(_logEntriesBuffer);
+                    _logEntriesBufferLength = 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Closes and disposes the current file stream if open. Clears the log cache file.
+        /// </summary>
+        public override LogClearResult Clear()
+        {
+            if (_isDisposed.Value)
+            {
+                _logger.LogWarning("{method} called but already disposed, ignored.",
+                    nameof(Clear));
+                return new LogClearResult
+                {
+                    Ok = false,
+                    Strategy = "storage-disposed",
+                    Path = filePath,
+                    Error = "The log storage is disposed."
+                };
+            }
+            lock (_fileMutex)
+            {
+                _logEntriesBufferLength = 0;
+                return ClearFileLocked();
+            }
+        }
+
+        public override LogEntry[] Query(
+            int maxEntries = 100,
+            LogType? logTypeFilter = null,
+            bool includeStackTrace = false,
+            int lastMinutes = 0)
+        {
+            if (_isDisposed.Value)
+            {
+                _logger.LogWarning("{method} called but already disposed, ignored.",
+                    nameof(Query));
+                return Array.Empty<LogEntry>();
+            }
+            lock (_fileMutex)
+            {
+                return QueryInternal(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
+            }
+        }
+
+        protected override LogEntry[] QueryInternal(
+            int maxEntries = 100,
+            LogType? logTypeFilter = null,
+            bool includeStackTrace = false,
+            int lastMinutes = 0)
+        {
+            var result = new List<LogEntry>();
+            var cutoffTime = lastMinutes > 0
+                ? System.DateTime.Now.AddMinutes(-lastMinutes)
+                : System.DateTime.MinValue;
+
+            // 1. Get from buffer (Newest are at the end of buffer)
+            for (int i = _logEntriesBufferLength - 1; i >= 0; i--)
+            {
+                var entry = _logEntriesBuffer[i];
+                if (logTypeFilter.HasValue && entry.LogType != logTypeFilter.Value)
+                    continue;
+
+                if (lastMinutes > 0)
+                {
+                    if (entry.Timestamp < cutoffTime)
+                    {
+                        return result.AsEnumerable().Reverse().ToArray();
+                    }
+                }
+
+                result.Add(entry);
+                if (result.Count >= maxEntries)
+                    return result.AsEnumerable().Reverse().ToArray();
+            }
+
+            // 2. Exit if we already have enough entries
+            var neededLogsCount = maxEntries - result.Count;
+            if (neededLogsCount <= 0)
+                return result.AsEnumerable().Reverse().ToArray();
+
+            result.Reverse();
+
+            // 3. Get from file
+            var fileEntries = base.QueryInternal(neededLogsCount, logTypeFilter, includeStackTrace, lastMinutes);
+            result.AddRange(fileEntries);
+
+            return result.ToArray();
+        }
+
+// No finalizer: Dispose is plain managed cleanup; running arbitrary code on
+        // the finalizer thread during domain unload is never safe.
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/Unity/Logs/FileLogStorage.cs

@@ -542,6 +542,8 @@ namespace com.AtelierAI.Unity.Copilot
             GC.SuppressFinalize(this);
         }
 
-        ~FileLogStorage() => Dispose();
+// No finalizer: Dispose performs file I/O / Unity static-event unsubscription,
+        // which must never run on the finalizer thread during domain unload
+        // (same crash class as uco-domain-reload-crash-20260919).
     }
 }

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/Unity/Logs/UnityLogCollector.cs

@@ -1,280 +1,282 @@
-/*
-┌──────────────────────────────────────────────────────────────────┐
-│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
-│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
-│  Copyright (c) 2025 Ivan Murzak                                  │
-│  Licensed under the Apache License, Version 2.0.                 │
-│  See the LICENSE file in the project root for more information.  │
-└──────────────────────────────────────────────────────────────────┘
-*/
-
-#nullable enable
-using System;
-using System.Text.RegularExpressions;
-using System.Threading;
-using System.Threading.Tasks;
-using com.AtelierAI.Unity.Copilot.Runtime.Utils;
-using com.AtelierAI.Unity.Copilot.Utils;
-using com.AtelierAI.Uco.Framework.Common;
-using com.IvanMurzak.ReflectorNet;
-using com.IvanMurzak.ReflectorNet.Utils;
-using UnityEngine;
-
-namespace com.AtelierAI.Unity.Copilot
-{
-    /// <summary>
-    /// Result of a detailed console query: the filtered entries plus the
-    /// collector's loss accounting so "no errors" is distinguishable from
-    /// "errors were dropped" (COCli-07).
-    /// </summary>
-    public class ConsoleLogsQueryResult
-    {
-        public LogEntry[] Entries { get; set; } = Array.Empty<LogEntry>();
-        public int DroppedEntries { get; set; }
-        public int TruncatedEntries { get; set; }
-    }
-
-    /// <summary>
-    /// Collects Unity log messages and manages saving/loading them to/from a cache file.
-    /// </summary>
-    public class UnityLogCollector : IDisposable
-    {
-        private static readonly Regex RichTextRegex = new Regex(@"</?(b|i|size|color|material|quad|a)\b[^>]*>", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-        const int MaxMessageCharacters = 16 * 1024;
-
-        readonly ILogStorage _logStorage;
-        readonly ThreadSafeBool _isDisposed = new(false);
-        // This collector's channel sink and the sink it displaced, so Dispose
-        // can restore the previous channel owner instead of clearing it.
-        readonly Action<PluginDiagnosticEntry> _channelSink;
-        Action<PluginDiagnosticEntry>? _previousChannelSink;
-        int _droppedEntries;
-        int _truncatedEntries;
-
-        public UnityLogCollector(ILogStorage logStorage)
-        {
-            if (!MainThread.Instance.IsMainThread)
-                throw new Exception($"{GetType().GetTypeShortName()} constructor must be initialized on the main thread.");
-
-            _logStorage = logStorage ?? throw new ArgumentNullException(nameof(logStorage));
-
-            _channelSink = AppendPluginDiagnostic;
-            _previousChannelSink = PluginDiagnostics.CurrentSink;
-            Application.logMessageReceivedThreaded += OnLogMessageReceived;
-            PluginDiagnostics.Install(_channelSink);
-        }
-
-        public LogClearResult Clear()
-        {
-            if (_isDisposed.Value)
-                return new LogClearResult
-                {
-                    Ok = false,
-                    Strategy = "collector-disposed",
-                    Error = "The Unity log collector is disposed."
-                };
-
-            return _logStorage.Clear();
-        }
-
-        /// <summary>
-        /// Synchronously saves all current log entries to the cache file.
-        /// </summary>
-        public void Save()
-        {
-            if (_isDisposed.Value)
-                return;
-
-            _logStorage.Flush();
-        }
-
-        /// <summary>
-        /// Asynchronously saves all current log entries to the cache file.
-        /// </summary>
-        /// <returns>A task that completes when the save operation is finished.</returns>
-        public Task SaveAsync()
-        {
-            if (_isDisposed.Value)
-                return Task.CompletedTask;
-
-            return _logStorage.FlushAsync();
-        }
-
-        public Task<LogEntry[]> QueryAsync(
-            int maxEntries = 100,
-            LogType? logTypeFilter = null,
-            bool includeStackTrace = false,
-            int lastMinutes = 0)
-        {
-            return _logStorage.QueryAsync(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
-        }
-
-        public LogEntry[] Query(
-            int maxEntries = 100,
-            LogType? logTypeFilter = null,
-            bool includeStackTrace = false,
-            int lastMinutes = 0)
-        {
-            return _logStorage.Query(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
-        }
-
-        /// <summary>
-        /// Detailed query with operation/correlation/source/time-boundary
-        /// filters and loss accounting (COCli-07). Existing filter names and
-        /// semantics are unchanged; the new filters compose with them.
-        /// </summary>
-        public ConsoleLogsQueryResult QueryDetailed(
-            int maxEntries = 100,
-            LogType? logTypeFilter = null,
-            bool includeStackTrace = false,
-            int lastMinutes = 0,
-            string? correlationId = null,
-            string? operationId = null,
-            string? source = null,
-            long? sinceUnixMs = null)
-        {
-            if (maxEntries < 1)
-                throw new ArgumentOutOfRangeException(nameof(maxEntries));
-            if (!string.IsNullOrEmpty(source)
-                && source != LogEntry.SourceProduct
-                && source != LogEntry.SourceBridge
-                && source != LogEntry.SourceTool
-                && source != LogEntry.SourceUnity)
-            {
-                throw new ArgumentException(
-                    $"source must be one of: {LogEntry.SourceProduct}, {LogEntry.SourceBridge}, {LogEntry.SourceTool}, {LogEntry.SourceUnity}.");
-            }
-
-            // Oversubscribe the storage query so the id/source filters below
-            // can still fill maxEntries from a wider recent window.
-            var fetchLimit = string.IsNullOrEmpty(correlationId) && string.IsNullOrEmpty(operationId)
-                ? maxEntries
-                : Math.Min(2_000, maxEntries * 10);
-            var candidates = _logStorage.Query(
-                fetchLimit, logTypeFilter, includeStackTrace, lastMinutes);
-
-            var results = new System.Collections.Generic.List<LogEntry>(candidates.Length);
-            var boundary = sinceUnixMs.HasValue
-                ? DateTimeOffset.FromUnixTimeMilliseconds(sinceUnixMs.Value).LocalDateTime
-                : (DateTime?)null;
-            // Storage returns newest-first; keep the newest maxEntries after
-            // filtering, then present them oldest-first for readability.
-            for (var i = 0; i < candidates.Length && results.Count < maxEntries; i++)
-            {
-                var entry = candidates[i];
-                if (!string.IsNullOrEmpty(correlationId)
-                    && !string.Equals(entry.CorrelationId, correlationId, StringComparison.Ordinal))
-                    continue;
-                if (!string.IsNullOrEmpty(operationId)
-                    && !string.Equals(entry.OperationId, operationId, StringComparison.Ordinal))
-                    continue;
-                if (!string.IsNullOrEmpty(source)
-                    && !string.Equals(entry.Source, source, StringComparison.Ordinal))
-                    continue;
-                if (boundary.HasValue && entry.Timestamp < boundary.Value)
-                    continue;
-                results.Add(entry);
-            }
-            results.Reverse();
-
-            return new ConsoleLogsQueryResult
-            {
-                Entries = results.ToArray(),
-                DroppedEntries = Volatile.Read(ref _droppedEntries) + PluginDiagnostics.DroppedEntries,
-                TruncatedEntries = Volatile.Read(ref _truncatedEntries),
-            };
-        }
-
-        /// <summary>Sink for the plugin/bridge/tool diagnostics channel.</summary>
-        void AppendPluginDiagnostic(PluginDiagnosticEntry entry)
-        {
-            if (_isDisposed.Value || entry == null) return;
-            try
-            {
-                _logStorage.Append(new LogEntry(
-                    logType: entry.LogType,
-                    message: BoundMessage(entry.Message, out var truncated),
-                    source: entry.Source,
-                    correlationId: entry.CorrelationId,
-                    operationId: entry.OperationId,
-                    timestamp: DateTime.Now,
-                    stackTrace: entry.StackTrace));
-                if (truncated)
-                    Interlocked.Increment(ref _truncatedEntries);
-            }
-            catch
-            {
-                Interlocked.Increment(ref _droppedEntries);
-            }
-        }
-
-        void OnLogMessageReceived(string message, string stackTrace, LogType type)
-        {
-            try
-            {
-                // Strip rich text tags
-                var cleanMessage = BoundMessage(RichTextRegex.Replace(message, string.Empty), out var truncated);
-
-                // COCli-07 attribution: entries produced on the main thread
-                // inside an owned execution window carry that call's ids and
-                // classify as product; everything Unity forwards otherwise
-                // stays source=unity with empty correlation fields.
-                string? correlationId = null;
-                string? operationId = null;
-                var source = LogEntry.SourceUnity;
-                if (MainThread.Instance.IsMainThread && LogCallScope.Current is { } frame)
-                {
-                    correlationId = frame.CorrelationId;
-                    operationId = frame.OperationId;
-                    source = LogEntry.SourceProduct;
-                }
-
-                _logStorage.Append(new LogEntry(
-                    logType: type,
-                    message: cleanMessage,
-                    source: source,
-                    correlationId: correlationId,
-                    operationId: operationId,
-                    timestamp: DateTime.Now,
-                    stackTrace: string.IsNullOrEmpty(stackTrace) ? null : stackTrace));
-                if (truncated)
-                    Interlocked.Increment(ref _truncatedEntries);
-            }
-            catch
-            {
-                Interlocked.Increment(ref _droppedEntries);
-            }
-        }
-
-        string BoundMessage(string message, out bool truncated)
-        {
-            if (message.Length <= MaxMessageCharacters)
-            {
-                truncated = false;
-                return message;
-            }
-            truncated = true;
-            return message.Substring(0, MaxMessageCharacters);
-        }
-
-        public void Dispose()
-        {
-            if (!_isDisposed.TrySetTrue())
-                return; // already disposed
-
-            Application.logMessageReceivedThreaded -= OnLogMessageReceived;
-            // Hand the channel back to whatever sink was installed before this
-            // collector (e.g. the plugin's own collector) instead of clearing
-            // it: a temporary collector must not disable console separation for
-            // the rest of the session. A newer install is left untouched.
-            PluginDiagnostics.RestoreIfCurrent(_channelSink, _previousChannelSink);
-            _previousChannelSink = null;
-            _logStorage.Dispose();
-
-            GC.SuppressFinalize(this);
-        }
-
-        ~UnityLogCollector() => Dispose();
-    }
-}
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using com.AtelierAI.Unity.Copilot.Runtime.Utils;
+using com.AtelierAI.Unity.Copilot.Utils;
+using com.AtelierAI.Uco.Framework.Common;
+using com.IvanMurzak.ReflectorNet;
+using com.IvanMurzak.ReflectorNet.Utils;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot
+{
+    /// <summary>
+    /// Result of a detailed console query: the filtered entries plus the
+    /// collector's loss accounting so "no errors" is distinguishable from
+    /// "errors were dropped" (COCli-07).
+    /// </summary>
+    public class ConsoleLogsQueryResult
+    {
+        public LogEntry[] Entries { get; set; } = Array.Empty<LogEntry>();
+        public int DroppedEntries { get; set; }
+        public int TruncatedEntries { get; set; }
+    }
+
+    /// <summary>
+    /// Collects Unity log messages and manages saving/loading them to/from a cache file.
+    /// </summary>
+    public class UnityLogCollector : IDisposable
+    {
+        private static readonly Regex RichTextRegex = new Regex(@"</?(b|i|size|color|material|quad|a)\b[^>]*>", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+        const int MaxMessageCharacters = 16 * 1024;
+
+        readonly ILogStorage _logStorage;
+        readonly ThreadSafeBool _isDisposed = new(false);
+        // This collector's channel sink and the sink it displaced, so Dispose
+        // can restore the previous channel owner instead of clearing it.
+        readonly Action<PluginDiagnosticEntry> _channelSink;
+        Action<PluginDiagnosticEntry>? _previousChannelSink;
+        int _droppedEntries;
+        int _truncatedEntries;
+
+        public UnityLogCollector(ILogStorage logStorage)
+        {
+            if (!MainThread.Instance.IsMainThread)
+                throw new Exception($"{GetType().GetTypeShortName()} constructor must be initialized on the main thread.");
+
+            _logStorage = logStorage ?? throw new ArgumentNullException(nameof(logStorage));
+
+            _channelSink = AppendPluginDiagnostic;
+            _previousChannelSink = PluginDiagnostics.CurrentSink;
+            Application.logMessageReceivedThreaded += OnLogMessageReceived;
+            PluginDiagnostics.Install(_channelSink);
+        }
+
+        public LogClearResult Clear()
+        {
+            if (_isDisposed.Value)
+                return new LogClearResult
+                {
+                    Ok = false,
+                    Strategy = "collector-disposed",
+                    Error = "The Unity log collector is disposed."
+                };
+
+            return _logStorage.Clear();
+        }
+
+        /// <summary>
+        /// Synchronously saves all current log entries to the cache file.
+        /// </summary>
+        public void Save()
+        {
+            if (_isDisposed.Value)
+                return;
+
+            _logStorage.Flush();
+        }
+
+        /// <summary>
+        /// Asynchronously saves all current log entries to the cache file.
+        /// </summary>
+        /// <returns>A task that completes when the save operation is finished.</returns>
+        public Task SaveAsync()
+        {
+            if (_isDisposed.Value)
+                return Task.CompletedTask;
+
+            return _logStorage.FlushAsync();
+        }
+
+        public Task<LogEntry[]> QueryAsync(
+            int maxEntries = 100,
+            LogType? logTypeFilter = null,
+            bool includeStackTrace = false,
+            int lastMinutes = 0)
+        {
+            return _logStorage.QueryAsync(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
+        }
+
+        public LogEntry[] Query(
+            int maxEntries = 100,
+            LogType? logTypeFilter = null,
+            bool includeStackTrace = false,
+            int lastMinutes = 0)
+        {
+            return _logStorage.Query(maxEntries, logTypeFilter, includeStackTrace, lastMinutes);
+        }
+
+        /// <summary>
+        /// Detailed query with operation/correlation/source/time-boundary
+        /// filters and loss accounting (COCli-07). Existing filter names and
+        /// semantics are unchanged; the new filters compose with them.
+        /// </summary>
+        public ConsoleLogsQueryResult QueryDetailed(
+            int maxEntries = 100,
+            LogType? logTypeFilter = null,
+            bool includeStackTrace = false,
+            int lastMinutes = 0,
+            string? correlationId = null,
+            string? operationId = null,
+            string? source = null,
+            long? sinceUnixMs = null)
+        {
+            if (maxEntries < 1)
+                throw new ArgumentOutOfRangeException(nameof(maxEntries));
+            if (!string.IsNullOrEmpty(source)
+                && source != LogEntry.SourceProduct
+                && source != LogEntry.SourceBridge
+                && source != LogEntry.SourceTool
+                && source != LogEntry.SourceUnity)
+            {
+                throw new ArgumentException(
+                    $"source must be one of: {LogEntry.SourceProduct}, {LogEntry.SourceBridge}, {LogEntry.SourceTool}, {LogEntry.SourceUnity}.");
+            }
+
+            // Oversubscribe the storage query so the id/source filters below
+            // can still fill maxEntries from a wider recent window.
+            var fetchLimit = string.IsNullOrEmpty(correlationId) && string.IsNullOrEmpty(operationId)
+                ? maxEntries
+                : Math.Min(2_000, maxEntries * 10);
+            var candidates = _logStorage.Query(
+                fetchLimit, logTypeFilter, includeStackTrace, lastMinutes);
+
+            var results = new System.Collections.Generic.List<LogEntry>(candidates.Length);
+            var boundary = sinceUnixMs.HasValue
+                ? DateTimeOffset.FromUnixTimeMilliseconds(sinceUnixMs.Value).LocalDateTime
+                : (DateTime?)null;
+            // Storage returns newest-first; keep the newest maxEntries after
+            // filtering, then present them oldest-first for readability.
+            for (var i = 0; i < candidates.Length && results.Count < maxEntries; i++)
+            {
+                var entry = candidates[i];
+                if (!string.IsNullOrEmpty(correlationId)
+                    && !string.Equals(entry.CorrelationId, correlationId, StringComparison.Ordinal))
+                    continue;
+                if (!string.IsNullOrEmpty(operationId)
+                    && !string.Equals(entry.OperationId, operationId, StringComparison.Ordinal))
+                    continue;
+                if (!string.IsNullOrEmpty(source)
+                    && !string.Equals(entry.Source, source, StringComparison.Ordinal))
+                    continue;
+                if (boundary.HasValue && entry.Timestamp < boundary.Value)
+                    continue;
+                results.Add(entry);
+            }
+            results.Reverse();
+
+            return new ConsoleLogsQueryResult
+            {
+                Entries = results.ToArray(),
+                DroppedEntries = Volatile.Read(ref _droppedEntries) + PluginDiagnostics.DroppedEntries,
+                TruncatedEntries = Volatile.Read(ref _truncatedEntries),
+            };
+        }
+
+        /// <summary>Sink for the plugin/bridge/tool diagnostics channel.</summary>
+        void AppendPluginDiagnostic(PluginDiagnosticEntry entry)
+        {
+            if (_isDisposed.Value || entry == null) return;
+            try
+            {
+                _logStorage.Append(new LogEntry(
+                    logType: entry.LogType,
+                    message: BoundMessage(entry.Message, out var truncated),
+                    source: entry.Source,
+                    correlationId: entry.CorrelationId,
+                    operationId: entry.OperationId,
+                    timestamp: DateTime.Now,
+                    stackTrace: entry.StackTrace));
+                if (truncated)
+                    Interlocked.Increment(ref _truncatedEntries);
+            }
+            catch
+            {
+                Interlocked.Increment(ref _droppedEntries);
+            }
+        }
+
+        void OnLogMessageReceived(string message, string stackTrace, LogType type)
+        {
+            try
+            {
+                // Strip rich text tags
+                var cleanMessage = BoundMessage(RichTextRegex.Replace(message, string.Empty), out var truncated);
+
+                // COCli-07 attribution: entries produced on the main thread
+                // inside an owned execution window carry that call's ids and
+                // classify as product; everything Unity forwards otherwise
+                // stays source=unity with empty correlation fields.
+                string? correlationId = null;
+                string? operationId = null;
+                var source = LogEntry.SourceUnity;
+                if (MainThread.Instance.IsMainThread && LogCallScope.Current is { } frame)
+                {
+                    correlationId = frame.CorrelationId;
+                    operationId = frame.OperationId;
+                    source = LogEntry.SourceProduct;
+                }
+
+                _logStorage.Append(new LogEntry(
+                    logType: type,
+                    message: cleanMessage,
+                    source: source,
+                    correlationId: correlationId,
+                    operationId: operationId,
+                    timestamp: DateTime.Now,
+                    stackTrace: string.IsNullOrEmpty(stackTrace) ? null : stackTrace));
+                if (truncated)
+                    Interlocked.Increment(ref _truncatedEntries);
+            }
+            catch
+            {
+                Interlocked.Increment(ref _droppedEntries);
+            }
+        }
+
+        string BoundMessage(string message, out bool truncated)
+        {
+            if (message.Length <= MaxMessageCharacters)
+            {
+                truncated = false;
+                return message;
+            }
+            truncated = true;
+            return message.Substring(0, MaxMessageCharacters);
+        }
+
+        public void Dispose()
+        {
+            if (!_isDisposed.TrySetTrue())
+                return; // already disposed
+
+            Application.logMessageReceivedThreaded -= OnLogMessageReceived;
+            // Hand the channel back to whatever sink was installed before this
+            // collector (e.g. the plugin's own collector) instead of clearing
+            // it: a temporary collector must not disable console separation for
+            // the rest of the session. A newer install is left untouched.
+            PluginDiagnostics.RestoreIfCurrent(_channelSink, _previousChannelSink);
+            _previousChannelSink = null;
+            _logStorage.Dispose();
+
+            GC.SuppressFinalize(this);
+        }
+
+// No finalizer: Dispose performs file I/O / Unity static-event unsubscription,
+        // which must never run on the finalizer thread during domain unload
+        // (same crash class as uco-domain-reload-crash-20260919).
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/UnityCopilotPlugin.cs

@@ -26,7 +26,7 @@ namespace com.AtelierAI.Unity.Copilot
 
     public partial class UnityCopilotPlugin : IDisposable
     {
-        public const string Version = "1.0.7";
+        public const string Version = "1.0.8";
 
         private static int _singletonCount = 0;
         public static bool HasAnyInstance => _singletonCount > 0;

package/vendor/plugin/com.atelierai.unity.copilot/package.json

@@ -15,7 +15,7 @@
     "Unity Skills",
     "uco"
   ],
-  "version": "1.0.7",
+  "version": "1.0.8",
   "unity": "2022.3",
   "description": "uco — Unity Copilot: AI Skills, Tools, and CLI for the Unity Engine, driven over plain REST + WebSocket. Any C# method may be turned into a tool by a single line. Derived from IvanMurzak/Unity-MCP (Apache-2.0).",
   "documentationUrl": "https://github.com/DumoeDss/uco-plugin/tree/main/uco-unity-project/Packages/com.atelierai.unity.copilot#readme",