feat: Hot reload keeps one run's assemblies cached between runs, uloop compile returns at once without raising the Editor, and pause point timeouts report their own timeout

[hatayama]

Summary

• This collects 28 pull requests (fix: uloop compile returns as soon as the Editor answers instead of warming execute-dynamic-code first #3227 to fix: A request that Unity keeps answering busy no longer brings the Editor to the front #3231, fix: Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached #3235, fix: The Debug-switch warning says the setting goes back to the startup preference, not that it reverts #3237, feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238, perf: Hot reload asks the compilation pipeline for the assembly list once per domain #3240 to perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258 and fix: The package compiles on Unity 6000.5 and newer, whose Editor ships its own System.Reflection.Metadata #3260) that came out of the third batch of findings from using hot reload on a large multi-assembly project: the floor of the time outside the timed phases and the three steps below it, five steps of the first run after a domain reload, vibe entries that split that run's two remaining phases, two cases where uloop raised the Editor window, the leftover warm-up of uloop compile, four details of the pause-point timeout response and the busy vibe entries, the wording of the Debug-switch warning, hot reload on a Multiplayer Play Mode Virtual Player, a note on a player that quits before uloop loads, the baseline of a package source in such a player, the error envelope of a request that Unity never acknowledged, a cache of the shared compiler worker, a background warm-up after a domain reload that also writes the edited assembly's publicized copy, the baseline of a file edited right after or during a compile, a background start of the shared Roslyn worker after a server reset, and a note on edits that another package's own AssetDatabase.Refresh() compiles.

• Hot reload keeps every assembly one run reads cached for the next run. On the trial project the caller lookup of an apply went from 2.0–2.5 s to 53–59 ms, the time outside the phases from 3.1–3.7 s to 0.7–0.9 s, and one apply from 3.7–4.4 s to 1.4–1.7 s.

• Of the time that remained, hot reload now asks the compilation pipeline for the assembly list once per domain instead of on every run (resolve_inputs, 0.34–0.37 s per run on the trial project), and compares a source with its baseline again only when the file's length or write time changed (sibling_detect, 0.23–0.46 s per run there). The first run after a domain reload that did not rebuild the edited assembly reads that assembly's PDB document list from a file under Library/UloopHotReload/ instead of walking every sequence point again (snapshot_group_state, 0.8–1.2 s cold there). That first run also keeps the assembly list across the import that follows the reload (perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246), compares unchanged siblings from the length and write time recorded with the snapshot instead of reading them (perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245), and reads a referencing assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded (perf: Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded #3247), and keeps each assembly's set on disk so that the first scan after a domain reload does not read those tables again (perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248). The first run after a compile that rebuilt the edited assembly builds the PDB document list from the PDB alone with System.Reflection.Metadata, opening the dll only for its CodeView GUID, instead of reading the whole dll with Cecil (perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249; snapshot_group_state 1774 ms to 288 ms on that run on the trial project, 413–465 ms to 60–62 ms on the development project).

• uloop --project-path <main>/Library/VP/mppm<id> hot-reload --files ... patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies, where it used to fail with "Compiled assembly not found ... hot reload cannot patch it yet".

• uloop compile returns as soon as the Editor answers and never brings the Editor to the front while it waits for compilation to start. A request that Unity keeps answering busy no longer brings the Editor to the front either.

• A timed-out await-pause-point reports its own timeout and the marker id the Editor uses; busy vibe entries name the running tool and the requests sent again.

• With ULOOP_DEBUG, one hot reload run also writes entries that split a cold run's analysis and shim-compile phases: transform worker start and request steps, the worker's own stages, the shim reference list, publicized copies, the shim compiler and the shared Roslyn worker start (feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250). Behaviour is unchanged; the entries are the evidence for the next cold-run work.

• After a domain reload, the first execute-dynamic-code run or hot reload copies the shared Roslyn compiler worker from a cache instead of building it with csc (perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252; assemblyEnsureMs 424 ms to 2 ms on the development project). Hot reload also loads, in the background on the first Editor update tick, the call sites, referenced-method sets and PDB document lists of the assemblies earlier runs edited, so the first run finds them loaded (perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253; on the development project the first run after a compile went from 3024 ms to 2484 ms, caller_notes from 462 ms to 8 ms). The warm-up first writes the publicized copy of each of those assemblies that the shim compile references, so the first run after a compile no longer rewrites it (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254; targetCopyMs 747 ms to 1 ms on the development project, 1012 ms to 5 ms on the trial project). A run that arrives during that warm-up waits only for the dll being read or the copy being written.

• A tool request that reached Unity but was not acknowledged within the attempt's 10-second window is reported as UNITY_NOT_REACHABLE with Retryable: true and SafeToRetry: false, where it used to be INTERNAL_ERROR with Retryable: false and a hint to fix the environment (fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251).

• Hot reload no longer takes an edit made right after uloop compile returned for compiled source: the snapshot of the compiled sources is captured while the new domain loads, before the Editor answers any command (fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255). Before, on the trial project, such an edit made the next run patch every method of the file ("No verified source snapshot"), and a run without --files did not select the file. A file saved while the compile ran, after the compiler had read it, is now checked against the PDB when the snapshot is captured and treated as changed when it does not match (fix: Hot reload no longer silently skips a file saved while the compile was running #3256), where it used to be dropped until the next compile.

• After each server reset, when hot reload's ledger names a compiled assembly, the shared Roslyn worker starts in the background and compiles once against the references the shim compile binds, so the first shim compile finds it running (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258; the first run's shim compileMs went from 801–807 ms to 72–80 ms on the development project, and from 439–493 ms to 118–129 ms on the trial project).

Merge status

• The reporting agent re-tested the head before feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238 on its project: the speed change (fix: Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached #3235) and the behaviour changes (fix: uloop compile returns as soon as the Editor answers instead of warming execute-dynamic-code first #3227, fix: uloop compile no longer brings the Editor to the front while it waits for compilation to start #3228, fix: Pause point timeout details carry the wait's timeout and the marker id, and busy vibe entries name the running tool and the resent requests #3229, fix: A request that Unity keeps answering busy no longer brings the Editor to the front #3231) all behaved as described. The Virtual Player change (feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238) was re-tested on a real player on head 084e1d13: five of the six checks behaved as described, and a source inside a local package patched every method of its file instead of the edited one, a defect in the baseline lookup that fix: Hot reload in a Virtual Player patches only the edited method of a package source #3244 fixes; the re-check on head c328223f confirmed the fix on the real player. See "Verification".
• The cold-run changes perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245 and perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246 were re-measured by the reporting agent on head 62b1236c, and the caller-scan changes perf: Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded #3247 and perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248 on head 1ed19803: the caller scan of the first run after a domain reload went from 4.4–5.9 s to 1.0–1.7 s there (see "Verification"). The PDB read of perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249 was re-measured by the reporting agent on head 7daed1af: the first run after a rebuild of the edited assembly went from 9.8 s to 6.1 s there, with snapshot_group_state from 1774 ms to 288 ms (see "Verification").
• The breakdown entries of feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250 were measured on the development project (see "Verification"); their numbers on the trial project are requested. The envelope change of fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251 is pinned by unit and integration tests against a silent server; it could not be reproduced live, because an Editor whose main thread is busy answers server_busy instead of staying silent.
• The worker cache of perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252 and the warm-up of perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253 and perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254 were re-measured by the reporting agent on heads 4fa78e1b and b200c1ab, each switched off and on in the same session (see "Verification"). fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255 and fix: Hot reload no longer silently skips a file saved while the compile was running #3256 were verified on the development project by their authors and re-checked by the reporting agent on head 57bbb472 (see "Verification"). docs: Note that a package's own AssetDatabase.Refresh compiles saved edits while hot reload holds Auto Refresh #3257 (documentation) was checked on the development project by its author, and perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258 by its author there and by the reporting agent on the trial project on head 88d0ff2c (see "Verification").
• fix: The package compiles on Unity 6000.5 and newer, whose Editor ships its own System.Reflection.Metadata #3260 was added after the Compile Check of this pull request failed on Unity 6000.5: from that version the Editor ships its own copies of the three code-analysis assemblies the package bundles (System.Reflection.Metadata, System.Collections.Immutable, System.Runtime.CompilerServices.Unsafe) and references them from every script assembly, so the bundled copies now step aside there through a define constraint on their importers; older Editors keep using them unchanged. The EditMode suite passed on 2022.3, 6000.3, 6000.5 and 6000.7 with it, and every check of this pull request passes on the new head.
• The repository squash-merges, so these 28 changes become one commit and one release-note line, in the changelogs of the Unity package and the project runner. The title can be reworded at merge time.

User Impact

Speed

Before	After	PR
The cache of compiled assemblies that the caller lookup reads held 64 entries. When the edited assembly was referenced by more assemblies than that (68 on the trial project, 42 MB), every run evicted the same 9 of them (29 MB, the edited assembly among them) and read them again with Cecil on the next run: 2.0–2.5 s per apply, run after run	The cache is bounded by the bytes of the dlls it holds (256 MB). Every assembly one run reads stays cached for the next run; on the trial project the caller lookup takes 53–59 ms and one apply 1.4–1.7 s	#3235
With ULOOP_DEBUG set, the time outside the response's phases (OtherMs) was one number	The Editor-side vibe log gets one hot_reload_timing_detail entry per run that breaks OtherMs into named steps, with the unaccounted remainder, so the next floor can be read from the log instead of instrumented again	#3230
Every run asked CompilationPipeline.GetAssemblies() for the project's assembly list, from five places; on the trial project (558 assemblies) one call took 342–622 ms, still 340 ms warm, and resolve_inputs (337–366 ms per run) was almost entirely that call	The list is fetched once per domain and reused until compilationStarted or projectChanged fires; the startup capture fills it, so the first run after a domain reload is fast too. On the development project (111 assemblies) resolve_inputs went from 62–149 ms to 1–2 ms per run	#3240
Every run read every source of the edited assembly and its baseline snapshot to find siblings that drifted from the compiled state; on the trial project (one assembly, about 1,300 sources, 26 MB) sibling_detect took 228–457 ms per run	A source compared with its baseline once is read and compared again only when its length or last write time changed; the verdict is kept per (snapshot, source) pair for the Editor session and dropped on compilationStarted. A stat of the same files takes 16–19 ms there	#3241
The PDB document list of an assembly lived only in static memory, so every domain reload (uloop compile, a Play Mode reload, an Editor restart) dropped it and the next run read the dll and the PDB with Cecil and walked every type, method and sequence point again, even when the edited assembly had not been rebuilt; on the trial project snapshot_group_state took 0.8–1.2 s on that first run	Each list is also written to Library/UloopHotReload/PdbDocuments/fmt1/<assemblyName>.txt with the same five-value stamp (dll length, write time and MVID; PDB length and write time); the first run after a domain reload reads it when the stamp still matches. On the development project that first run went from 28–30 ms to 3 ms. The run right after recompiling the edited assembly itself still walks, because its stamp changed	#3242
After a compile's domain reload, the import that follows the reload fired projectChanged, which dropped the assembly list the startup capture had just filled, so the first run after every compile asked CompilationPipeline.GetAssemblies() again (resolve_inputs 0.6–0.7 s on that run on the trial project)	The list is dropped by compilationStarted and by an import batch that touches a .cs, .asmdef, .asmref or .dll; the batch that follows a domain reload keeps it. On the trial project resolve_inputs takes 25–53 ms on the first run after a compile	#3246
The verdict memo of #3241 lives in static memory, so the first run after a domain reload read every source of the edited assembly and its snapshot again (sibling_detect 0.75–1.3 s on that run on the trial project)	The snapshot records each source's length and write time in source-stamps.txt beside it when it is captured; the first run after a reload compares stamps and reads only the sources whose stamp changed. A snapshot captured before this change has no stamp file and keeps the byte comparison until the assembly is rebuilt and snapshotted again	#3245
The caller scan read every assembly that references the edited one with Cecil and walked the IL of every method to index its call sites: 67 assemblies (32 MB) on the trial project, 3.4–5.9 s on the first run after a reload, although only one of them calls the edited method	It first reads each referencing assembly's MemberRef table (metadata only) and walks only the assemblies whose table names one of the edited methods; the edited assembly itself is always walked. The sets are kept in memory under the dll's length, write time and MVID	#3247
The sets of #3247 lived only in static memory, so the first caller scan after every domain reload read the MemberRef table of all 67 referencing assemblies again (about 0.8–1.2 s on the trial project)	Each set is written to Library/UloopHotReload/ReferencedMethods/fmt1/<assemblyName>.txt with the dll's length, write time and MVID, and the first scan after a reload reads the file instead of the dll while they match. A missing, truncated, differently stamped or otherwise malformed file is ignored as a whole and rewritten after the dll is read	#3248
When the persisted list of #3242 did not match (the first run after a compile that rebuilt the edited assembly, which with Domain Reload off is every first run), the list was rebuilt by reading the whole dll with Cecil (InMemory, ReadSymbols) and walking every type, method and sequence point: snapshot_group_state 1.2–1.8 s on that run on the trial project (a 10 MB dll with about 1,300 sources)	The list is read from the PDB alone with System.Reflection.Metadata: the method debug information table is walked and every document that a visible sequence point refers to is kept once, in order of first use. The dll is opened only for its CodeView debug directory entry, and a PDB of another build is still rejected before any document is read. On the development project that run went from 413–465 ms to 60–62 ms, on the trial project from 1774 ms to 288 ms	#3249
After every domain reload the shared Roslyn compiler worker that execute-dynamic-code and the hot reload shim compile use was built again with csc, because shutdown deletes its per-process directory: assemblyEnsureMs 400–500 ms on the development project, paid by whichever came first	The built worker assembly is kept under <OS temp>/UnityCliLoopCompilation/RoslynWorkerCache/<key>/, keyed by the worker source and the compiler paths, and copied from there: assemblyEnsureMs 424 ms on the first build, 2 ms after each later reload	#3252
The first run after a domain reload read the edited assemblies' call sites, the referenced-method sets of the assemblies that reference them, and their PDB document lists on its own clock: caller_notes 462 ms and snapshot_group_state 95 ms on the development project, 1.5 s and 0.3 s on the trial project	Every run records its edited assemblies in Library/UloopHotReload/WarmUp/targets.txt. On the first update tick after a domain reload the Editor loads those three for up to 8 of them in the background. On the development project the first run after a compile took 2484 ms instead of 3024 ms, with caller_notes 8 ms and snapshot_group_state 2 ms	#3253
The first run after a compile rewrote and wrote the publicized copy of the edited assembly that its shim compile references, because the compile changed the MVID that keys the copy: targetCopyMs 747 ms on the development project, 858 ms on the trial project	The warm-up writes that copy first, in the background, and the run finds it in the cache: targetCopyMs 1 ms on the development project, 5 ms on the trial project (1012 ms with the warm-up switched off in the same session)	#3254
After a server reset the shared Roslyn worker was not running, so the first hot reload's shim compile started it and loaded its references on the run's clock: shim compileMs 801–807 ms on the development project and 439–493 ms on the trial project	When hot reload's ledger names a compiled assembly, the worker starts in the background after every server reset and compiles once against the references the shim compile binds as they are; the first run's shim compileMs was 72–80 ms and 118–129 ms there	#3258

Edits made around a compile

Before	After	PR
The snapshot of the compiled sources was captured on the Editor's first update tick after a compile's domain reload, which on a large project comes 3–6 s after uloop compile returns. An edit saved in that window was copied as compiled source: the next run warned "No verified source snapshot" and patched every method of the file, and a run without --files did not select it, until the next compile	The snapshot is captured at the end of the Editor's startup, before the domain answers any command. The first update tick and the run capture it only when that capture threw or Unity listed no compilation assembly yet	#3255
A file saved while uloop compile ran, after the compiler had read it, was copied into the snapshot with its new content, so the default file selection, the sibling scan and the skip check compared it as unchanged and the edit was dropped until the next compile	A source written since the compile started, or whose stamp changed while it was copied, is checked against the PDB document checksum at capture. A copy that does not match is marked in source-stamps.txt, and the three readers treat a marked file as changed	#3256

Multiplayer Play Mode

Before	After	PR
uloop --project-path <main>/Library/VP/mppm<id> hot-reload --files ... failed with Compiled assembly not found ... hot reload cannot patch it yet: hot reload looked for the player's DLLs under the player's own Library/ScriptAssemblies, which does not exist, and resolved relative assembly references against the process's current directory	The player's edit is patched from the main project's Library/ScriptAssemblies, while the player keeps its own hot reload state (patch ledger, source snapshots, publicized copies, worker cache) under its own Library/UloopHotReload/. When the main project has never compiled the assembly, the failure says to compile the main Editor's project first	#3238

uloop compile

Before	After	PR
After a successful compile the command sent get-version and then an execute-dynamic-code probe before returning, showed a Warming execute-dynamic-code after compile... spinner, and printed warning: post-compile warmup skipped: ... when the probe did not go through	The command returns as soon as the Editor answers with the compile result. The first execute-dynamic-code after a compile pays its own settle time	#3227
While the command waited for compilation to start, ten seconds without Editor activity brought the Editor window to the front once	The window order stays as it is for the whole wait	#3228

Editor focus

Before	After	PR
A plain tool request that Unity kept answering server_busy for five seconds, because another command was running, brought the Editor to the front	The request keeps being resent once a second within the 10-second window and returns the BUSY error when the window runs out, without touching the window order. The other focus reasons (pre-accept timeout, main-thread stall, heartbeat silence) are unchanged	#3231

Pause points

Before	After	PR
A timed-out await-pause-point --timeout-seconds 5 reported Details.TimeoutSeconds: 30 (the marker's window) while its message said 5 s	Details.TimeoutSeconds is the wait's own timeout; the marker's window moves to Details.MarkerTimeoutSeconds	#3229
Details.Id of that failure echoed the typed path form (./Assets/Foo.cs:42), which differs from the id the status command reports	It carries the marker id as the Editor normalized it (Assets/Foo.cs:42)	#3229
The warning after the automatic Debug switch said the setting "reverts on every Editor restart", which reads as "goes back to Release"; an Editor whose per-user "Code Optimization On Startup" preference is Debug comes back in Debug	It says the setting goes back to that preference (Release unless the preference was changed); the troubleshooting reference, the soak-testing doc and a code comment say the same	#3237

Logs (with ULOOP_DEBUG)

Before	After	PR
The CLI's cli_hot_reload_busy_wait_complete entry did not say which requests were sent again during the wait	It lists their correlation ids (resend_correlation_ids, an empty array when none)	#3229
A busy cli_tool_request_failed entry did not say which tool held the Editor	It names it (running_tool_name)	#3229
Nothing recorded when the call-site cache had to evict entries at the end of a run	One hot_reload_call_site_cache_evicted entry with the evicted count and bytes, the bytes still cached, and the budget	#3235
AnalysisMs and ShimCompileMs were two numbers, with nothing inside them measured	Per run: hot_reload_worker_request_timing (one per transform worker request: gate wait, launch target resolution, input write, process spawn, response wait, output read, whether the request started the worker, and the worker's own stages), hot_reload_signature_gate_timing, hot_reload_shim_first_compile_timing, hot_reload_shim_references_timing, hot_reload_shim_compiler_timing; and only when they happen, hot_reload_publicized_copy_written and dynamic_code_shared_worker_started (ready false when the start failed)	#3250
dynamic_code_shared_worker_started did not say where the worker assembly came from	It carries workerAssemblySource (existing, cache or built), cachePublish and cachePublishError	#3252
hot_reload_timing_detail showed the first run's loads inside caller_notes and snapshot_group_state only	Each domain reload writes one hot_reload_warm_up_complete (the target assemblies, each item's outcome and time in the order publicized_targets, call_sites, referenced_method_sets, pdb_documents, and cancelledBy) or hot_reload_warm_up_skipped (its reason), and a run's steps gain warm_up_yield and warm_up_targets. A copy the warm-up writes also appears as hot_reload_publicized_copy_written	#3253, #3254
Nothing recorded when the source snapshot was captured	hot_reload_source_snapshot_captured, once per domain, with trigger (domain_load, first_update_tick or apply) and captureMs	#3255
Nothing recorded about sources saved after a compile started	hot_reload_source_snapshot_checked, per assembly whose capture checked any source against the PDB, with suspect, editedAfterCompile and checkMs	#3256
Nothing recorded about a background start of the shared Roslyn worker	After each server reset, dynamic_code_shared_worker_warm_up_skipped with its reason, or dynamic_code_shared_worker_warm_up_complete with ms, referencesMs, mainThreadMs, warmMs, referenceCount, outcome (answered, already_running, start_failed, request_failed or failed), failureReason and errorCount	#3258

Error envelopes

Before	After	PR
A plain tool request that connected and was written, but got no "accepted" answer from Unity within the attempt's 10-second window, was printed as ErrorCode: INTERNAL_ERROR, Phase: execution, Retryable: false, SafeToRetry: false, with the raw i/o timeout message and the hint to fix the local environment or command input	It is printed as ErrorCode: UNITY_NOT_REACHABLE, Phase: response_waiting, Retryable: true, SafeToRetry: false, Details.Cause carrying the timeout, and NextActions that say Unity may have received the request and to retry only after confirming the previous command did not run or has finished	#3251

Behaviour changes to weigh before merging

1. uloop compile no longer probes execute-dynamic-code after a successful compile (fix: uloop compile returns as soon as the Editor answers instead of warming execute-dynamic-code first #3227). A script that runs uloop execute-dynamic-code right after uloop compile sees the settle time of the domain reload in that command instead of in compile.

2. Two of the focus rescues are gone (fix: uloop compile no longer brings the Editor to the front while it waits for compilation to start #3228, fix: A request that Unity keeps answering busy no longer brings the Editor to the front #3231). uloop compile never raises the Editor while waiting for compilation to start, and a request that Unity keeps answering busy never raises it. If the Editor is genuinely stuck behind a dialog, the remaining reasons (pre-accept timeout, main-thread stall, heartbeat silence) still bring it forward.

3. Details.TimeoutSeconds of a timed-out await-pause-point changed meaning (fix: Pause point timeout details carry the wait's timeout and the marker id, and busy vibe entries name the running tool and the resent requests #3229). It is now the wait's --timeout-seconds; anything that read the marker's window from it must read Details.MarkerTimeoutSeconds.

4. The call-site cache may hold up to 256 MB of dll bytes in the Editor process between runs (fix: Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached #3235), where it held 64 entries before. The bound counts file lengths, not the exact in-memory size, and nothing is evicted while a run is in progress, as before.

5. With ULOOP_DEBUG set, the Editor-side vibe log gets one more entry per hot-reload run (feat: Hot reload writes a timing detail vibe entry that breaks down the time outside the response's phases #3230) and, only when the cache had to evict, one hot_reload_call_site_cache_evicted (fix: Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached #3235). Nothing is written without the define.

6. Hot reload resolves a project's compiled assemblies through one layout (feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238). A Virtual Player root (<main>/Library/VP/<player>) reads the main project's Library/ScriptAssemblies; an ordinary root reads its own, as before. Relative entries of an assembly's allReferences are resolved against the project root instead of the process's current directory; for an ordinary project, whose Editor runs with the project root as its current directory, the files are the same. An assembly whose reported outputPath does not lead to the DLL the layout built now fails as a missing compiled assembly that names both paths.

7. The compilation assembly list is kept per domain (perf: Hot reload asks the compilation pipeline for the assembly list once per domain #3240, perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246). CompilationPipeline.GetAssemblies() is called once per domain and the answer reused until compilationStarted fires or an import batch touches a .cs, .asmdef, .asmref or .dll; an empty answer is never kept. perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246 replaced the projectChanged subscription with that import check, because the import that follows a compile's domain reload fires projectChanged after the startup capture and dropped the list on every first run. An import of other assets only, and the batch that follows a domain reload, keep the list; a change that fires no import of those files leaves hot reload with the earlier list until the next compile.

8. A source compared with its baseline once is compared again only when its length or last write time changes (perf: Hot reload compares a sibling with its snapshot again only when the file's length or write time changed #3241). This applies wherever a source is compared with its baseline: finding drifted siblings, deciding which live patches to re-apply after a skip, and selecting files when --files is omitted. A rewrite that keeps both, for example a copy that preserves timestamps, is noticed only after the next domain reload.

9. One small file per assembly appears under Library/UloopHotReload/PdbDocuments/fmt1/ (perf: Hot reload keeps the PDB document list of an assembly across domain reloads #3242). A missing, truncated, hand-edited or differently stamped file is treated as absent: the PDB is walked and the file rewritten (temp file, then move). A walk that throws leaves no entry and no file. A failure to read or write that file (a locked file, an unwritable Library) surfaces as the run's error instead of being ignored, like the other files hot reload keeps under Library/UloopHotReload/.

10. Hot reload in a Virtual Player finds the baseline of a package source (fix: Hot reload in a Virtual Player patches only the edited method of a package source #3244). The physical path of a package source is made relative to the root of the project that compiled the assembly, which for a Virtual Player is the main project, instead of the player's own root. The lookup key now matches the ./-prefixed relative path the main Editor's compile records, so only the edited method is patched. The match rule stays one-directional and the snapshot key is unchanged. An ordinary project resolves to its own root as before.

11. Each source snapshot directory gets a source-stamps.txt (perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245), written with the snapshot and read on the first run after a domain reload. A missing, truncated or differently formed file means the byte comparison of perf: Hot reload compares a sibling with its snapshot again only when the file's length or write time changed #3241's cold path, never a stale verdict. A source rewritten with the same length and write time is read as unchanged until the next snapshot, the same limit as perf: Hot reload compares a sibling with its snapshot again only when the file's length or write time changed #3241's memo.

12. The caller scan no longer reads an assembly whose MemberRef table names none of the edited methods (perf: Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded #3247). The scan result gains SkippedScanAssemblyNames (diagnostic, like ExaminedCallSiteCount); MissingScanAssemblyNames keeps its meaning, so the lifecycle notes and the signature-change closure behave as before. The Editor holds one more static memo (one key set per dll, dropped with the domain). Keys are kept for every assembly scope on purpose: limiting them to project assemblies would build an empty set while Unity compiles and hide real callers.

13. Hot reload keeps one more file per referencing assembly under Library/UloopHotReload/ReferencedMethods/fmt1/ (perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248), written with a temp file and a move after the dll is read, and read only when its stamp matches the dll. A set is never used in part: any malformed file means the dll is read and the file rewritten. A file that cannot be written surfaces as the run's error, like the other files under Library/UloopHotReload/. The trial project's 67 referencing assemblies are estimated at 5–8 MB of such files.

14. The shared hot reload assembly now runs System.Reflection.Metadata in the Editor domain (perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249). It references the bundled UnityCliLoop.System.Reflection.Metadata, UnityCliLoop.System.Collections.Immutable and UnityCliLoop.System.Runtime.CompilerServices.Unsafe plugins that the dynamic code assembly already lists; before, only the out-of-process workers used them. The PDB document list keeps its meaning (documents with at least one visible sequence point, once each), but the documents now come in method token order instead of type-then-method order, and a PDB of another build throws InvalidOperationException where Cecil threw SymbolsNotMatchingException; no caller catches either. A dll without a CodeView debug directory entry throws too (Unity's compiler always writes one).

15. With ULOOP_DEBUG set, the Editor-side vibe log gets up to seven more entries per hot reload run (feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250), and the transform worker's output JSON gains a timings array (read only by that entry; output of an older worker leaves it null). Nothing is written without the define, and hot_reload_timing_detail keeps its shape, so unaccountedMs keeps its meaning.

16. The project runner wraps a dispatched, unacknowledged timeout in UnityServerNotRespondingError (fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251). The wrap happens in the retry loop after the focus handling, for the pre_accept_timeout focus reason only; it does not depend on whether a Unity process was found, and it is applied even when the caller has cancelled (that path never checked cancellation before either). The raw timeout stays in the error's unwrap chain, so IsFinalResponseTimeoutError and the CLI vibe log's error_kind (final_response_timeout) are unchanged. An accepted timeout, a disconnect, an RPC error, an editor-unresponsive error and an undispatched failure are reported as before. cli/common is untouched, so the shared release inputs are not stamped.

17. The shared Roslyn compiler worker assembly is cached in OS temp across domain reloads and Editor restarts (perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252). One file per key under <OS temp>/UnityCliLoopCompilation/RoslynWorkerCache/<key>/, written with a temp file and a move and never cleaned up; a Unity upgrade or a changed worker source makes a new key. A worker assembly already in the per-process directory is used as is and never published. A cache copy that fails with an IO error falls back to the build, and a publish that fails still starts the worker and records the error in cachePublishError; this is the one place in the branch where an IO error is not the command's error, because the assembly is already built. A toolchain whose files change while their paths stay the same is not detected.

18. Hot reload works in the background after every domain reload (perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253, perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254). On the first Editor update tick after a reload, unless the Editor is compiling or importing, it works on a pool thread for up to 8 assemblies from Library/UloopHotReload/WarmUp/targets.txt whose dll and PDB exist, one kind of work after another: it writes their publicized copies under Library/UloopHotReload/PublicizedRefs/ (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254), then reads their call sites, the referenced-method sets of the referencing assemblies and their PDB document lists. A project that never ran hot reload has no such file and reads nothing. A domain reload, a compile start and a service replacement stop it. A hot reload run first stops it before its next dll and waits for the dll being read (step warm_up_yield), whose result it reuses; an item stopped that way is reported cancelled. Every run records its edited assemblies in that file (step warm_up_targets, most recent first, up to 32 names), and a failure to write it fails the run, like the other files under Library/UloopHotReload/. No macOS activity is held while it runs. Writes of rewritten reference copies go through one lock per Editor process (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254); a run never overlaps the warm-up, so the lock only orders a test run that starts while the warm-up still writes. A Cecil resolution or IO error while writing a copy marks that item failed and the later items still run; any other error stops the remaining items and is logged to the Console, and a run on the same assembly fails the same way. A transform worker request that failed on parse errors now keeps the worker's own stage times (workerSteps).

19. The source snapshot is captured in the Editor's startup, before the domain answers its first command (fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255). The capture moved from the first update tick to the last statement of the [InitializeOnLoadMethod] startup, so its time (431 ms on the development project, 1.2–1.9 s on the trial project) is spent before the IPC server answers instead of right after, and a uloop compile returns that much later; the same capture ran on the first update tick before, so the main thread is busy for the same time in total. It does not run in an Asset Import Worker. A capture that throws is logged by Unity as a startup exception and retried on the first update tick; a capture that finds no compilation assembly is no longer marked done, so a later reader captures again.

20. The snapshot's source-stamps.txt moves to format version 2 (fix: Hot reload no longer silently skips a file saved while the compile was running #3256). Each line gains a fourth field, 0 or 1; a version 1 file reads as empty, so the first run after updating compares sources by bytes until the next compile rewrites it. The compile start is kept in SessionState from compilationStarted; with no record (the first compile after an Editor start), only sources written after the dll are checked. A mark stays until the next compile, even if the edit is reverted. A file with no method bodies (an interface, an enum, constants) has no PDB document, so when it is saved after a compile started it is marked even if the compile read the saved content, and a run without --files selects it. The method-diff baseline is unchanged; its mismatch warning now names the usual cause ("most often the file was saved after the compile had read it").

21. The shared Roslyn worker starts after every server reset in a project whose hot-reload ledger names a compiled assembly (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258). It is a dotnet child process that stays running until the next reset, domain reload or quit, as it does after a first compile today; before, it started only at the first compile. The warm-up compiles a one-class source in the background, holds the worker's compile gate for that compile (about 0.8 s on the development project), and reports a failed start or request only to the vibe log, leaving the Console error to the next real compile; an unexpected exception is logged to the Console. Projects without a ledger are unchanged.

Not covered

• Before perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252 and perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253, the first run after a domain reload on the trial project took 5.4–6.1 s on head 7daed1af (5.7–9.8 s on 1ed19803; warm runs 1.0–1.3 s). caller_notes was down to 1.3–1.5 s, of which the edited assembly's own walk (about 1 s there) stayed, because its call sites are MethodDef rows that no MemberRef table names; perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253 moves that walk and the 288 ms of snapshot_group_state after a rebuild (perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249) to the background warm-up, when the run comes after it. The three phases themselves (AnalysisMs 1.3–1.5 s, ShimCompileMs 2.2–2.4 s, PatchMs 0.07–0.13 s, against 0.57 s, 0.13 s and 0.09 s warm) were the largest part of that run; perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252 takes the worker assembly build out of ShimCompileMs. Reading each file's MVID (ReadAssemblyMvid, the whole dll) is unchanged.
• A snapshot captured before perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245 has no stamp file; the first run after a reload keeps reading its sources until the assembly is rebuilt and snapshotted again (752 ms on the trial project). No stamp file is written for an existing snapshot.
• Pause points in a Virtual Player still join <project root>/Library/ScriptAssemblies; the Debug switch and recompile need their own design there (feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238). A new source added in a Virtual Player was checked on a real player and applied as an introduced type. A source inside a local package lost its baseline in a Virtual Player (every method of the file was patched, see "Verification"); fix: Hot reload in a Virtual Player patches only the edited method of a package source #3244 fixes it; the re-check on head c328223f applied only the edited method in the player, and the player reports the same normalized absolute PackageInfo.resolvedPath as the main Editor.
• Still open from the earlier batches: a 29-minute compile seen once on the trial project, not reproduced since fix: Commands no longer run several times slower while the Unity Editor stays in the background on macOS #3200. The 30 s busy refusal of the first pause-point recovery compile turned out to be the CLI polling a server that was unreachable during the Debug-switch recompile, not a bug.
• Seen twice on real Virtual Players, not explained: right after an apply, a player stopped answering tool requests for about 10–30 s (no Editor-side vibe entry in that window), and the CLI reported the unacknowledged request as INTERNAL_ERROR with Retryable: false; the same request sent again a few seconds later succeeded. fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251 fixes the classification. The stall itself coincided with a machine load average above 100; the reporting agent tried to reproduce it on head 7daed1af at a load average below 32 (one player, five applies; then three players at once, three applies plus one with the original check sequence, each followed by 60 s of two-second probes) and saw no stall and no failed probe.
• The time inside the analysis and shim-compile phases of a cold run is now measured (feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250) and only partly reduced. On the development project a cold run's shim compile split into the shared Roslyn worker start (about 1.1 s, of which the 0.5 s of making sure the worker assembly exists is gone with perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252) and the publicized copy of the rebuilt assembly (0.7 s, the write dominating); its analysis into the transform worker's spawn and start-up (about 0.1 s) and the worker's own cold stages (0.2 s). The shared Roslyn worker start is moved to a background warm-up after each server reset (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258); the transform worker start is not warmed up yet. The publicized copy of the edited assembly is (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254); the copies of the other project assemblies a shim compile references are still written by the run. On the trial project a cold run's transform worker requests took about 0.56 s longer than a warm run's (the prepare request 353 ms, the transform request about 210 ms).
• On Windows, if a compile that started after a warm-up item began finishes while that item still reads a dll, Unity's copy into Library/ScriptAssemblies can fail on the item's read handle: the call-site reader opens the file with FileShare.Read. The window is one dll, because a compile start keeps the warm-up from reading the next one (perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253). Not verified on Windows.
• The check of fix: Hot reload no longer silently skips a file saved while the compile was running #3256 compares file write times with the recorded compile start. On file systems with coarse write times (FAT 2 s, HFS+ 1 s), or when the file clock and the system clock disagree, a save near the compile start can fall on the wrong side. Whether compilationStarted fires in a Multiplayer Play Mode Virtual Player is not verified; if it does not, the check there starts at the dll's write time.
• Seen on the trial project and traced with its Editor log: an editor package in that project copies files under Assets/ after every domain reload and then calls AssetDatabase.Refresh() itself. That refresh imports any script saved since the last compile, so an edit saved a few seconds after a compile's domain reload was compiled by the Editor on its own (4 of 4 tries, with and without the warm-up; an edit saved 35 s after was not). Patches applied before that compile end at its domain reload, and the compiled code contains the edit. A hot reload that meets the compile is refused and sent again once the Editor settles. Nothing in uloop starts that refresh. The Auto Refresh hold does not stop such an explicit call: on the development project an AssetDatabase.Refresh() sent while the hold was armed compiled a saved edit and reloaded, and the hold was released only after that reload. The skill's lifecycle reference now says so (docs: Note that a package's own AssetDatabase.Refresh compiles saved edits while hot reload holds Auto Refresh #3257).

Included pull requests

PR	Title
#3227	uloop compile returns as soon as the Editor answers instead of warming execute-dynamic-code first
#3228	uloop compile no longer brings the Editor to the front while it waits for compilation to start
#3229	Pause point timeout details carry the wait's timeout and the marker id, and busy vibe entries name the running tool and the resent requests
#3230	Hot reload writes a timing detail vibe entry that breaks down the time outside the response's phases
#3231	A request that Unity keeps answering busy no longer brings the Editor to the front
#3235	Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached
#3237	The Debug-switch warning says the setting goes back to the startup preference, not that it reverts
#3238	Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies
#3240	Hot reload asks the compilation pipeline for the assembly list once per domain
#3241	Hot reload compares a sibling with its snapshot again only when the file's length or write time changed
#3242	Hot reload keeps the PDB document list of an assembly across domain reloads
#3243	Explain why a Multiplayer Play Mode player can quit with a Fatal Error before uloop loads
#3244	Hot reload in a Virtual Player patches only the edited method of a package source
#3245	Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings
#3246	Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload
#3247	Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded
#3248	Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method
#3249	Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll
#3250	Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time
#3251	A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error
#3252	The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it
#3253	The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded
#3254	The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy
#3255	Hot reload no longer mistakes an edit made right after compile for compiled source
#3256	Hot reload no longer silently skips a file saved while the compile was running
#3257	Note that a package's own AssetDatabase.Refresh compiles saved edits while hot reload holds Auto Refresh
#3258	The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded
#3260	The package compiles on Unity 6000.5 and newer, whose Editor ships its own System.Reflection.Metadata

Each pull request's description holds its own behaviour changes, mutation checks and "Not changed" list.

Changes

• Unity package: the call-site cache (HotReloadCompiledCallSiteCache, byte budget and eviction entry), the timing detail entry (HotReloadRunTiming, HotReloadTimingDetailPayload, HotReloadOrchestratorLog), the group file-list helper split out of the group processor for file length, the compiled-assembly layout (CompiledAssemblyLayout in Common.ScriptPath, replacing HotReloadVirtualPlayerProject.IsVirtualPlayerProjectRoot; the eight Library/ScriptAssemblies joins of hot reload go through it, and HotReload.Patching now references Common.ScriptPath), the outputPath check (HotReloadCompiledAssemblyPathCheck), the baseline loader's lookup root (HotReloadSourceBaseline relativizes a package source's physical path against the layout's main project root), the per-domain assembly list (HotReloadCompilationAssemblies over HotReloadCompilationAssemblyCache; the five call sites read it instead of CompilationPipeline.GetAssemblies()), and the baseline verdict memo (HotReloadSiblingVerdictCache, read and written by HotReloadChangedSiblingSourceDetector), the persisted PDB document lists (HotReloadPdbDocumentIndex takes its persistence directory; HotReloadConstants.PdbDocumentsRelativeDirectory), the source stamp manifest (HotReloadSourceStampManifest, written by HotReloadSourceSnapshotter and read by HotReloadChangedSiblingSourceDetector, perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245), the import-batch check that replaces the projectChanged subscription (HotReloadCompilationAssemblyListPostprocessor, perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246), the referenced-method index (HotReloadReferencedMethodIndex, consulted by HotReloadCallSiteScanner; HotReloadCallSiteScanResult.SkippedScanAssemblyNames; HotReloadCompiledCallSiteCache.ReadFingerprint shared, perf: Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded #3247; the index takes its persistence directory and gains PersistedLoadCount, HotReloadConstants.ReferencedMethodsRelativeDirectory, perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248), and the PDB read of the document index (HotReloadPdbDocumentIndex.ReadDocuments reads the PDB with MetadataReaderProvider and the dll's debug directory with PEReader; the shared hot reload asmdef adds the three System.Reflection.Metadata plugins to its precompiled references, perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249), and the cold-run breakdown entries (TransformWorkerRequestTiming attached to every TransformWorkerHostResult at the single exit of TransformWorkerHost.RunAsync; WorkerRequestTimings and the timings output field in the transform worker; timing entries in HotReloadGroupProcessor, HotReloadShimFirstCompile, HotReloadShimReferenceBuilder, ReferencePublicizer, HotReloadShimCompiler and SharedRoslynCompilerWorkerHostProcess, feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250), the shared Roslyn compiler worker's assembly cache (SharedRoslynCompilerWorkerAssemblyCache, used by SharedRoslynCompilerWorkerSession.EnsureWorkerAssemblyBuiltAsync, and the new fields of dynamic_code_shared_worker_started, perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252), and the warm-up after a domain reload (the HotReloadWarmUp facade and its call-site, referenced-method and PDB document items, the target ledger HotReloadWarmUpTargetLedger, the context source, the editor hooks that stop it, Preload on the referenced-method and PDB document indexes, and the orchestrator's warm_up_yield and warm_up_targets steps, perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253), and the warm-up's first item, which writes the edited assemblies' publicized copies (HotReloadPublicizedTargetWarmUpItem), with the lock that serializes ReferencePublicizer's copy writes (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254), the snapshot capture at the end of the Editor startup (FirstPartyToolsEditorStartup.PrepareBeforeServingCommands, fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255), and the compile start record, the PDB check at capture and the manifest's mark (HotReloadCompileStartRecord, HotReloadSnapshotSourceCheck, HotReloadSourceStampManifest format 2, fix: Hot reload no longer silently skips a file saved while the compile was running #3256), and the shared-worker warm-up (SharedRoslynCompilerWorkerWarmUp, started by DynamicCodeServicesRegistry.ResetServerScopedServices; the host's WarmUpAsync and SharedWorkerWarmUpOutcome; the ToolContracts port SharedCompilerWarmUpCoordination, set by the hot-reload startup to HotReloadSharedCompilerWarmUpReferenceSource; HotReloadShimReferenceBuilder.ClassifyCompileReferences, shared with the run; ExternalCompilerPathResolver split into resolving and reporting, with ResolveWithoutReporting, perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258).
• Project runner (Go): the compile command's post-compile warm-up and compile-start focus, the busy-stall focus of the connection retry, the pause-point timeout details, the busy vibe entries, the Debug-switch warning text, and the wrap of a dispatched, unacknowledged timeout in finishNonRetryableConnectionAttempt (fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251).
• Docs: docs/vibe-logs.md (new entries and fields), ADR 0012 (the removed busy-stall focus), docs/soak-testing.md and the pause-point troubleshooting reference (the startup preference), the Multiplayer Play Mode reference's hot reload section and the hot reload scope table (feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238), and the scope reference's baseline paragraph (when a source is compared with its baseline again, perf: Hot reload compares a sibling with its snapshot again only when the file's length or write time changed #3241), and docs/hot-reload.md's list of what hot reload keeps under Library/UloopHotReload/ (perf: Hot reload keeps the PDB document list of an assembly across domain reloads #3242, perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245, perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248), docs/vibe-logs.md's list of the breakdown entries (feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250), and a section of the Multiplayer Play Mode reference on a player that quits a few seconds after activation with Fatal Error! Compilation Pipeline: Could not read file Packages/<package>/<path>.asmdef (docs: Explain why a Multiplayer Play Mode player can quit with a Fatal Error before uloop loads #3243): the player restores packages from the main project's Library/PackageManager/ProjectCache, which is absent when the main Editor's own package resolution failed, so uloop never loads in it; the fix is on the main project's dependencies. docs/hot-reload.md gains the warm-up paragraph and docs/vibe-logs.md the warm-up entries, the order of the warm-up items and the worker cache fields (perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252, perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253, perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254). docs/vibe-logs.md gains the snapshot capture and check entries (fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255, fix: Hot reload no longer silently skips a file saved while the compile was running #3256); docs/hot-reload.md and the hot reload scope reference describe the mark of a file saved during a compile (fix: Hot reload no longer silently skips a file saved while the compile was running #3256). The hot reload lifecycle reference says that the Auto Refresh hold does not stop a package's own AssetDatabase.Refresh() (docs: Note that a package's own AssetDatabase.Refresh compiles saved edits while hot reload holds Auto Refresh #3257). docs/hot-reload.md gains the shared-worker warm-up and docs/vibe-logs.md its two entries (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258).
• No change to the dispatcher, the protocol version, the project runner pin, the shared release inputs, the tool catalog or the coverage baseline.

Verification

• Per pull request: each was verified locally with unit tests and, where behaviour in the Editor changed, end-to-end checks and mutation checks; the results are in each description. Each was reviewed by an advisor before the merge into this branch. Pull requests to the integration branch do not trigger the full CI.
• Re-tests by the reporting agent, on its own project with a runner built from this branch:
  • Head f3daae7e (fix: uloop compile returns as soon as the Editor answers instead of warming execute-dynamic-code first #3227 to feat: Hot reload writes a timing detail vibe entry that breaks down the time outside the response's phases #3230): the timing detail entry matched the response's Timing to within 5–21 ms per run and showed the caller lookup at 2.0–2.5 s of a 3.1–3.7 s OtherMs. A diagnostic in the Editor confirmed the cause: 68 assemblies to scan against a 64-entry cache, 9 of them (29 MB) read again on every run, the fingerprint pass itself 1–3 ms.
  • Head d872b6d6 (adds fix: A request that Unity keeps answering busy no longer brings the Editor to the front #3231 and fix: Hot reload's call-site cache is bounded by bytes instead of a count, so one run's assemblies stay cached #3235): after a warm run, no assembly of the scan set was missing from the cache, a run read no dll again (load count unchanged), the end of the run evicted nothing and wrote no eviction entry; the caller lookup took 53, 53 and 59 ms over three applies, OtherMs 935, 805 and 725 ms, and one apply 1676, 1364 and 1367 ms.
  • Head d872b6d6, behaviour checks: uloop compile printed no warm-up spinner or warning and an execute-dynamic-code sent right after it succeeded; with another application in front, neither a compile nor a plain tool request that the busy Editor kept refusing (BUSY after the 10-second window) brought the Editor forward, and the CLI vibe log had no busy_stall or compile_start_stall focus entry; a timed-out await-pause-point --timeout-seconds 5 reported TimeoutSeconds 5, MarkerTimeoutSeconds 30 and the asset-path Id; the busy cli_tool_request_failed entry named the running tool, and the cli_hot_reload_busy_wait_complete entry carried resend_correlation_ids (an empty array, as no request had to be sent again during that wait).
  • Virtual Player (feat: Hot reload patches a Multiplayer Play Mode Virtual Player by reading the main project's compiled assemblies #3238), checked by the reporting agent on a real player on head 084e1d13. Its first attempt on head 00b4a896 did not reach hot reload: the player's Editor exited during its initial asset database refresh with Compilation Pipeline: Could not read file Packages/<package>/Editor/<name>.asmdef. The cause was on the project's side: a file: dependency pointed into a git submodule that was not initialized, so the main Editor's package resolution had failed and left no Library/PackageManager/ProjectCache for the player to restore from (docs: Explain why a Multiplayer Play Mode player can quit with a Fatal Error before uloop loads #3243 documents this). After initializing the submodule the player started and uloop reached Ready in it after about 1.5 minutes. Results: (1) an edit sent to the player is Applied with the player's ActivePatchTotal at 1 and the main Editor's at 0; (2) the patched method logs in the player only; (3) a uloop compile on the main Editor reloads the player and its ActivePatchTotal returns to 0; (4) with the main project's DLL renamed away, the player fails with the "Compile the main Editor's project first" wording and the Virtual Player RecommendedNextAction; (5) the main project's Library/UloopHotReload is not written by the player's apply, and the player's own SourceSnapshot holds the snapshots; (6) a new source with one new type is applied as an introduced type without any sentence pointing at the player's own Library (the first send of this check timed out after 10 seconds with no record on the Editor side and succeeded when resent; seen once, not explained); (7) a source inside a file: local package came back PartiallyApplied with every method of the file patched and the warning "has no compiled method body, so there is no baseline for edited-method detection", although the player's snapshot of the assembly exists. The cause is in HotReloadSourceBaseline: the PDB document is looked up by the physical path made relative to the player's root, and a package folder under the main project is outside that root, so the lookup uses an absolute path that the relative document the main Editor's compile recorded never matches. fix: Hot reload in a Virtual Player patches only the edited method of a package source #3244 fixes it by making the physical path relative to the main project's root, which compiled the assembly. Re-checked on head c328223f: the same edit sent to the player is Applied with 1 patched and 19 unchanged methods, no skipped accessor and no warning, exactly as when sent to the main Editor; PackageInfo.resolvedPath reported inside the player is identical to the main Editor's, a normalized absolute path under the main project rather than under the player's root, so the case the change assumes away does not occur there.
  • Two Virtual Players at once, checked by the reporting agent on head 1ed19803: an edit sent to one player patched that player only, the same edit sent to both at once patched both independently, a uloop compile on the main Editor reloaded both players and cleared their patches, and one edit sent to the main Editor and both players at once was Applied on all three (6.6–11.8 s each, against 1.6–1.7 s when sent to one player at a time; the extra time is outside the phases). Right after that last apply one player did not answer tool requests for about 30 s (see "Not covered").
  • resolve_inputs and sibling_detect (perf: Hot reload asks the compilation pipeline for the assembly list once per domain #3240, perf: Hot reload compares a sibling with its snapshot again only when the file's length or write time changed #3241), re-measured by the reporting agent on head 084e1d13 with three consecutive runs of the same one-method edit at a one-minute load average of 22 to 27: run 1, the first apply after a compile that rebuilt the edited assembly, took resolve_inputs 594 ms, sibling_detect 749 ms, snapshot_group_state 1106 ms, caller_notes 3810 ms, 9266 ms in total; runs 2 and 3 took 5 ms, 50 to 52 ms, 2 to 4 ms, 66 to 190 ms, and 1092 to 1286 ms in total. The same runs at a load average of 71 to 94 showed 86 ms and 198 ms on run 2, so the two steps still scale with machine load on their first warm run. The persisted PDB document list (perf: Hot reload keeps the PDB document list of an assembly across domain reloads #3242) was measured in this repository's Editor only (first run after a reload that kept Assembly-CSharp.dll: 30 and 28 ms without the file, 3 and 3 ms with it); on head c328223f the reporting agent measured it: after a compile of an unrelated Editor-only assembly that left the edited assembly's DLL untouched, the first run's snapshot_group_state fell from 1165 ms (on 084e1d13, without the file) to 65 ms with the persisted list, which that run read without rewriting it; the other first-run steps (resolve_inputs 704 ms, sibling_detect 655 ms, caller_notes 3654 ms) are rebuilt per domain and are unchanged by perf: Hot reload keeps the PDB document list of an assembly across domain reloads #3242. That project runs with Domain Reload off, so there the saving applies to compiles of other assemblies and Editor restarts.
  • Cold run (perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245, perf: Hot reload keeps its compilation assembly list across the import that follows a compile's domain reload #3246), re-measured by the reporting agent on head 62b1236c at a one-minute load average of 4 to 12, two ways. With the edited assembly's dll unchanged by the reload (a checkout of the edited file followed by uloop compile): resolve_inputs 53 ms (611 ms on 084e1d13), sibling_detect 752 ms because that snapshot predated perf: Hot reload records each source's length and write time with its snapshot, so the first run after a domain reload does not read unchanged siblings #3245 and had no stamp file, snapshot_group_state 49 ms, caller_notes 5897 ms, 9657 ms in total. With the dll rebuilt by the compile: 25 ms, 72 ms (the snapshot and its stamp file had been captured by the startup capture that follows that compile's reload), 1298 ms (the PDB walk after a rebuild, unchanged), 4438 ms, 9677 ms in total. The warm runs that followed took 1078 and 1678 ms. A third attempt, meant to reload without rebuilding the dll, ended up rebuilding it (the edit left on disk was compiled when the Auto Refresh hold was released after the reload) and measured sibling_detect 95 ms on a stamped snapshot. Every run was Applied with one patched method and no warning, and the Editor never came to the front.
  • Caller scan (perf: Hot reload's caller scan reads an assembly's MemberRef table before walking it, so assemblies that name none of the edited methods are not loaded #3247, perf: Hot reload keeps each assembly's referenced-method set on disk, so the first caller scan after a domain reload reads only assemblies that name an edited method #3248), re-measured by the reporting agent on head 1ed19803 at a one-minute load average of 5 to 17, three ways. After a compile that rebuilt the edited assembly's dll and none of the 559 other dlls, the first run read the MemberRef tables of the 72 referencing assemblies and wrote their 72 set files (3.7 MB): caller_notes 1719 ms (4438–5897 ms on 62b1236c), snapshot_group_state 1774 ms, 9757 ms in total. The next compile-triggered first run read the sets from the files and wrote none: caller_notes 983 ms, snapshot_group_state 1195 ms, 6564 ms in total. A reload without a rebuild (EditorUtility.RequestScriptReload() with the source checked out to its compiled content; no second reload, dll unchanged, stamped snapshot): resolve_inputs 37 ms, sibling_detect 172 ms, snapshot_group_state 46 ms, caller_notes 1353 ms, 5666 ms in total (AnalysisMs 1946, ShimCompileMs 1714, PatchMs 152), against 1085 ms warm. Every run was Applied with one patched method and no warning, and the Editor never came to the front.
  • PDB read after a rebuild (perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249), measured on the development project (Unity 2022.3) by its author: for each round, a compile of a test fixture and, right after it, a hot reload of one more edit to that fixture, base and head alternated in the same Editor: snapshot_group_state 413 and 465 ms on the base, 60, 61 and 62 ms on the head, 1 ms on the next run. Every run applied with no warning. The 22 existing document-index tests and the snapshot tests passed unchanged, and the first Editor-domain load of the bundled System.Reflection.Metadata plugin raised no error. Re-measured by the reporting agent on head 7daed1af at a one-minute load average of 12 to 24, two ways. After a compile that rebuilt the edited assembly's dll and none of the 559 others: resolve_inputs 120 ms, sibling_detect 72 ms, snapshot_group_state 288 ms (1774 ms on 1ed19803), caller_notes 1521 ms, 6097 ms in total (9757 ms on 1ed19803), with AnalysisMs 1524, ShimCompileMs 2360 and PatchMs 71; that run rewrote the persisted document list. A reload without a rebuild (EditorUtility.RequestScriptReload() after a checkout and a compile; dll unchanged, stamped snapshot): 22 ms, 91 ms, 111 ms (46 ms on 1ed19803; one measurement each, and this path reads the persisted list, which perf: Hot reload builds the PDB document list with System.Reflection.Metadata from the PDB and the dll's debug directory, so a rebuilt assembly's first run does not walk its dll #3249 does not touch), 1310 ms, 5392 ms in total. The warm runs that followed took 979–986 ms. Every run was Applied with one patched method and no warning, and the Editor never came to the front.
  • Cold-run breakdown entries (feat: Hot reload writes vibe entries that split a cold run's analysis and shim-compile phases into worker start, request steps, shim references, publicized copies, and compiler time #3250), measured on the development project by their author: after a compile that rebuilt the edited assembly, a cold run of 3668 ms (AnalysisMs 827, ShimCompileMs 1972, unaccountedMs 18) against a warm run of 738 ms (280, 305, 6). The prepare request to the transform worker reported workerStarted true, process_start 54 ms, response_wait 341 ms and 285 ms of worker stages (72 ms warm); the shared Roslyn worker start reported assemblyEnsureMs 487 and processStartMs 35; the publicized copy of the rebuilt assembly took 73 ms to rewrite and 615 ms to write; the shim compiler reported compileMs 1086 cold and 15 warm on the shared worker backend. All seven entries appeared on the cold run, the two conditional ones were absent on the warm run, and both runs were Applied with no warning.
  • Unacknowledged request (fix: A tool request that Unity never acknowledged is reported as UNITY_NOT_REACHABLE and retryable instead of an internal error #3251): the new unit tests cover the wrapped case with a live and a cancelled context and twelve other attempt outcomes that stay unwrapped; the two integration tests against a TCP listener that reads the request and stays silent now require the wrapped type; five mutations (dropping the wrap, wrapping on any focus reason, a nil cause, an empty connection, removing the error's Unwrap) each fail the tests meant to catch them. A live reproduction was attempted in this repository's Editor by blocking the main thread for 25 s and sending clear-console: the server answered server_busy, so the pre-accept timeout itself could not be provoked that way; it is reproduced only by a silent server in the tests.
  • Worker assembly cache (perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252), measured on the development project by its author: the first worker start with an empty cache built and published the assembly (assemblyEnsureMs 424); an execute-dynamic-code right after a compile and a hot reload right after another compile copied it from the cache (assemblyEnsureMs 2 each), and the hot reload applied on the shared worker backend. Unit tests pin the cache key, the copy, the publish (temp file and move, an existing file kept, a blocked directory and a failed move reported as Failed with no temp file left), and nine mutations each fail the tests meant to catch them.
  • Warm-up (perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253), measured on the development project by its author: after a compile with the ledger present, hot_reload_warm_up_complete reported call_sites 635 ms, referenced_method_sets 897 ms and pdb_documents 309 ms (1857 ms in total, not cancelled), and the first run took 2484 ms with caller_notes 8 ms, snapshot_group_state 2 ms and warm_up_yield 0 ms. Without the ledger the warm-up was skipped (no_targets) and the first run took 3024 ms with caller_notes 462 ms and snapshot_group_state 95 ms. A hot reload sent right after a compile waited 2 ms (warm_up_yield): call_sites had finished (880 ms), referenced_method_sets stopped between its dlls and was reported cancelled after 1377 ms, and pdb_documents never started. Unit and end-to-end tests pin the hand-off to a run (before the start, inside a unit, between units, after completion), the stops on a reload, a compile start and a service replacement, the per-item failure boundary and the ledger. Each mutation listed in the pull request fails the tests meant to catch it, except one equivalent mutation and three that EditMode cannot detect, which are guarded by review.
  • Warm-up of the publicized copy (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254), measured on the development project by its author: with the ledger listing the edited assembly, publicized_targets finished in 1693 ms (rewrite 57 ms, write 1460 ms) with all four items done, and the first run after the compile did not write the copy (targetCopyMs 1 ms). With the ledger emptied, the warm-up was skipped and the run wrote the copy itself (rewrite 49 ms, write 542 ms; targetCopyMs 747 ms). Unit and end-to-end tests pin that the item writes the copy the run then reuses, leaves an existing copy untouched, skips a name that is no compilation assembly, and stops before the first unit and between units when cancelled; each listed mutation fails them. The lock has no deterministic test.
  • Warm-up and worker cache (perf: The first dynamic code run and hot reload after a domain reload reuse a cached compiler worker instead of rebuilding it #3252, perf: The first hot reload after a domain reload finds the edited assemblies' call sites, referenced-method sets and PDB documents already loaded #3253), re-measured by the reporting agent on head 4fa78e1b after an Editor restart, at a one-minute load average of 10 to 34: the first run after a compile took 2793 ms with the warm-up's ledger present and 3760 ms with it removed (caller_notes 143 against 867 ms, snapshot_group_state 2 against 101 ms); warm runs took 851–952 ms. The worker assembly was built once (assemblyEnsureMs 480) and copied from the cache after every later reload, in the main Editor and in two Virtual Players (0–3 ms). With the main Editor and two players, the highest one-minute load average in the minute after a compile was 20.7 with the warm-up and 23.5 without.
  • Warm-up of the publicized copy (perf: The first hot reload after a compile no longer spends most of a second rewriting the edited assembly's reference copy #3254), re-measured by the reporting agent on head b200c1ab: with the ledger present, the warm-up wrote the copy (rewrite 416 ms, write 1234 ms) and the first run after the compile took 2793 ms with targetCopyMs 5 ms and ShimCompileMs 721; with the ledger removed, the run wrote the copy itself (rewrite 137 ms, write 863 ms) and took 4968 ms with targetCopyMs 1012 ms and ShimCompileMs 1612. Runs sent while the warm-up was working stopped it within 4–113 ms (warm_up_yield); the two that applied found the copy written (targetCopyMs 4 and 7 ms). With the main Editor and two Virtual Players, each Editor's first run after a compile took 2.1–2.7 s and wrote no copy.
  • Snapshot capture and check (fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255, fix: Hot reload no longer silently skips a file saved while the compile was running #3256), verified on the development project by their authors with ULOOP_DEBUG: after a compile, hot_reload_source_snapshot_captured reported trigger domain_load and captureMs 431, logged 4.7 s before domain_reload_complete, with no capture on the first update tick. A file saved during uloop compile was checked at capture (suspect 1, editedAfterCompile 1, checkMs 28); the next run without --files selected it, warned that the snapshot does not match the compiled file and applied. An ordinary edit followed by a compile checked nothing and marked no line.
  • Auto Refresh hold and an explicit refresh (docs: Note that a package's own AssetDatabase.Refresh compiles saved edits while hot reload holds Auto Refresh #3257), checked on the development project by its author: after an apply (AutoRefreshHeld true), a second edit was saved and AssetDatabase.Refresh() was called through execute-dynamic-code; the Editor reloaded 3 s later with no compile request pending, hot_reload_auto_refresh_hold_released appeared only after that reload, and --status then reported no active patch.
  • Shared-worker warm-up (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258), measured on the development project by its author, three rounds each of uloop compile, a 15 s wait and a hot reload of one edited method body, with the ledger present and moved aside on the same head: with the ledger, the warm-up answered every time (warmMs 764–819, mainThreadMs 69–94, 228 references), the run did not start the worker, and the shim compileMs was 72–80 ms; without it, the warm-up was skipped (no_targets), the run started the worker, and the shim compileMs was 801–807 ms. Unit tests pin that the reset starts the warm-up without running it inline, that the package path is read on the main thread and the compiler paths off it, the skip reasons, the outcomes, that a failed start logs nothing to the Console and leaves the error to the next real compile, and the reference list; each of the 16 listed mutations fails the tests meant to catch it.
  • Shared-worker warm-up (perf: The first hot reload shim compile after a server reset finds the shared Roslyn worker already running with its references loaded #3258) on the trial project, by the reporting agent on head 88d0ff2c, three rounds each with the ledger present and removed, alternating, editing 42 s after uloop compile returned: with the ledger, the warm-up answered every time 2.6–3.3 s after the compile returned (warmMs 433–473, mainThreadMs 0, 328 references), the worker started inside the warm-up and not in the hot reload, and the shim compileMs was 118–129 ms; without it, the warm-up was skipped (no_targets), the worker started inside the hot reload, and the shim compileMs was 439–493 ms. No round saw an unplanned compile or domain reload, and the Console had no error or exception.
  • Snapshot capture and check (fix: Hot reload no longer mistakes an edit made right after compile for compiled source #3255, fix: Hot reload no longer silently skips a file saved while the compile was running #3256), re-checked by the reporting agent on head 57bbb472: every domain load captured the snapshot before the server answered (captureMs 1182–1903, logged 1.2–2.5 s before domain_reload_complete). An edit saved 0.12 s after uloop compile returned was applied with 1 patched and 14 unchanged methods and no snapshot warning. An edit saved during a compile, 2.4 s before its domain reload, was marked (suspect 1, editedAfterCompile 1, the line's fourth field 1); the next run treated all 15 methods of that file as changed, was refused when an Editor compile started by the package refresh described in "Not covered" began, and, sent again after that compile, had nothing to apply because the edit was compiled by then.

[coderabbitai]

Important

Review skipped

Too many files!

This PR contains 189 files, which is 39 over the limit of 150.

To get a review, reduce the PR to 150 files or fewer by splitting it into smaller PRs or changing its base branch.

Upgrade to a paid plan to raise the limit.

This review couldn't start because sufficient usage credits or metered capacity aren't available. Add credits or update usage-based reviews in the billing tab, then retry.

⚙️ Run configuration

• Configuration used: Repository: hatayama/unity-cli-loop/.coderabbit.yaml
• Review profile: CHILL
• Plan: Advanced
• Run ID: 968fcb6a-cad4-4c0b-b3bf-b58440ea6acc

---

📥 Commits

Reviewing files that changed from the base of the PR and between b05bd95 and 7a5711d.

---

⛔ Files ignored due to path filters (69)

• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerAssemblyCacheTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerCacheScope.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerWarmUpTestSafety.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerWarmUpTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/CompiledAssemblyLayoutTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCallSiteWarmUpItemTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssembliesTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssemblyCacheTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssemblyListPostprocessorTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCompileStartTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadCompiledAssemblyPathCheckTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadEditorStartupTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadPdbDocumentWarmUpItemTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadPublicizedTargetWarmUpItemTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadReferencedMethodIndexTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadReferencedMethodSetWarmUpItemTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadSharedCompilerWarmUpReferenceSourceTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadSiblingVerdictCacheTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadSnapshotEditedDuringCompileTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadSourceStampManifestTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadTimingDetailPayloadTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpContextSourceTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpE2ETests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpEditorHooksTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpItemsTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTargetLedgerTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTestDoubles.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTests.cs.meta is excluded by none and included by none
• Assets/Tests/Editor/HotReload/TransformWorkerRequestTimingTests.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/Common/ScriptPath/CompiledAssemblyLayout.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/ExternalCompilerPathResolution.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerAssemblyCache.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerWarmUp.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/Plugins/CodeAnalysis/UnityCliLoop.System.Collections.Immutable.dll.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/Plugins/CodeAnalysis/UnityCliLoop.System.Reflection.Metadata.dll.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/Plugins/CodeAnalysis/UnityCliLoop.System.Runtime.CompilerServices.Unsafe.dll.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCallSiteWarmUpItem.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCompiledAssemblyPathCheck.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadGroupFileLists.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadPdbDocumentWarmUpItem.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadPublicizedTargetWarmUpItem.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadReferencedMethodIndex.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadReferencedMethodSetWarmUpItem.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadSharedCompilerWarmUpReferenceSource.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadSiblingVerdictCache.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadTimingDetailPayload.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadTimingDetailStep.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUp.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpContext.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpContextSource.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpEditorHooks.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpItemOutcome.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpItems.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpTarget.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpTargetLedger.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/IHotReloadWarmUpContextSource.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/IHotReloadWarmUpItem.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/ShimCompileReference.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/UnityCLILoop.FirstPartyTools.HotReload.Patching.Editor.asmdef is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblies.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblyCache.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblyListPostprocessor.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompileStart.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompileStartRecord.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSnapshotSourceCheck.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSourceStampManifest.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/TransformWorkerRequestTiming.cs.meta is excluded by none and included by none
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/UnityCLILoop.FirstPartyTools.HotReload.Shared.Editor.asmdef is excluded by none and included by none
• Packages/src/Editor/ToolContracts/SharedCompilerWarmUpCoordination.cs.meta is excluded by none and included by none

---

📒 Files selected for processing (189)

• .agents/skills/uloop-control-play-mode/references/multiplayer-play-mode.md
• .agents/skills/uloop-hot-reload/references/mechanism-and-lifecycle.md
• .agents/skills/uloop-hot-reload/references/scope-and-limits.md
• .agents/skills/uloop-pause-point/references/troubleshooting.md
• .claude/skills/uloop-control-play-mode/references/multiplayer-play-mode.md
• .claude/skills/uloop-hot-reload/references/mechanism-and-lifecycle.md
• .claude/skills/uloop-hot-reload/references/scope-and-limits.md
• .claude/skills/uloop-pause-point/references/troubleshooting.md
• .github/workflows/unity-compile-check-and-test-runner.yml
• Assets/Tests/Editor/DynamicCodeToolTests/CodeAnalysisPluginImporterTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/DynamicCodeExecutionFacadeTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/ExternalCompilerPathResolverTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/RoslynCompilerBackendTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerAssemblyCacheTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerCacheScope.cs
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerHostTests.cs
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerWarmUpTestSafety.cs
• Assets/Tests/Editor/DynamicCodeToolTests/SharedRoslynCompilerWorkerWarmUpTests.cs
• Assets/Tests/Editor/GetCompileStatusResponseContractTests.cs
• Assets/Tests/Editor/HotReload/CompiledAssemblyLayoutTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCallSiteCacheE2ETests.cs
• Assets/Tests/Editor/HotReload/HotReloadCallSiteScannerFixture.cs
• Assets/Tests/Editor/HotReload/HotReloadCallSiteScannerTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCallSiteWarmUpItemTests.cs
• Assets/Tests/Editor/HotReload/HotReloadChangedSiblingSourceDetectorTests.cs
• Assets/Tests/Editor/HotReload/HotReloadChangedSourceDetectorTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssembliesTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssemblyCacheTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompilationAssemblyListPostprocessorTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompileStartTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompiledAssemblyPathCheckTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompiledCallSiteCacheTests.cs
• Assets/Tests/Editor/HotReload/HotReloadCompositionRootTests.cs
• Assets/Tests/Editor/HotReload/HotReloadDefaultFilesTests.cs
• Assets/Tests/Editor/HotReload/HotReloadDomainTestScope.cs
• Assets/Tests/Editor/HotReload/HotReloadDomainTests.cs
• Assets/Tests/Editor/HotReload/HotReloadEditorStartupTests.cs
• Assets/Tests/Editor/HotReload/HotReloadEditorTickPumpTestSafety.cs
• Assets/Tests/Editor/HotReload/HotReloadPatcherContractTests.cs
• Assets/Tests/Editor/HotReload/HotReloadPatcherTests.cs
• Assets/Tests/Editor/HotReload/HotReloadPdbDocumentIndexTests.cs
• Assets/Tests/Editor/HotReload/HotReloadPdbDocumentWarmUpItemTests.cs
• Assets/Tests/Editor/HotReload/HotReloadPublicizedTargetWarmUpItemTests.cs
• Assets/Tests/Editor/HotReload/HotReloadReferencedMethodIndexTests.cs
• Assets/Tests/Editor/HotReload/HotReloadReferencedMethodSetWarmUpItemTests.cs
• Assets/Tests/Editor/HotReload/HotReloadResolverSearchDirectoriesTests.cs
• Assets/Tests/Editor/HotReload/HotReloadRunTimingTests.cs
• Assets/Tests/Editor/HotReload/HotReloadServicesTestScope.cs
• Assets/Tests/Editor/HotReload/HotReloadSharedCompilerWarmUpReferenceSourceTests.cs
• Assets/Tests/Editor/HotReload/HotReloadShimReferenceBuilderTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSiblingVerdictCacheTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSnapshotAssemblyEnumerationTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSnapshotEditedDuringCompileTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSourceSnapshotCaptureTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSourceSnapshotTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSourceSnapshotterTests.cs
• Assets/Tests/Editor/HotReload/HotReloadSourceStampManifestTests.cs
• Assets/Tests/Editor/HotReload/HotReloadTimingDetailPayloadTests.cs
• Assets/Tests/Editor/HotReload/HotReloadTypeHomeTests.cs
• Assets/Tests/Editor/HotReload/HotReloadVirtualPlayerProjectTests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpContextSourceTests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpE2ETests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpEditorHooksTests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpItemsTests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTargetLedgerTests.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTestDoubles.cs
• Assets/Tests/Editor/HotReload/HotReloadWarmUpTests.cs
• Assets/Tests/Editor/HotReload/PublicizedCopyTestCache.cs
• Assets/Tests/Editor/HotReload/ReferencePublicizerTests.cs
• Assets/Tests/Editor/HotReload/TransformWorkerClientTests.cs
• Assets/Tests/Editor/HotReload/TransformWorkerDtoSyncTests.cs
• Assets/Tests/Editor/HotReload/TransformWorkerHostTests.cs
• Assets/Tests/Editor/HotReload/TransformWorkerOutputReaderTests.cs
• Assets/Tests/Editor/HotReload/TransformWorkerRequestTimingTests.cs
• Assets/Tests/Editor/HotReloadCallSiteCrossAssembly/HotReloadCallSiteCrossAssemblyCaller.cs
• Packages/src/Editor/CliOnlyTools~/PausePoint/Skill/references/troubleshooting.md
• Packages/src/Editor/CompositionRoot/UnityCliLoopEditorBootstrapper.cs
• Packages/src/Editor/FirstPartyTools/Common/ScriptPath/AssemblyInfo.cs
• Packages/src/Editor/FirstPartyTools/Common/ScriptPath/CompiledAssemblyLayout.cs
• Packages/src/Editor/FirstPartyTools/ControlPlayMode/Skill/references/multiplayer-play-mode.md
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCodeServices.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/ExternalCompilerPathResolution.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/ExternalCompilerPathResolver.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerAssemblyCache.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerHost.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerHostProcess.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerHostResults.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerSession.cs
• Packages/src/Editor/FirstPartyTools/ExecuteDynamicCode/DynamicCompilation/SharedRoslynCompilerWorkerWarmUp.cs
• Packages/src/Editor/FirstPartyTools/FirstPartyToolsEditorStartup.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCallSiteScanner.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCallSiteWarmUpItem.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadChangedFileAggregator.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadChangedSiblingSourceDetector.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCompiledAssemblyPathCheck.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCompiledCallSiteCache.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadCompositionRoot.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadEditorStartup.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadGroupFileLists.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadGroupProcessor.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadGroupWorkerInputBuilder.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadIntroducedTypePreparation.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadNewSourceMembershipValidator.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadOrchestrator.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadOrchestratorLog.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadPatchTargetSupport.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadPdbDocumentWarmUpItem.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadPublicizedTargetWarmUpItem.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadReferencedMethodIndex.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadReferencedMethodSetWarmUpItem.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadRunTiming.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadServices.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadSharedCompilerWarmUpReferenceSource.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadShimFirstCompile.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadSiblingVerdictCache.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadTimingDetailPayload.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadTimingDetailStep.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadTools.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUp.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpContext.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpContextSource.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpEditorHooks.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpItemOutcome.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpItems.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpTarget.cs
• Packages/src/Editor/FirstPartyTools/HotReload/HotReloadWarmUpTargetLedger.cs
• Packages/src/Editor/FirstPartyTools/HotReload/IHotReloadWarmUpContextSource.cs
• Packages/src/Editor/FirstPartyTools/HotReload/IHotReloadWarmUpItem.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/HotReloadResolverSearchDirectories.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/HotReloadShimCompiler.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/HotReloadShimReferenceBuilder.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/ReferencePublicizer.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Patching/ShimCompileReference.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblies.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblyCache.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompilationAssemblyListPostprocessor.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompileStart.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadCompileStartRecord.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadConstants.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadPdbDocumentIndex.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSnapshotSourceCheck.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSourceBaseline.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSourceSnapshotCapture.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSourceSnapshotter.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadSourceStampManifest.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadTypeHome.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/HotReloadVirtualPlayerProject.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/TransformWorkerDtos.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/TransformWorkerHost.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/TransformWorkerHostResult.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Shared/TransformWorkerRequestTiming.cs
• Packages/src/Editor/FirstPartyTools/HotReload/Skill/references/mechanism-and-lifecycle.md
• Packages/src/Editor/FirstPartyTools/HotReload/Skill/references/scope-and-limits.md
• Packages/src/Editor/FirstPartyTools/HotReload/TransformWorker~/IntroducedTypePreparation.cs
• Packages/src/Editor/FirstPartyTools/HotReload/TransformWorker~/TransformWorker.cs
• Packages/src/Editor/FirstPartyTools/HotReload/TransformWorker~/WorkerGroupPipeline.cs
• Packages/src/Editor/FirstPartyTools/HotReload/TransformWorker~/WorkerOutput.cs
• Packages/src/Editor/FirstPartyTools/HotReload/TransformWorker~/WorkerRequestTimings.cs
• Packages/src/Editor/FirstPartyTools/PausePoint/SourcePausePointConstants.cs
• Packages/src/Editor/ToolContracts/SharedCompilerWarmUpCoordination.cs
• Packages/src/THIRD-PARTY-NOTICES.md
• cli/project-runner/internal/projectrunner/compile_attach.go
• cli/project-runner/internal/projectrunner/compile_attach_test.go
• cli/project-runner/internal/projectrunner/compile_current_sources_test.go
• cli/project-runner/internal/projectrunner/compile_fresh_recovery_test.go
• cli/project-runner/internal/projectrunner/compile_status_response_contract_test.go
• cli/project-runner/internal/projectrunner/compile_wait.go
• cli/project-runner/internal/projectrunner/compile_wait_deps.go
• cli/project-runner/internal/projectrunner/compile_wait_focus.go
• cli/project-runner/internal/projectrunner/compile_wait_test.go
• cli/project-runner/internal/projectrunner/connection_retry.go
• cli/project-runner/internal/projectrunner/connection_retry_flow.go
• cli/project-runner/internal/projectrunner/connection_retry_flow_test.go
• cli/project-runner/internal/projectrunner/connection_retry_test.go
• cli/project-runner/internal/projectrunner/hot_reload_busy_wait.go
• cli/project-runner/internal/projectrunner/hot_reload_busy_wait_test.go
• cli/project-runner/internal/projectrunner/pause_point_errors.go
• cli/project-runner/internal/projectrunner/pause_point_errors_test.go
• cli/project-runner/internal/projectrunner/pause_point_release_recovery.go
• cli/project-runner/internal/projectrunner/pause_point_release_recovery_test.go
• cli/project-runner/internal/projectrunner/pause_point_wait_test.go
• cli/project-runner/internal/projectrunner/plain_tool_log.go
• cli/project-runner/internal/projectrunner/plain_tool_log_test.go
• cli/project-runner/internal/projectrunner/run.go
• cli/project-runner/internal/projectrunner/run_test.go
• docs/adr/0012-hold-a-macos-activity-while-a-command-runs.md
• docs/hot-reload.md
• docs/soak-testing.md
• docs/vibe-logs.md

---

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

---

_{Comment @coderabbitai help to get the list of available commands.}