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/Diagnostics/WorldLifecycleResourceSnapshotSource.cs

@@ -3,7 +3,9 @@ using AcDream.App.Rendering.Vfx;
 using AcDream.App.Rendering.Wb;
 using AcDream.App.Streaming;
 using AcDream.App.World;
+using AcDream.Content;
 using AcDream.Core.Vfx;
+using DatReaderWriter.Lib.IO;
 
 namespace AcDream.App.Diagnostics;
 
@@ -14,6 +16,10 @@ namespace AcDream.App.Diagnostics;
 /// </summary>
 internal sealed class WorldLifecycleResourceSnapshotSource
 {
+    // Generation index 3 is the large object heap; see GCMemoryInfo.GenerationInfo
+    // (verified against the installed net10.0 runtime — Gen0/1/2, LOH, POH).
+    private const int LohGenerationIndex = 3;
+
     private readonly GpuWorldState _world;
     private readonly LiveEntityAnimationRuntimeView<LiveEntityAnimationState>
         _animations;
@@ -29,6 +35,7 @@ internal sealed class WorldLifecycleResourceSnapshotSource
     private readonly TextureCache _textures;
     private readonly WbDrawDispatcher _dispatcher;
     private readonly FrameProfiler _frameProfiler;
+    private readonly IDatReaderWriter _dats;
 
     public WorldLifecycleResourceSnapshotSource(
         GpuWorldState world,
@@ -44,7 +51,8 @@ internal sealed class WorldLifecycleResourceSnapshotSource
         WbMeshAdapter meshes,
         TextureCache textures,
         WbDrawDispatcher dispatcher,
-        FrameProfiler frameProfiler)
+        FrameProfiler frameProfiler,
+        IDatReaderWriter dats)
     {
         _world = world ?? throw new ArgumentNullException(nameof(world));
         _animations = animations
@@ -68,6 +76,7 @@ internal sealed class WorldLifecycleResourceSnapshotSource
             ?? throw new ArgumentNullException(nameof(dispatcher));
         _frameProfiler = frameProfiler
             ?? throw new ArgumentNullException(nameof(frameProfiler));
+        _dats = dats ?? throw new ArgumentNullException(nameof(dats));
     }
 
     public WorldLifecycleResourceSnapshot Capture(RenderFrameOutcome outcome)
@@ -78,6 +87,25 @@ internal sealed class WorldLifecycleResourceSnapshotSource
         var mesh = meshManager.Diagnostics;
         RenderFrameDiagnosticsSnapshot render = _renderDiagnostics.Snapshot;
         GCMemoryInfo memory = GC.GetGCMemoryInfo();
+        ReadOnlySpan<GCGenerationInfo> generations = memory.GenerationInfo;
+        long lohSizeBytes = generations.Length > LohGenerationIndex
+            ? generations[LohGenerationIndex].SizeAfterBytes
+            : 0L;
+        long lohFragmentationBytes = generations.Length > LohGenerationIndex
+            ? generations[LohGenerationIndex].FragmentationAfterBytes
+            : 0L;
+
+        // The DAT-object cache lives behind IDatReaderWriter (a third-party
+        // interface from the DatReaderWriter package — we cannot extend it).
+        // RuntimeDatCollection is the one production implementation that
+        // owns the bounded per-database caches; a caller supplying a test
+        // double simply reports zero counters here.
+        CacheStats datObjectCacheStats = _dats is RuntimeDatCollection runtimeDats
+            ? runtimeDats.ObjectCacheStats
+            : default;
+        CacheStats cpuMeshCacheStats = meshManager.CpuMeshCacheStats;
+        CacheStats decodedTextureCacheStats = meshManager.DecodedTextureCacheStats;
+
         return new WorldLifecycleResourceSnapshot(
             LoadedLandblocks: _world.LoadedLandblockIds.Count,
             WorldEntities: _world.Entities.Count,
@@ -112,6 +140,18 @@ internal sealed class WorldLifecycleResourceSnapshotSource
                 _dispatcher.LastCompositeWarmupPendingCount,
             ManagedBytes: GC.GetTotalMemory(forceFullCollection: false),
             ManagedCommittedBytes: memory.TotalCommittedBytes,
+            LohSizeBytes: lohSizeBytes,
+            LohFragmentationBytes: lohFragmentationBytes,
+            ProcessTotalAllocatedBytes: GC.GetTotalAllocatedBytes(precise: false),
+            CpuMeshCacheHits: cpuMeshCacheStats.Hits,
+            CpuMeshCacheMisses: cpuMeshCacheStats.Misses,
+            CpuMeshCacheEvictions: cpuMeshCacheStats.Evictions,
+            DecodedTextureCacheHits: decodedTextureCacheStats.Hits,
+            DecodedTextureCacheMisses: decodedTextureCacheStats.Misses,
+            DecodedTextureCacheEvictions: decodedTextureCacheStats.Evictions,
+            DatObjectCacheHits: datObjectCacheStats.Hits,
+            DatObjectCacheMisses: datObjectCacheStats.Misses,
+            DatObjectCacheEvictions: datObjectCacheStats.Evictions,
             Fps: render.Fps,
             FrameMilliseconds: render.FrameMilliseconds,
             LastFrameProfile: _frameProfiler.LastReport);