feat(edge): threshold-driven sub-window delta-sketch transmission

[zzylol]

What

Rewrites this PR from the static fixed-interval sub-window producer into a dynamic, threshold-driven one. A series ships an incremental sub-window delta only when its sketch has diverged from the backend's last-acked copy by ≥ ε in the family's norm — so the backend can answer the open (incomplete) window's query to relative ε at minimal bandwidth.

Why (large tumbling windows)

With a large window, a single boundary emit leaves the open window stale for a long time, and a blind fixed cadence is either wasteful (re-emits stable series) or insufficient (can't react to a burst). Threshold-driven emission bounds the open-window query error to ε regardless of window size, and emits nothing while a series is stable.

Which CDM guarantee this is (Cormode-2013)

This is the functional-tracking / ε-approximation branch — the backend's reconstructed open-window sketch stays within ε·‖f‖ of the true current sketch, so it can query the value to relative ε. It is not the threshold-exceedance/countdown path (that's the separate alert coordinator). It is the per-series local case (no coordinator). See docs/continuous-monitoring-aggregation-taxonomy.md.

How

Threshold mode is a superset of the old fixed mode. The mechanism is retained (EmitSubWindow, ComputeSubWindowDelta — the no-boundary-empty-base within-window diff, subWindowVisit, serializeSubWindowSeries, the flush check ticker). New is a per-series divergence gate, tight for every family:

family	norm	gate
Sum	L1 (value)	`
Count-Min	L1 (count)	ΔN ≥ ε·N (f̂ ≤ f + εN)
KLL / DDSketch	rank	ΔN ≥ ε·N (rank staleness ≤ ΔN; DDSketch value α-relative)
Count-Sketch	L2	‖f_now − f_acked‖₂ ≥ ε·‖f_now‖₂ (Frobenius cell-diff)
HLL	relative	`

Scalar families track the divergence reference on seriesEntry; Count-Sketch snapshots its cell matrix in the wrapper. sub_window_epsilon = 0 ⇒ emit every check tick (the old fixed mode, backward compatible); the first emit of a window always ships full state.

Config

• PrecomputeConfig.SubWindowInterval (check cadence) + SubWindowEpsilon.
• asap_edge: sub_window_interval + sub_window_epsilon, validated 0 < interval < window_duration and 0 ≤ epsilon < 1.

Composition with the backend

Composes with the merged per-window_start base rotation (#346): sub-window deltas carry the open window's range and accumulate until the boundary advances window_start.

Tests

asap-precompute-go: threshold gating (stable series emits nothing; crossing ε emits), first-emit-full, fixed-mode (ε=0) emits every tick, disabled-without-delta, Count-Sketch L2 divergence. asap_edge: config validation of both knobs. All green.

Accuracy (proof sketch)

Between emits the backend holds S_acked; the gate guarantees D(S_now, S_acked) < ε·‖S_now‖ at all times, so the backend's open-window answer is within relative ε. Across k edges the per-edge thresholds compose additively to ε·‖f_global‖ (L1; DDSketch α structural). Full per-family proofs in docs/continuous-monitoring-tumbling-cost-analysis.md.

Applicable families

Sub-window emission applies to all the incremental-delta families — Sum/count, DDSketch, Count-Min, Count-Sketch, HLL. Sum was made incremental for this: its ComputeDeltaAgainst now ships {Δsum,Δcount} and it opts into per-window-reset (DeltaAgainstEmptyBase), so a window's sub-window emits + boundary emit accumulate additively to the exact window total (TestSubWindow_Sum_IncrementalReconstruction). KLL is excluded (subWindowEmissionSafe): its ComputeDeltaAgainst is a full-state merge (it cannot subtract), so re-emitting every sub-window would re-merge-inflate it — KLL emits once at the boundary as before.

Scope / follow-ups

• Go runtime + asap_edge (the deployable path). Rust asap-precompute-rs mirror deferred.
• Backend compatibility: Sum delta envelopes are applied via the same additive ApplyDelta + window_start-triggered PWR reset the backend already uses for the other delta families (mvp_report: fix DDSketch family metric name (http_latency_ms → http_requests_total_latency_ms) #346).

🤖 Generated with Claude Code