Merge backfill into Sync now, replace Full backfill with a destructive Reset all

Sync now now runs Backfill (resumes from the watermark, so a widened history
horizon is picked up automatically) then IncrementalSync then detail-fill, in
one click. "Full backfill" is gone -- in its place, "Reset all" (styled as a
destructive action, gated by a confirm dialog) wipes every synced activity
and its laps/kind assignments and rewinds the backfill watermark, so the next
sync performs a genuinely fresh pull instead of trying to patch up existing
rows with newer schema fields.

backend/internal/api/api_test.go

@@ -335,6 +335,42 @@ func TestListActivities_ReportsLockedForManualAndRaceAssignments(t *testing.T) {
 	}
 }
 
+func TestSyncReset_DeletesActivitiesAndBackfillEndpointIsGone(t *testing.T) {
+	s, db := newTestServer(t)
+	ctx := newCtx()
+
+	if _, err := db.UpsertActivity(ctx, store.Activity{GarminActivityID: 1, ActivityType: "running", StartTimeUTC: "2026-07-11 06:00:00", RawJSON: "{}"}); err != nil {
+		t.Fatalf("UpsertActivity: %v", err)
+	}
+
+	router := s.Router()
+	rec := doJSON(t, router, http.MethodPost, "/api/sync/reset", nil)
+	if rec.Code != http.StatusAccepted {
+		t.Fatalf("reset status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+
+	deadline := time.Now().Add(2 * time.Second)
+	for {
+		activities, err := db.ListActivities(ctx, store.ActivityFilter{})
+		if err != nil {
+			t.Fatalf("ListActivities: %v", err)
+		}
+		if len(activities) == 0 {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("timed out waiting for reset to delete activities, still have %d", len(activities))
+		}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	// "Full backfill" no longer exists as an endpoint -- superseded by reset.
+	rec = doJSON(t, router, http.MethodPost, "/api/sync/backfill", nil)
+	if rec.Code != http.StatusNotFound {
+		t.Errorf("/api/sync/backfill status = %d, want 404 (removed)", rec.Code)
+	}
+}
+
 func TestProgression_ReturnsSortedTimeSeries(t *testing.T) {
 	s, db := newTestServer(t)
 	ctx := newCtx()

backend/internal/api/server.go

@@ -53,7 +53,7 @@ func (s *Server) Router() http.Handler {
 
 		r.Route("/sync", func(r chi.Router) {
 			r.Post("/run", s.handleSyncRun)
-			r.Post("/backfill", s.handleSyncBackfill)
+			r.Post("/reset", s.handleSyncReset)
 			r.Get("/runs", s.handleSyncRuns)
 			r.Get("/status", s.handleSyncStatus)
 		})

backend/internal/api/sync.go

@@ -10,8 +10,17 @@ import (
 // internal/sync.Service.FillPendingDetails.
 const detailFillBatchSize = 50
 
+// handleSyncRun does a full sync pass: Backfill first (resumes from the
+// watermark, so widening the configured history horizon between clicks is
+// picked up automatically), then IncrementalSync (catches anything new since
+// the latest known activity), then fills in details for whatever's still
+// missing them. Activities already fully processed are left untouched --
+// see internal/sync.Service.FillPendingDetails.
 func (s *Server) handleSyncRun(w http.ResponseWriter, r *http.Request) {
 	ok := s.backgroundSync(func(ctx context.Context) error {
+		if err := s.Sync.Backfill(ctx); err != nil {
+			return err
+		}
 		if err := s.Sync.IncrementalSync(ctx); err != nil {
 			return err
 		}
@@ -24,12 +33,13 @@ func (s *Server) handleSyncRun(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusAccepted, map[string]string{"status": "started"})
 }
 
-func (s *Server) handleSyncBackfill(w http.ResponseWriter, r *http.Request) {
+// handleSyncReset wipes every synced activity (and its laps/samples/kind
+// assignments) and rewinds the backfill watermark, so the next Sync Now
+// performs a genuinely fresh pull from Garmin. Destructive -- the frontend
+// gates this behind a confirmation.
+func (s *Server) handleSyncReset(w http.ResponseWriter, r *http.Request) {
 	ok := s.backgroundSync(func(ctx context.Context) error {
-		if err := s.Sync.Backfill(ctx); err != nil {
-			return err
-		}
-		return s.Sync.FillPendingDetails(ctx, detailFillBatchSize)
+		return s.Sync.ResetAll(ctx)
 	})
 	if !ok {
 		writeError(w, http.StatusConflict, "a sync is already in progress")