Scope FSD insights to drive detail

Adds drive_id support for FSD insights with a 7-day bookend lookup and focused attribution, while filtering negligible fidget drives so they do not steal sparse counter deltas. Updates drive detail and list UI to use the drive-scoped hook and omit unknown FSD badges.

Author: atulmgupta

internal/api/fsd/drive_aggregate.go

@@ -19,7 +19,11 @@ const (
 	maxObservatoryTimelineEvents = 200
 	maxObservatoryCommuteStories = 8
 	minObservatoryCommuteDrives  = 2
-	observatoryHonesty           = "Every kilometre here is a reset-safe counter change, not an FSD engagement segment. Unknown and ambiguous distance are shown instead of guessed."
+	// Tesla will not emit SelfDrivingMilesSinceReset below a 1 mile wire
+	// delta. Sub-0.1 mi "drives" are pull-in / GPS fidget and must not steal
+	// overlap from a real commute sitting one minute later.
+	minFSDAttributionDistanceM = 160.9344
+	observatoryHonesty         = "Every kilometre here is a reset-safe counter change, not an FSD engagement segment. Unknown and ambiguous distance are shown instead of guessed."
 )
 
 type driveAttributionState struct {
@@ -80,11 +84,19 @@ func BuildDriveAnalytics(
 	}
 
 	currentDrives := drivesFullyContained(input.Drives, current.Period.StartAt, current.Period.EndAt)
+	if input.FocusDriveID != 0 {
+		currentDrives = focusedDrive(input.Drives, input.FocusDriveID)
+	} else {
+		currentDrives = significantDrives(currentDrives, 0)
+	}
 	currentDriveIDs := make(map[int64]struct{}, len(currentDrives))
 	for _, drive := range currentDrives {
 		currentDriveIDs[drive.ID] = struct{}{}
 	}
-	allDrives := drivesOverlapping(input.Drives, previous.Period.StartAt, current.Period.EndAt)
+	allDrives := significantDrives(
+		drivesOverlapping(input.Drives, previous.Period.StartAt, current.Period.EndAt),
+		input.FocusDriveID,
+	)
 	states := make(map[int64]*driveAttributionState, len(allDrives))
 	for _, drive := range allDrives {
 		drive.DistanceM = finiteNonNegativePointer(drive.DistanceM)
@@ -399,6 +411,43 @@ func drivesFullyContained(drives []DriveRecord, start, end time.Time) []DriveRec
 	return filtered
 }
 
+func focusedDrive(drives []DriveRecord, driveID int64) []DriveRecord {
+	for _, drive := range drives {
+		if drive.ID == driveID {
+			return []DriveRecord{drive}
+		}
+	}
+	return nil
+}
+
+func isNegligibleDrive(drive DriveRecord) bool {
+	if drive.DistanceM != nil && *drive.DistanceM >= minFSDAttributionDistanceM {
+		return false
+	}
+	if drive.DistanceM != nil && *drive.DistanceM > 0 {
+		return true
+	}
+	if drive.EndedAt == nil {
+		return false
+	}
+	return drive.EndedAt.Sub(drive.StartedAt) < time.Minute
+}
+
+func significantDrives(drives []DriveRecord, keepID int64) []DriveRecord {
+	filtered := make([]DriveRecord, 0, len(drives))
+	for _, drive := range drives {
+		if keepID != 0 && drive.ID == keepID {
+			filtered = append(filtered, drive)
+			continue
+		}
+		if isNegligibleDrive(drive) {
+			continue
+		}
+		filtered = append(filtered, drive)
+	}
+	return filtered
+}
+
 func trustedCounterObservations(samples []Sample, field string) []counterObservation {
 	ordered := make([]Sample, 0, len(samples)/2+1)
 	for _, sample := range samples {

internal/api/fsd/drive_aggregate_test.go

@@ -141,6 +141,81 @@ func TestBuildDriveAnalytics_DriveDetailLookaroundIncludesSparseBookend(t *testi
 	}
 }
 
+func TestBuildDriveAnalytics_FidgetDriveDoesNotStealCommuteDelta(t *testing.T) {
+	start := at(t, "2026-09-07T00:00:00Z")
+	end := at(t, "2026-09-08T00:00:00Z")
+	fidgetStart := at(t, "2026-09-07T00:51:00Z")
+	fidgetEnd := at(t, "2026-09-07T00:52:00Z")
+	driveStart := at(t, "2026-09-07T00:55:00Z")
+	driveEndAt := at(t, "2026-09-07T01:19:00Z")
+	fidgetDistance := 32.0
+	commuteDistance := 13260.0
+	samples := []Sample{
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T00:50:00Z"), 10000),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T00:50:00Z"), 50000),
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T01:18:00Z"), 22874.752),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T01:18:00Z"), 63260),
+	}
+	current := responseForRange(7, start, end, samples)
+	previous := responseForRange(7, start.Add(-24*time.Hour), start, samples)
+
+	analytics := BuildDriveAnalytics(current, previous, AnalyticsInput{
+		CounterSamples: samples,
+		Drives: []DriveRecord{
+			{ID: 349, StartedAt: fidgetStart, EndedAt: &fidgetEnd, DistanceM: &fidgetDistance},
+			{ID: 350, StartedAt: driveStart, EndedAt: &driveEndAt, DistanceM: &commuteDistance},
+		},
+	}, time.UTC, true)
+
+	if len(analytics.ContributingDrives) != 1 {
+		t.Fatalf("drives = %d, want 1 commute (fidget excluded)", len(analytics.ContributingDrives))
+	}
+	drive := analytics.ContributingDrives[0]
+	if drive.DriveID != 350 {
+		t.Fatalf("drive id = %d, want 350", drive.DriveID)
+	}
+	if drive.Confidence != ConfidenceEstimated {
+		t.Errorf("confidence = %q, want estimated", drive.Confidence)
+	}
+	wantMeasured(t, drive.FSDDistanceM, 12874.752, "commute FSD after ignoring fidget overlap")
+}
+
+func TestBuildDriveAnalytics_FocusDriveIDReportsOnlyThatDrive(t *testing.T) {
+	start := at(t, "2026-09-07T00:00:00Z")
+	end := at(t, "2026-09-08T00:00:00Z")
+	firstStart := at(t, "2026-09-07T01:00:00Z")
+	firstEnd := at(t, "2026-09-07T01:20:00Z")
+	secondStart := at(t, "2026-09-07T03:00:00Z")
+	secondEnd := at(t, "2026-09-07T03:20:00Z")
+	distance := 8000.0
+	samples := []Sample{
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T00:59:00Z"), 1000),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T00:59:00Z"), 10000),
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T01:19:00Z"), 2609.344),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T01:19:00Z"), 18000),
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T02:59:00Z"), 2609.344),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T02:59:00Z"), 18000),
+		trustedSample(SignalFSDDistance, at(t, "2026-09-07T03:19:00Z"), 4218.688),
+		trustedSample(SignalDrivingDistance, at(t, "2026-09-07T03:19:00Z"), 26000),
+	}
+	current := responseForRange(7, start, end, samples)
+	previous := responseForRange(7, start.Add(-24*time.Hour), start, samples)
+
+	analytics := BuildDriveAnalytics(current, previous, AnalyticsInput{
+		CounterSamples: samples,
+		Drives: []DriveRecord{
+			{ID: 1, StartedAt: firstStart, EndedAt: &firstEnd, DistanceM: &distance},
+			{ID: 2, StartedAt: secondStart, EndedAt: &secondEnd, DistanceM: &distance},
+		},
+		FocusDriveID: 1,
+	}, time.UTC, true)
+
+	if len(analytics.ContributingDrives) != 1 || analytics.ContributingDrives[0].DriveID != 1 {
+		t.Fatalf("drives = %+v, want only drive 1", analytics.ContributingDrives)
+	}
+	wantMeasured(t, analytics.ContributingDrives[0].FSDDistanceM, 1609.344, "focused drive FSD")
+}
+
 func TestBuildDriveAnalytics_SparseIntervalAcrossDrivesIsAmbiguous(t *testing.T) {
 	start := at(t, "2026-03-03T08:00:00Z")
 	end := at(t, "2026-03-03T13:00:00Z")

internal/api/fsd/drive_repo.go

@@ -2,10 +2,14 @@ package fsd
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
 )
 
+// ErrDriveNotFound is returned by DriveByID when the vehicle has no such drive.
+var ErrDriveNotFound = errors.New("fsd drive not found")
+
 const analyticsCounterSamplesSQL = `
 WITH baseline AS (
     SELECT DISTINCT ON (field)
@@ -194,6 +198,20 @@ SELECT id,
    AND COALESCE(ended_at, $3) > $2
  ORDER BY started_at ASC, id ASC`
 
+const analyticsDriveByIDSQL = `
+SELECT id,
+       started_at,
+       ended_at,
+       NULLIF(BTRIM(start_place), ''),
+       NULLIF(BTRIM(end_place), ''),
+       start_geofence_id,
+       end_geofence_id,
+       distance_m,
+       energy_used_wh
+  FROM drives
+ WHERE vehicle_id = $1
+   AND id = $2`
+
 const analyticsVersionSamplesSQL = `
 WITH baseline AS (
     SELECT ts, str_value, normalization_version
@@ -372,3 +390,36 @@ func (r *Repo) LoadAnalyticsInput(
 
 	return input, nil
 }
+
+// DriveByID loads one drive for vehicle-scoped FSD focus queries.
+func (r *Repo) DriveByID(ctx context.Context, vehicleID, driveID int64) (DriveRecord, error) {
+	var drive DriveRecord
+	if r == nil || r.pool == nil {
+		return drive, fmt.Errorf("load FSD drive %d: database pool is nil", driveID)
+	}
+	rows, err := r.pool.Query(ctx, analyticsDriveByIDSQL, vehicleID, driveID)
+	if err != nil {
+		return drive, fmt.Errorf("query FSD drive %d: %w", driveID, err)
+	}
+	defer rows.Close()
+	if !rows.Next() {
+		if err := rows.Err(); err != nil {
+			return drive, fmt.Errorf("iterate FSD drive %d: %w", driveID, err)
+		}
+		return drive, fmt.Errorf("load FSD drive %d: %w", driveID, ErrDriveNotFound)
+	}
+	if err := rows.Scan(
+		&drive.ID,
+		&drive.StartedAt,
+		&drive.EndedAt,
+		&drive.StartPlace,
+		&drive.EndPlace,
+		&drive.StartGeofenceID,
+		&drive.EndGeofenceID,
+		&drive.DistanceM,
+		&drive.EnergyUsedWh,
+	); err != nil {
+		return drive, fmt.Errorf("scan FSD drive %d: %w", driveID, err)
+	}
+	return drive, nil
+}

internal/api/fsd/drive_types.go

@@ -44,6 +44,10 @@ type AnalyticsInput struct {
 	CounterSamples         []Sample
 	VersionSamples         []VersionSample
 	Drives                 []DriveRecord
+	// FocusDriveID, when non-zero, reports only that drive as a current-period
+	// contributor. Neighboring drives still participate in overlap so a
+	// sparse counter interval that spans two real trips stays ambiguous.
+	FocusDriveID int64
 }
 
 // EvidenceInterval identifies the time span in which a cumulative FSD counter
@@ -110,13 +114,13 @@ type CounterResetEvent struct {
 
 // CommuteMonthShare is one calendar month of a commute identity.
 type CommuteMonthShare struct {
-	Month           string                 `json:"month"`
-	DriveCount      int                    `json:"drive_count"`
-	FSDDistanceM    *float64               `json:"fsd_distance_m"`
+	Month            string                `json:"month"`
+	DriveCount       int                   `json:"drive_count"`
+	FSDDistanceM     *float64              `json:"fsd_distance_m"`
 	DrivingDistanceM float64               `json:"driving_distance_m"`
-	FSDSharePct     *float64               `json:"fsd_share_pct"`
-	Confidence      AttributionConfidence  `json:"confidence"`
-	UnknownDays     int                    `json:"unknown_days"`
+	FSDSharePct      *float64              `json:"fsd_share_pct"`
+	Confidence       AttributionConfidence `json:"confidence"`
+	UnknownDays      int                   `json:"unknown_days"`
 }
 
 // CommuteIdentity compares the same route and time-of-day window this month

internal/api/fsd/handler.go

@@ -39,6 +39,9 @@ const (
 	// pool connection. The pool's per-connection statement_timeout remains
 	// the backstop underneath this.
 	insightsQueryBudget = 5 * time.Second
+	// Bookend SelfDrivingMilesSinceReset samples for one drive. Tesla's
+	// minimum_delta is 1 mile, so a commute's opener may sit hours earlier.
+	driveFocusLookaround = 7 * 24 * time.Hour
 )
 
 type daysLimitError struct {
@@ -61,6 +64,7 @@ type driveAnalyticsRepository interface {
 		vehicleID int64,
 		from, split, to time.Time,
 	) (AnalyticsInput, error)
+	DriveByID(ctx context.Context, vehicleID, driveID int64) (DriveRecord, error)
 }
 
 // clock is injected so handler tests can pin the period boundary;
@@ -98,6 +102,7 @@ type request struct {
 	endAt           *time.Time
 	explicitRange   bool
 	includeEvidence bool
+	driveID         int64
 }
 
 // parseRequest validates every query parameter. Returns ok=false after
@@ -164,8 +169,30 @@ func parseRequest(w http.ResponseWriter, r *http.Request) (request, bool) {
 		includeEvidence = value
 	}
 
+	var driveID int64
+	if raw := q.Get("drive_id"); raw != "" {
+		value, err := strconv.ParseInt(raw, 10, 64)
+		if err != nil || value <= 0 {
+			httpx.WriteError(w, http.StatusBadRequest, "drive_id must be a positive integer")
+			return request{}, false
+		}
+		driveID = value
+	}
+
 	startRaw := q.Get("start")
 	endRaw := q.Get("end")
+	if driveID != 0 {
+		if startRaw != "" || endRaw != "" || q.Get("days") != "" {
+			httpx.WriteError(w, http.StatusBadRequest, "drive_id cannot be combined with days, start, or end")
+			return request{}, false
+		}
+		return request{
+			vehicleID:       vehicleID,
+			loc:             loc,
+			includeEvidence: includeEvidence,
+			driveID:         driveID,
+		}, true
+	}
 	if startRaw != "" || endRaw != "" {
 		if startRaw == "" || endRaw == "" {
 			httpx.WriteError(w, http.StatusBadRequest, "start and end must be provided together")
@@ -247,6 +274,7 @@ func (h *Handler) Insights(w http.ResponseWriter, r *http.Request) {
 		attribute.Int64("vehicle_id", req.vehicleID),
 		attribute.Int("fsd.days", req.days),
 		attribute.String("fsd.timezone", req.loc.String()),
+		attribute.Int64("drive_id", req.driveID),
 	)
 
 	fields := counterFields()
@@ -262,8 +290,41 @@ func (h *Handler) Insights(w http.ResponseWriter, r *http.Request) {
 
 	var resp Response
 	if analyticsRepo, ok := h.repo.(driveAnalyticsRepository); ok {
+		var focusDriveID int64
+		if req.driveID != 0 {
+			drive, err := analyticsRepo.DriveByID(readCtx, req.vehicleID, req.driveID)
+			if err != nil {
+				if errors.Is(err, ErrDriveNotFound) {
+					httpx.WriteError(w, http.StatusNotFound, "drive not found")
+					return
+				}
+				span.RecordError(err)
+				log.Error().Err(err).
+					Int64("vehicle_id", req.vehicleID).
+					Int64("drive_id", req.driveID).
+					Str("trace_id", traceID).
+					Msg("fsd.insights: drive lookup failed")
+				httpx.WriteError(w, http.StatusInternalServerError, "failed to load FSD insights")
+				return
+			}
+			focusDriveID = drive.ID
+			start = drive.StartedAt
+			if drive.EndedAt != nil && drive.EndedAt.After(drive.StartedAt) {
+				now = drive.EndedAt.Add(driveFocusLookaround)
+			} else {
+				now = h.now()
+				if !now.After(start) {
+					now = start.Add(time.Millisecond)
+				}
+			}
+			req.days = inclusiveCivilDayCount(start, now.Add(-time.Nanosecond), req.loc)
+		}
 		previousEnd := start
 		previousStart := start.Add(-now.Sub(start))
+		if req.driveID != 0 {
+			previousStart = start.Add(-driveFocusLookaround)
+			previousEnd = start
+		}
 		input, err := analyticsRepo.LoadAnalyticsInput(
 			readCtx,
 			req.vehicleID,
@@ -281,6 +342,7 @@ func (h *Handler) Insights(w http.ResponseWriter, r *http.Request) {
 			httpx.WriteError(w, http.StatusInternalServerError, "failed to load FSD insights")
 			return
 		}
+		input.FocusDriveID = focusDriveID
 
 		resp = Aggregate(AggregateParams{
 			VehicleID: req.vehicleID,
@@ -304,6 +366,9 @@ func (h *Handler) Insights(w http.ResponseWriter, r *http.Request) {
 			Samples:   input.PreviousCounterSamples,
 		})
 		resp.Analytics = BuildDriveAnalytics(resp, previous, input, req.loc, req.includeEvidence)
+	} else if req.driveID != 0 {
+		httpx.WriteError(w, http.StatusInternalServerError, "failed to load FSD insights")
+		return
 	} else {
 		baselines, err := h.repo.BaselineSamples(readCtx, req.vehicleID, fields, start)
 		if err != nil {