Fix FSD trip meter glitch attribution

Treat spurious trip-meter resets and implausible counter jumps as discontinuities instead of driven distance. Adds reset/restore cursor logic and tests so include_fields zero snap-backs do not inflate FSD or driving aggregates.

Author: atulmgupta

internal/api/fsd/aggregate.go

@@ -174,12 +174,16 @@ func applyCompactedObservationStats(
 //     first in-window observation without a baseline contributes nothing and
 //     does not open the attributable span.
 //   - A non-negative delta is attributed in full to the local calendar day of
-//     the LATER sample.
+//     the LATER sample, unless it is physically implausible for the interval
+//     (faster than maxAttributableSpeedMps) — that is a discontinuity, not
+//     travel.
 //   - A negative delta is a counter reset: it is recorded, and contributes
 //     exactly zero distance. The post-reset absolute value is NOT treated as
-//     distance travelled, because the distance accumulated between the reset
-//     and the next emission is unknowable. A reset still opens/extends the
-//     attributable span — the counter is demonstrably reporting.
+//     distance travelled. If the next reading returns to the pre-reset
+//     magnitude (include_fields zero / trip-meter glitch), the drop is
+//     uncounted and only any excess past the pre-reset value is travel.
+//   - A reset still opens/extends the attributable span — the counter is
+//     demonstrably reporting.
 //   - A sample whose timestamp does not advance is a duplicate/out-of-order
 //     redelivery and is skipped without touching the accumulator.
 func accumulate(samples []Sample, start time.Time, loc *time.Location) *counterState {
@@ -197,6 +201,7 @@ func accumulate(samples []Sample, start time.Time, loc *time.Location) *counterS
 
 	var prev *float64
 	var prevTS time.Time
+	var cursor tripMeterCursor
 
 	for _, s := range ordered {
 		inWindow := !s.TS.Before(start)
@@ -208,6 +213,7 @@ func accumulate(samples []Sample, start time.Time, loc *time.Location) *counterS
 			// differencing trusted values across it could bridge a hidden reset
 			// or mix wire units.
 			prev = nil
+			cursor.clear()
 			if !inWindow {
 				state.baselineAvailable = false
 			}
@@ -222,6 +228,7 @@ func accumulate(samples []Sample, start time.Time, loc *time.Location) *counterS
 			// Invalid observations are also barriers. The next valid row is a
 			// fresh anchor, never a delta against stale pre-error state.
 			prev = nil
+			cursor.clear()
 			if !inWindow {
 				state.baselineAvailable = false
 			}
@@ -256,14 +263,32 @@ func accumulate(samples []Sample, start time.Time, loc *time.Location) *counterS
 		if prev != nil {
 			state.derived = true
 			state.perDayDerived[day] = true
-			change := signalcounter.Compare(*prev, value)
-			switch change.Kind {
-			case signalcounter.ChangeReset:
+			step := stepTripMeter(*prev, value, s.TS.Sub(prevTS), day, &cursor)
+			switch {
+			case step.Reset:
 				state.resets++
 				state.perDayResets[day]++
-			case signalcounter.ChangeAdvanced:
-				state.perDayMeters[day] += change.Delta
-				state.totalMeters += change.Delta
+			case step.Restored:
+				if state.resets > 0 {
+					state.resets--
+				}
+				if step.UndoResetDay != "" {
+					state.perDayResets[step.UndoResetDay]--
+					if state.perDayResets[step.UndoResetDay] < 0 {
+						delete(state.perDayResets, step.UndoResetDay)
+					}
+				}
+				if step.Delta > 0 {
+					state.perDayMeters[day] += step.Delta
+					state.totalMeters += step.Delta
+				}
+			case step.Implausible:
+				// New baseline after a unit-mix or zero-glitch jump.
+			default:
+				if step.Delta > 0 {
+					state.perDayMeters[day] += step.Delta
+					state.totalMeters += step.Delta
+				}
 			}
 		}
 

internal/api/fsd/aggregate_test.go

@@ -420,6 +420,54 @@ func TestAggregate_CounterResetContributesNoDistanceAndIsCounted(t *testing.T) {
 	}
 }
 
+func TestAggregate_SpuriousZeroDoesNotAttributeTripMeterAbsolute(t *testing.T) {
+	// SelfDrivingMilesSinceReset / MilesSinceReset sometimes emit 0 on an
+	// include_fields companion row, then snap back to the trip-meter
+	// absolute. That used to become a ~5 000 mile "day".
+	const fsdM = 4_913.0 * 1609.344
+	const drivingM = 12_231.5 * 1609.344
+	resp := Aggregate(utcParams(t, []Sample{
+		fsdSample(t, "2026-02-28T22:00:00Z", fp(fsdM)),
+		drivingSample(t, "2026-02-28T22:00:00Z", fp(drivingM)),
+		fsdSample(t, "2026-03-01T09:00:00Z", fp(fsdM+1_000)),
+		drivingSample(t, "2026-03-01T09:00:00Z", fp(drivingM+1_600)),
+		fsdSample(t, "2026-03-01T09:00:01Z", fp(0)),
+		drivingSample(t, "2026-03-01T09:00:01Z", fp(0)),
+		fsdSample(t, "2026-03-01T09:00:02Z", fp(fsdM+2_000)),
+		drivingSample(t, "2026-03-01T09:00:02Z", fp(drivingM+3_200)),
+	}))
+
+	wantMeasured(t, resp.Totals.FSDDistanceM, 2_000, "total fsd (1 km before glitch + 1 km after restore)")
+	wantMeasured(t, resp.Totals.DrivingDistanceM, 3_200, "total driving")
+	if resp.Quality.FSDResetCount != 0 {
+		t.Errorf("fsd reset count = %d, want 0 after spurious restore", resp.Quality.FSDResetCount)
+	}
+	if resp.Quality.DrivingResetCount != 0 {
+		t.Errorf("driving reset count = %d, want 0 after spurious restore", resp.Quality.DrivingResetCount)
+	}
+	if !resp.Quality.ShareBasisAvailable {
+		t.Error("a restored include_fields zero must not void the shared basis")
+	}
+	day := dayOf(t, resp, "2026-03-01")
+	wantMeasured(t, day.FSDDistanceM, 2_000, "glitch day fsd")
+	wantMeasured(t, day.DrivingDistanceM, 3_200, "glitch day driving")
+	if day.ResetCount != 0 {
+		t.Errorf("glitch day reset_count = %d, want 0", day.ResetCount)
+	}
+}
+
+func TestAggregate_ImplausibleJumpIsNotDistance(t *testing.T) {
+	resp := Aggregate(utcParams(t, []Sample{
+		fsdSample(t, "2026-02-28T22:00:00Z", fp(50)),
+		fsdSample(t, "2026-03-01T09:00:00Z", fp(50+4_913*1609.344)),
+	}))
+	wantMeasured(t, resp.Totals.FSDDistanceM, 0, "implausible jump contributes no distance")
+	wantMeasured(t, dayOf(t, resp, "2026-03-01").FSDDistanceM, 0, "implausible day")
+	if resp.Quality.FSDResetCount != 0 {
+		t.Errorf("reset count = %d, want 0 (discontinuity is not a driver reset)", resp.Quality.FSDResetCount)
+	}
+}
+
 func TestAggregate_IndependentResetsClampShareAtOneHundredPercent(t *testing.T) {
 	resp := Aggregate(utcParams(t, []Sample{
 		fsdSample(t, "2026-02-28T22:00:00Z", fp(0)),

internal/api/fsd/counter_advance.go

@@ -0,0 +1,101 @@
+package fsd
+
+import (
+	"time"
+
+	signalcounter "github.com/ev-dev-labs/teslasync/internal/signal/counter"
+)
+
+// maxAttributableSpeedMps is faster than any Tesla can travel. An advance
+// larger than this over the observation interval is a counter discontinuity
+// (include_fields zero, unit mix, trip-meter restore), not distance driven.
+const maxAttributableSpeedMps = 120.0
+
+// minAdvanceInterval floors the speed check so a 0.01 mile tick on a
+// sub-second change-feed row remains attributable.
+const minAdvanceInterval = time.Second
+
+// tripMeterCursor remembers the pre-drop reading of a resettable trip meter
+// so a later return to that magnitude can be treated as a telemetry glitch
+// instead of thousands of kilometres of driving.
+type tripMeterCursor struct {
+	preReset *float64
+	resetDay string
+}
+
+func (c *tripMeterCursor) clear() {
+	*c = tripMeterCursor{}
+}
+
+func (c *tripMeterCursor) noteReset(pre float64, day string) {
+	if c.preReset != nil {
+		return
+	}
+	v := pre
+	c.preReset = &v
+	c.resetDay = day
+}
+
+// tripMeterStep is the reset-safe classification of one consecutive pair.
+type tripMeterStep struct {
+	Delta        float64
+	Reset        bool
+	Restored     bool
+	Implausible  bool
+	UndoResetDay string
+}
+
+func stepTripMeter(prev, current float64, dt time.Duration, day string, cur *tripMeterCursor) tripMeterStep {
+	if cur == nil {
+		cur = &tripMeterCursor{}
+	}
+	change := signalcounter.Compare(prev, current)
+	switch change.Kind {
+	case signalcounter.ChangeReset:
+		cur.noteReset(prev, day)
+		return tripMeterStep{Reset: true}
+	case signalcounter.ChangeAdvanced:
+		if cur.preReset != nil {
+			if restored, ok := restoreDelta(*cur.preReset, current); ok {
+				undo := cur.resetDay
+				cur.clear()
+				return tripMeterStep{Delta: restored, Restored: true, UndoResetDay: undo}
+			}
+		}
+		if !plausibleCounterAdvance(change.Delta, dt) {
+			cur.clear()
+			return tripMeterStep{Implausible: true}
+		}
+		cur.clear()
+		return tripMeterStep{Delta: change.Delta}
+	default:
+		return tripMeterStep{}
+	}
+}
+
+// restoreDelta reports the distance to keep when a trip meter dropped and
+// then returned to (or passed) its pre-drop reading. Only the excess past
+// that reading is travel; the snap back from 0 is not.
+func restoreDelta(preReset, current float64) (float64, bool) {
+	if preReset <= 0 {
+		return 0, false
+	}
+	if current+1 < preReset {
+		return 0, false
+	}
+	d := current - preReset
+	if d < 0 {
+		d = 0
+	}
+	return d, true
+}
+
+func plausibleCounterAdvance(delta float64, dt time.Duration) bool {
+	if delta <= 0 || !signalcounter.Valid(delta) {
+		return true
+	}
+	if dt < minAdvanceInterval {
+		dt = minAdvanceInterval
+	}
+	return delta <= maxAttributableSpeedMps*dt.Seconds()
+}

internal/api/fsd/counter_advance_test.go

@@ -0,0 +1,55 @@
+package fsd
+
+import (
+	"testing"
+	"time"
+)
+
+func TestRestoreDelta(t *testing.T) {
+	t.Parallel()
+
+	if _, ok := restoreDelta(7_900_000, 7_900_000); !ok {
+		t.Fatal("snap-back to the pre-reset reading must be a restore")
+	}
+	got, ok := restoreDelta(7_900_000, 7_901_000)
+	if !ok || got != 1_000 {
+		t.Fatalf("restore excess = (%v, %v), want (1000, true)", got, ok)
+	}
+	if _, ok := restoreDelta(9_000, 100); ok {
+		t.Fatal("real post-reset climb must not look like a restore")
+	}
+	if _, ok := restoreDelta(0, 5_000); ok {
+		t.Fatal("a zero baseline is not a restore")
+	}
+}
+
+func TestPlausibleCounterAdvance(t *testing.T) {
+	t.Parallel()
+
+	if !plausibleCounterAdvance(80, 24*time.Hour) {
+		t.Fatal("80 m over a day must be attributable")
+	}
+	if plausibleCounterAdvance(4_913*1609.344, 2*time.Second) {
+		t.Fatal("thousands of miles in two seconds must be rejected")
+	}
+	if !plausibleCounterAdvance(16, time.Millisecond) {
+		t.Fatal("a sub-second 0.01 mile tick must still pass the floor")
+	}
+}
+
+func TestStepTripMeterSpuriousZero(t *testing.T) {
+	t.Parallel()
+
+	var cur tripMeterCursor
+	reset := stepTripMeter(7_900_000, 0, time.Second, "2026-03-01", &cur)
+	if !reset.Reset || cur.preReset == nil {
+		t.Fatalf("drop to 0: %+v cursor=%+v", reset, cur)
+	}
+	restore := stepTripMeter(0, 7_901_000, time.Second, "2026-03-01", &cur)
+	if !restore.Restored || restore.Delta != 1_000 || restore.UndoResetDay != "2026-03-01" {
+		t.Fatalf("restore: %+v", restore)
+	}
+	if cur.preReset != nil {
+		t.Fatal("cursor must clear after restore")
+	}
+}

internal/api/fsd/drive_aggregate.go

@@ -130,37 +130,44 @@ func BuildDriveAnalytics(
 	analytics := emptyDriveAnalytics(current, previous)
 	var ambiguousDistance, unattributedDistance float64
 
+	var fsdCursor tripMeterCursor
 	for index := 1; index < len(fsdObservations); index++ {
 		earlier := fsdObservations[index-1]
 		later := fsdObservations[index]
 		if earlier.segment != later.segment {
+			fsdCursor.clear()
 			continue
 		}
+		step := stepTripMeter(
+			earlier.value,
+			later.value,
+			later.at.Sub(earlier.at),
+			"",
+			&fsdCursor,
+		)
 		if later.at.Before(current.Period.StartAt) || !later.at.Before(current.Period.EndAt) {
 			continue
 		}
-
-		change := signalcounter.Compare(earlier.value, later.value)
-		if change.Kind != signalcounter.ChangeAdvanced {
+		if step.Delta <= 0 {
 			continue
 		}
 		if earlier.at.Before(previous.Period.StartAt) {
-			unattributedDistance += change.Delta
+			unattributedDistance += step.Delta
 			continue
 		}
 
 		candidates := overlapSweep.overlapping(earlier.at, later.at)
 		currentCandidates := currentPeriodStates(candidates, currentDriveIDs)
 		switch len(candidates) {
 		case 0:
-			unattributedDistance += change.Delta
+			unattributedDistance += step.Delta
 		case 1:
 			if len(currentCandidates) == 0 {
-				unattributedDistance += change.Delta
+				unattributedDistance += step.Delta
 				continue
 			}
 			state := currentCandidates[0]
-			state.uniqueDistanceM += change.Delta
+			state.uniqueDistanceM += step.Delta
 			if !intervalIsBoundedByDrive(
 				state.drive,
 				earlier.at,
@@ -173,21 +180,21 @@ func BuildDriveAnalytics(
 				state.summary.Evidence = append(state.summary.Evidence, EvidenceInterval{
 					StartAt:      maxTime(earlier.at, state.drive.StartedAt),
 					EndAt:        minTime(later.at, driveEnd(state.drive, current.Period.EndAt)),
-					FSDDistanceM: roundMeters(change.Delta),
+					FSDDistanceM: roundMeters(step.Delta),
 					Confidence:   ConfidenceEstimated,
 					Approximate:  true,
 				})
 			}
 		default:
 			if len(currentCandidates) == 0 {
-				unattributedDistance += change.Delta
+				unattributedDistance += step.Delta
 				continue
 			}
-			ambiguousDistance += change.Delta
+			ambiguousDistance += step.Delta
 			totalOverlap := totalOverlapDuration(candidates, earlier.at, later.at, current.Period.EndAt)
 			for _, state := range candidates {
 				share := proportionalDistance(
-					change.Delta,
+					step.Delta,
 					overlapDuration(state.drive, earlier.at, later.at, current.Period.EndAt),
 					totalOverlap,
 					len(candidates),