add insights to dashboard: match rate, quotes, multi-link

new stats tracked:
- quote_matches: posts that matched via quoted content
- multi_platform: posts with links to 2+ platforms
- match rate: calculated posts/hour

dashboard now shows insights section with these metrics.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

src/feed/filter.zig

···
     return false;
 }
 
+/// returns true if the post matched because it quotes a music post (not direct link)
+pub fn isQuoteMatch(record: Record) bool {
+    const val: json.Value = .{ .object = record };
+
+    // if post has direct music links, it's not a quote match
+    if (zat.json.getString(val, "embed.external.uri")) |uri| {
+        if (containsMusicDomain(uri)) return false;
+    }
+    if (zat.json.getArray(val, "facets")) |facets| {
+        if (checkFacetsForMusic(facets)) return false;
+    }
+
+    // check if music is in quoted content
+    if (zat.json.getString(val, "embed.record.value.embed.external.uri")) |uri| {
+        if (containsMusicDomain(uri)) return true;
+    }
+    if (zat.json.getArray(val, "embed.record.value.facets")) |facets| {
+        if (checkFacetsForMusic(facets)) return true;
+    }
+    if (zat.json.getString(val, "embed.record.record.value.embed.external.uri")) |uri| {
+        if (containsMusicDomain(uri)) return true;
+    }
+
+    return false;
+}
+
 fn containsMusicDomain(uri: []const u8) bool {
     for (music_domains) |domain| {
         if (mem.indexOf(u8, uri, domain) != null) return true;

src/jetstream.zig

···
             return;
         };
 
-        stats.get().recordMatch();
+        const s = stats.get();
+        s.recordMatch();
 
         // track all platforms in post
         const platforms = filter.detectAllPlatformsFromRecord(post_record.object);
-        const s = stats.get();
         if (platforms.soundcloud) s.recordPlatform(.soundcloud);
         if (platforms.bandcamp) s.recordPlatform(.bandcamp);
         if (platforms.spotify) s.recordPlatform(.spotify);
         if (platforms.plyr) s.recordPlatform(.plyr);
         if (platforms.apple) s.recordPlatform(.apple);
+
+        // track match types
+        if (filter.isQuoteMatch(post_record.object)) s.recordQuoteMatch();
+        if (platforms.count() >= 2) s.recordMultiPlatform();
 
         std.debug.print("added: {s}\n", .{at_uri.string});
     }

src/server/dashboard.zig

···
         \\    </div>
         \\
         \\    <div class="criteria">
+        \\      <div class="criteria-title">insights</div>
+        \\      <div class="criteria-list">
+    );
+
+    // match rate
+    const match_rate = s.getMatchRate();
+    try w.print("{d:.1} posts/hour", .{match_rate});
+
+    // quote matches
+    const quote_matches = s.getQuoteMatches();
+    const multi_platform = s.getMultiPlatform();
+    const matches = s.getMatches();
+
+    if (matches > 0) {
+        try w.writeAll(" · ");
+        if (quote_matches > 0) {
+            const quote_pct: f64 = @as(f64, @floatFromInt(quote_matches)) / @as(f64, @floatFromInt(matches)) * 100.0;
+            try w.print("{d} quotes ({d:.1}%)", .{ quote_matches, quote_pct });
+        } else {
+            try w.writeAll("0 quotes");
+        }
+        try w.writeAll(" · ");
+        if (multi_platform > 0) {
+            try w.print("{d} multi-link", .{multi_platform});
+        } else {
+            try w.writeAll("0 multi-link");
+        }
+    }
+
+    try w.writeAll(
+        \\</div>
+        \\    </div>
+        \\
+        \\    <div class="criteria">
         \\      <div class="criteria-title">excluded</div>
         \\      <div class="criteria-list">posts with nsfw <a href="https://docs.bsky.app/docs/advanced-guides/moderation">labels</a></div>
         \\    </div>

src/server/stats.zig

···
     plyr: Atomic(u64),
     apple: Atomic(u64),
 
+    // match type counters
+    quote_matches: Atomic(u64), // posts quoting music posts
+    multi_platform: Atomic(u64), // posts with 2+ platforms
+
     // for lag trend tracking
     prev_lag_ms: Atomic(i64),
 
···
             .spotify = Atomic(u64).init(0),
             .plyr = Atomic(u64).init(0),
             .apple = Atomic(u64).init(0),
+            .quote_matches = Atomic(u64).init(0),
+            .multi_platform = Atomic(u64).init(0),
             .prev_lag_ms = Atomic(i64).init(0),
         };
         self.load();
···
         };
         if (root.get("apple")) |v| if (v == .integer) {
             self.apple.store(@intCast(@max(0, v.integer)), .monotonic);
+        };
+        if (root.get("quote_matches")) |v| if (v == .integer) {
+            self.quote_matches.store(@intCast(@max(0, v.integer)), .monotonic);
+        };
+        if (root.get("multi_platform")) |v| if (v == .integer) {
+            self.multi_platform.store(@intCast(@max(0, v.integer)), .monotonic);
         };
 
         std.debug.print("loaded stats from {s}\n", .{STATS_PATH});
···
         const session_uptime: u64 = @intCast(@max(0, now - self.started_at));
         const total_uptime = self.prior_uptime + session_uptime;
 
-        var buf: [512]u8 = undefined;
+        var buf: [768]u8 = undefined;
         const data = std.fmt.bufPrint(&buf,
-            \\{{"messages":{},"matches":{},"cumulative_uptime":{},"soundcloud":{},"bandcamp":{},"spotify":{},"plyr":{},"apple":{}}}
+            \\{{"messages":{},"matches":{},"cumulative_uptime":{},"soundcloud":{},"bandcamp":{},"spotify":{},"plyr":{},"apple":{},"quote_matches":{},"multi_platform":{}}}
         , .{
             self.messages.load(.monotonic),
             self.matches.load(.monotonic),
···
             self.spotify.load(.monotonic),
             self.plyr.load(.monotonic),
             self.apple.load(.monotonic),
+            self.quote_matches.load(.monotonic),
+            self.multi_platform.load(.monotonic),
         }) catch return;
 
         file.writeAll(data) catch return;
···
         };
     }
 
+    pub fn recordQuoteMatch(self: *Stats) void {
+        _ = self.quote_matches.fetchAdd(1, .monotonic);
+    }
+
+    pub fn recordMultiPlatform(self: *Stats) void {
+        _ = self.multi_platform.fetchAdd(1, .monotonic);
+    }
+
+    pub fn getQuoteMatches(self: *const Stats) u64 {
+        return self.quote_matches.load(.monotonic);
+    }
+
+    pub fn getMultiPlatform(self: *const Stats) u64 {
+        return self.multi_platform.load(.monotonic);
+    }
+
+    pub fn getMatchRate(self: *Stats) f64 {
+        const uptime_sec = self.totalUptime();
+        if (uptime_sec <= 0) return 0;
+        const uptime_hours: f64 = @as(f64, @floatFromInt(uptime_sec)) / 3600.0;
+        const matches: f64 = @floatFromInt(self.matches.load(.monotonic));
+        return matches / uptime_hours;
+    }
+
     pub fn recordConnected(self: *Stats) void {
         self.connected_at.store(std.time.milliTimestamp(), .monotonic);
     }
···
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
         .apple = Atomic(u64).init(0),
+        .quote_matches = Atomic(u64).init(0),
+        .multi_platform = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };
 
···
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
         .apple = Atomic(u64).init(0),
+        .quote_matches = Atomic(u64).init(0),
+        .multi_platform = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };
 
···
         .spotify = Atomic(u64).init(0),
         .plyr = Atomic(u64).init(0),
         .apple = Atomic(u64).init(0),
+        .quote_matches = Atomic(u64).init(0),
+        .multi_platform = Atomic(u64).init(0),
         .prev_lag_ms = Atomic(i64).init(0),
     };