perf(audience): cache DiskStore.Count to avoid per-tick directory scans

Sample diagnostics panels poll QueueSize on a UI tick — at 10 Hz with
a non-trivial spool that's a continuous Directory.GetFiles scan for a
value that barely changes. Cache the count instead.

- Seed at construction from the existing spool so first poll is
  correct without a pre-mutation branch. Lazy-seeding on first bump
  had a double-count bug: the seed scan already saw the just-written
  file, then the +1 delta pushed the cache past the real on-disk
  count.
- Write / Delete / DeleteAll / ApplyAnonymousDowngrade maintain the
  delta via BumpCount (Interlocked.Add) and TryDelete now returns a
  bool so "actually removed" vs "already gone" can drive the
  decrement.
- TryDelete folds DirectoryNotFoundException into the true
  (idempotent) branch — per the MS docs it fires on invalid paths
  (example: "unmapped drive"), and an unreachable path can't point
  to a real file — and keeps IOException / UnauthorizedAccessException
  in the false branch so the cache stays honest when a file survived
  the delete attempt. FileNotFoundException is deliberately absent:
  File.Delete silently succeeds when the file is gone, so there is
  nothing to catch.
- Count() reads through Volatile.Read so a caller on a different
  thread sees the latest published value.

Cache invariant: on-disk-count-at-ctor + Σ tracked deltas. Events
written outside the DiskStore API (direct File.* calls from tests
that plant fixtures) are not tracked and will drift the cache; such
tests assert on the post-op filesystem state, not Count().

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ImmutableJeffrey

src/Packages/Audience/Runtime/Transport/DiskStore.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
+using System.Threading;
 
 namespace Immutable.Audience
 {
@@ -14,10 +15,17 @@ internal sealed class DiskStore
     {
         private readonly string _queueDir;
 
+        // Cached queue file count: on-disk count at construction, plus
+        // tracked deltas from Write/Delete. Tests that plant files
+        // outside the DiskStore API will drift this and should assert
+        // on filesystem state, not Count().
+        private int _cachedCount;
+
         internal DiskStore(string persistentDataPath)
         {
             _queueDir = Path.Combine(persistentDataPath, "imtbl_audience", "queue");
             Directory.CreateDirectory(_queueDir);
+            _cachedCount = Directory.GetFiles(_queueDir, "*.json").Length;
         }
 
         // Atomically writes json as a new event file.
@@ -29,16 +37,19 @@ internal void Write(string json)
 
             File.WriteAllText(tmpPath, json);
 
+            var replaced = false;
             try
             {
                 File.Move(tmpPath, finalPath);
             }
             catch (IOException)
             {
-                // Destination already exists (unlikely but safe to handle)
                 File.Delete(finalPath);
                 File.Move(tmpPath, finalPath);
+                replaced = true;
             }
+
+            if (!replaced) BumpCount(+1);
         }
 
         // Returns up to maxSize file paths, oldest first. Stale files
@@ -71,7 +82,7 @@ internal IReadOnlyList<string> ReadBatch(int maxSize)
                     var fileTime = new DateTime(ticks, DateTimeKind.Utc);
                     if (fileTime < cutoff)
                     {
-                        TryDelete(path);
+                        if (TryDelete(path)) BumpCount(-1);
                         continue;
                     }
                 }
@@ -86,17 +97,21 @@ internal IReadOnlyList<string> ReadBatch(int maxSize)
         internal void Delete(IEnumerable<string> paths)
         {
             foreach (var path in paths)
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
         }
 
-        // Total number of event files currently on disk.
-        internal int Count() => Directory.GetFiles(_queueDir, "*.json").Length;
+        // Total number of event files currently on disk. Reads the cached
+        // count seeded at construction; mutating ops maintain it.
+        internal int Count() => Volatile.Read(ref _cachedCount);
+
+        private void BumpCount(int delta) => Interlocked.Add(ref _cachedCount, delta);
 
-        private static void TryDelete(string path)
+        private static bool TryDelete(string path)
         {
-            try { File.Delete(path); }
-            catch (IOException) { }
-            catch (UnauthorizedAccessException) { }
+            try { File.Delete(path); return true; }
+            catch (DirectoryNotFoundException) { return true; }
+            catch (IOException) { return false; }
+            catch (UnauthorizedAccessException) { return false; }
         }
         internal void DeleteAll()
         {
@@ -105,7 +120,7 @@ internal void DeleteAll()
             catch (DirectoryNotFoundException) { return; }
 
             foreach (var path in paths)
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
         }
 
         // Drops queued identify/alias files, strips userId from track files.
@@ -126,13 +141,13 @@ private void ApplyAnonymousDowngradeToFile(string path)
                 !msg.TryGetValue(MessageFields.Type, out var typeObj) ||
                 !(typeObj is string type))
             {
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
                 return;
             }
 
             if (IsIdentityMessage(type))
             {
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
                 return;
             }
 
@@ -176,11 +191,11 @@ private void RewriteTrackWithoutUserId(string path, Dictionary<string, object> m
             catch (IOException)
             {
                 // Delete rather than leave the old userId-bearing payload.
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
             }
             catch (UnauthorizedAccessException)
             {
-                TryDelete(path);
+                if (TryDelete(path)) BumpCount(-1);
             }
         }