fix: belief accumulates across frames (lazy-OR), not once

A track recognised on 318 of 385 frames was owned on none, so the truth file
named nobody while the matcher was accepting almost continuously.

The correlation discount was an annihilator rather than an attenuator. Weight
was 1 - P(same view), so once a track had one stored view every later frame of
that same face scored ~0.01 and the belief stopped moving. One observation just
over the accept threshold is logit(0.78) ~ 1.27, under the ownership bar — hence
recognised always, owned never.

Two changes, in the order they were found.

Correlated evidence is now attenuated by effective sample size,
n_eff = n / (1 + (n-1)·rho), each frame contributing the marginal gain. That has
the right shape at both ends: uncorrelated evidence accumulates linearly, and a
held pose converges on 1/rho rather than growing without bound. A constant floor
was tried first and rejected — it grows linearly forever, so a long shot could
out-argue genuinely varied evidence purely by lasting longer.

Combination is now weighted lazy-OR: P = 1 - (1-P_old)·(1-p)^w, stored as
log(1-P) so the update is additive and precision stays where it matters as P
approaches 1. Each frame is new evidence that this track is that actor, and the
belief is the probability that at least one sighting was right. It converges
faster than summing log-odds at the same effective count — 2.98 vs 2.53 after
two observations at p=0.78 — which is what a real clip needs.

Note that summing log-odds was already a correct sequential Bayesian update:
the matcher fits with prior 0.5, so logit(p) IS the per-frame log-likelihood
ratio and the running sum carries the prior forward. It was not wrong, it was
slow. What blocked ownership was the discount, not the combination rule.

Also fixes a real correctness bug: the observation count lived on the
discounter, which is shared by every track, so tracks pooled into one effective
sample and each was discounted by how many others happened to be on screen. It
is now a per-track parameter.

The registry's frame scope holds its lock for its lifetime and the mutex is not
recursive, so calling observe() inside a scope self-deadlocks. The pipeline
never does — separate nodes — but the test did, and hung rather than failing.
Documented at the call site.

Verified end to end: the same clip that produced zero actors now identifies
Bing Crosby and Dorothy Lamour with belief 0.97.

Suite: 96 cases, 6142 assertions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

TRACES: AR-025 | SR-002

src/track_registry.hpp

@@ -60,7 +60,13 @@ struct Track {
     double                first_seen{0.0};
     std::optional<double> last_seen;              ///< unset ⇒ on screen
     std::optional<int>    actor;                  ///< set once a posterior crosses
-    std::map<int, float>  belief;                 ///< actor_idx → accumulated log-odds
+    /// actor_idx → accumulated log(1 − P). Lazy-OR (noisy-OR) accumulation:
+    /// each frame is new evidence that this track is that actor, and the
+    /// combined belief is the probability that *at least one* sighting was
+    /// right. Stored as log(1−P) because that makes the update additive and
+    /// keeps precision where it matters — as P approaches 1, (1−P) is the
+    /// quantity with the significant digits.
+    std::map<int, float>  belief;
     Embedding             mean{};                 ///< running directional mean
     std::vector<Embedding> views;                 ///< distinct looks, for AR-025 discounting
     float                 discounted_weight{0.f}; ///< sum of applied weights
@@ -146,14 +152,20 @@ public:
         if (it == tracks_.end()) { ++dropped_votes_; return; }
 
         Track& t = it->second;
-        const float w = discounter_.weight(t.views, e);
-        t.belief[actor_idx] += w * logit(posterior);
+        const float w = discounter_.weight(t.views, t.n_obs, e);
+
+        // Weighted lazy-OR: P_new = 1 − (1 − P_old)·(1 − p)^w, which in log
+        // space is a plain sum. w is the discounted evidence (AR-025), so a
+        // repeated view still advances the belief but by a fraction of what a
+        // genuinely new look would.
+        const float p = std::min(1.f - 1e-6f, std::max(1e-6f, posterior));
+        t.belief[actor_idx] += w * std::log(1.f - p);
         t.discounted_weight += w;
         ++t.n_obs;
 
-        const int   best   = argmax_belief(t);
-        const float best_lo = t.belief[best];
-        if (best_lo < cfg_.ownership_logodds) return;
+        const int   best = argmax_belief(t);
+        const float best_p = 1.f - std::exp(t.belief[best]);
+        if (best_p < own_threshold()) return;
 
         if (!t.actor.has_value()) {
             claim_locked(t, best);
@@ -285,20 +297,28 @@ private:
         d.effective_obs = t.discounted_weight;
         if (t.actor) {
             d.actor_idx = *t.actor;
-            d.belief    = logistic(t.belief[*t.actor]);
+            d.belief    = 1.f - std::exp(t.belief[*t.actor]);
             auto oi = owner_index_.find(*t.actor);
             if (oi != owner_index_.end() && oi->second == t.id) owner_index_.erase(oi);
         }
         on_dead_(d);
     }
 
+    /// Most-believed actor. belief holds log(1 − P), so the strongest claim is
+    /// the *most negative* entry, not the largest.
     static int argmax_belief(const Track& t) {
         int   best = -1;
-        float hi   = -1e30f;
-        for (const auto& [a, lo] : t.belief) if (lo > hi) { hi = lo; best = a; }
+        float lo   = 1e30f;
+        for (const auto& [a, v] : t.belief) if (v < lo) { lo = v; best = a; }
         return best;
     }
 
+    /// Ownership expressed as a probability. Config still carries log-odds so
+    /// the knob keeps its meaning across this change.
+    float own_threshold() const {
+        return 1.f / (1.f + std::exp(-cfg_.ownership_logodds));
+    }
+
     static void update_mean(Track& t, const Embedding& e) {
         // Directional mean: accumulate then re-normalise to the unit sphere, so
         // cosine against it stays a plain dot product.