perf(diag): per-frame history export + checkpoint LOH/cache counters + soak capped mode (2026-07-24 audit review)

An adversarial performance review found our own instruments cannot
measure the project's own performance gates:

- FrameProfiler aggregated CPU/GPU/alloc/stage samples into ~5-second
  windows and reset the ring buffers after each report, so route-wide
  p50/p95/p99 distributions across a whole soak could not be
  reconstructed after the fact. ACDREAM_FRAME_HISTORY=<path> now opts
  into a separate per-frame history (one record per frame, ~72
  bytes/record, accumulated in memory with zero frame-thread I/O) that
  a shutdown-only Dispose() writes as CSV. The aggregated [frame-prof]
  report format and its existing metrics are unchanged.

- The canonical checkpoint JSON tracked cache residency (entry/byte
  counts) but never LOH size/fragmentation, process-wide allocated
  bytes, or cache hit/miss/eviction traffic — a committed audit JSON
  showed 65% LOH fragmentation that no tracked instrument recorded,
  and "does a revisit portal hit or miss the caches" was unanswerable
  from an artifact alone. WorldLifecycleResourceSnapshot now carries
  loh_size_bytes/loh_fragmentation_bytes (GCMemoryInfo.GenerationInfo
  index 3), process_total_allocated_bytes (GC.GetTotalAllocatedBytes),
  and Interlocked hit/miss/eviction counters for the CPU mesh cache,
  decoded-texture cache, and the four bounded DAT-object caches
  (portal/cell/highRes/language, aggregated).

- run-connected-r6-soak.ps1 unconditionally forced
  ACDREAM_UNCAPPED_RENDER=1 with no capped mode, while its sibling
  lifecycle-gate script correctly gated it behind a switch. Added
  -Uncapped (default capped, matching the sibling script's pattern),
  fixed the stationary dwell (12s -> 26s, past the 25s
  LiveEntityLivenessController deadline the adjacent comment already
  cited), and now write an env-disclosure.json into the automation
  artifact directory before every launch listing every ACDREAM_* var
  the script sets plus -Uncapped, since the prior audit could only see
  ACDREAM_DUMP_MOVE_TRUTH and nothing else was ever recorded anywhere.

Cache counters are wired via the existing composition path
(ObjectMeshManager already owns the CPU mesh cache and the mesh
extractor directly; content.Dats is threaded into
WorldLifecycleResourceSnapshotSource the same way every other
composition consumer receives it). The DAT-object cache lives behind
IDatReaderWriter, a third-party interface from the DatReaderWriter
package that cannot be extended; RuntimeDatCollection (the one
production implementation) exposes the aggregate stats directly and a
pattern match reads them, degrading to zero for any test double —
no new static registry was introduced (GpuMemoryTracker remains the
one precedented process-wide static).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
(cherry picked from commit 1da2c33c875b41fa383dd79694ee2765f0e21896)

src/AcDream.App/Rendering/Wb/MeshUploadCaches.cs

@@ -271,6 +271,21 @@ internal sealed class CpuMeshUploadCache
     private readonly long _byteCapacity;
     private long _residentBytes;
 
+    // Hit/miss/eviction traffic counters (2026-07-24 measurement-tooling
+    // review). Read via Stats from the diagnostics/checkpoint thread
+    // without taking _data's lock, so plain fields with Interlocked
+    // increments — the 4 concurrent preparation workers all consult
+    // TryGetAndStage.
+    private long _hits;
+    private long _misses;
+    private long _evictions;
+
+    /// <summary>Cumulative hit/miss/eviction counts since construction.</summary>
+    internal CacheStats Stats => new(
+        Interlocked.Read(ref _hits),
+        Interlocked.Read(ref _misses),
+        Interlocked.Read(ref _evictions));
+
     public CpuMeshUploadCache(int capacity, long byteCapacity = 128L * 1024 * 1024)
     {
         if (capacity <= 0)
@@ -292,9 +307,11 @@ internal sealed class CpuMeshUploadCache
         lock (_data)
         {
             if (!_data.TryGetValue(id, out data)) {
+                Interlocked.Increment(ref _misses);
                 stageResult = default;
                 return false;
             }
+            Interlocked.Increment(ref _hits);
             _lru.Remove(id);
             _lru.AddLast(id);
             stageResult = staging.TryStage(data);
@@ -325,6 +342,7 @@ internal sealed class CpuMeshUploadCache
                 _data.Remove(oldest);
                 if (_bytesById.Remove(oldest, out long oldestBytes))
                     _residentBytes -= oldestBytes;
+                Interlocked.Increment(ref _evictions);
             }
 
             _data[data.ObjectId] = data;

src/AcDream.App/Rendering/Wb/ObjectMeshManager.cs

@@ -276,6 +276,12 @@ namespace AcDream.App.Rendering.Wb
         internal (int Count, long Bytes) CpuCacheDiagnostics =>
             (_cpuMeshCache.Count, _cpuMeshCache.ResidentBytes);
 
+        /// <summary>CPU prepared-mesh cache hit/miss/eviction counts (2026-07-24 measurement-tooling review).</summary>
+        internal CacheStats CpuMeshCacheStats => _cpuMeshCache.Stats;
+
+        /// <summary>Decoded-texture cache hit/miss/eviction counts (2026-07-24 measurement-tooling review).</summary>
+        internal CacheStats DecodedTextureCacheStats => _extractor.DecodedTextureCacheStats;
+
         private sealed class PreparationRequest(
             ulong id,
             bool isSetup,