fix(api): /signals/observations latest-first + unbounded since

The driving-dynamics cold-signal panels (G-Force, Pedal Usage, Autopilot &
Cruise) and the SignalLogWidget event feed surfaced empty / stale values
because /signals/observations had two coordinated bugs:

1. The repo ordered ASC by ts. The frontend latestNumeric() helper reads
   data[0] expecting the most recent observation, so callers asking with
   limit:1 got the OLDEST row in the window, and SignalLogWidget showed
   the oldest 20 events of the day instead of the most recent 20.

2. The handler defaulted since to now-24h. Cold signals (Lateral/Long
   Acceleration, PedalPosition, BrakePedalPos, BrakePedal, CruiseSetSpeed,
   CruiseFollowDistance) only emit while driving, so the panels went empty
   when the car had been parked > 24h despite the data being on disk.

Fix:
- Repo: ListByName + ListByVehicle now ORDER BY ts DESC and accept zero
  time.Time{} bounds to mean 'unbounded' on that side. Extracted the SQL
  composition into buildObservationQuery (covered by 5 new unit tests).
  The (vehicle_id, signal_name, ts DESC) index serves the bounded LIMIT
  case in index-only fashion.
- Handler: omit the lower/upper bound from the predicate when since/until
  query params are absent. Reject non-RFC3339 since/until with 400 instead
  of silently widening to 'all history' (subtle behavior regression flagged
  by rubber-duck review).

Affected callers (all want latest-first): GForcePanel, PedalUsage,
AutopilotSection, SignalLogWidget, PowersharePage. SignalCatalogWidget's
per-signal counts now reflect 'recently active signals' (newest 100 of
all-time) instead of 'oldest 100 of last 24h' — strictly more useful for
the widget's UX.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: atulmgupta

internal/api/signal_catalog_handler.go

@@ -96,9 +96,17 @@ func (h *SignalCatalogHandler) ListCatalog(w http.ResponseWriter, r *http.Reques
 // Query params:
 //   - vehicle_id (required): int64
 //   - signal_name (optional): when set, narrows to one signal name
-//   - since / until (optional, RFC3339): time window (default: last 24h)
+//   - since / until (optional, RFC3339): time window. When omitted the
+//     corresponding bound is unconstrained, so callers asking for `limit=1`
+//     get the most recent observation regardless of age — required for the
+//     cold-signal panels (G-force / pedals / cruise) on /driving-dynamics
+//     where signals only emit while driving and may be hours-to-days old.
+//     Invalid RFC3339 values produce 400 instead of being silently ignored.
 //   - limit (optional): cap, 1..1000, default 100
 //
+// Results are ordered most recent first (ts DESC) — the frontend
+// `latestNumeric()` helper reads `data[0]` as the latest reading.
+//
 // Used by SignalLogWidget, SignalCatalogWidget, PowersharePage, and the
 // driving-dynamics components.
 func (h *SignalCatalogHandler) ListObservations(w http.ResponseWriter, r *http.Request) {
@@ -118,18 +126,22 @@ func (h *SignalCatalogHandler) ListObservations(w http.ResponseWriter, r *http.R
 		limit = 1000
 	}
 
-	now := time.Now().UTC()
-	since := now.Add(-24 * time.Hour)
-	until := now
+	var since, until time.Time
 	if s := q.Get("since"); s != "" {
-		if t, err := time.Parse(time.RFC3339, s); err == nil {
-			since = t
+		t, err := time.Parse(time.RFC3339, s)
+		if err != nil {
+			writeError(w, http.StatusBadRequest, "since must be RFC3339")
+			return
 		}
+		since = t
 	}
 	if u := q.Get("until"); u != "" {
-		if t, err := time.Parse(time.RFC3339, u); err == nil {
-			until = t
+		t, err := time.Parse(time.RFC3339, u)
+		if err != nil {
+			writeError(w, http.StatusBadRequest, "until must be RFC3339")
+			return
 		}
+		until = t
 	}
 
 	signalName := q.Get("signal_name")

internal/database/signal_observation_repo.go

@@ -3,6 +3,7 @@ package database
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"github.com/jackc/pgx/v5"
@@ -16,6 +17,37 @@ type SignalObservationRepo struct {
 	db *DB
 }
 
+// buildObservationQuery composes the SELECT for ListByVehicle / ListByName.
+// signalName == "" omits the signal_name predicate. from.IsZero() omits the
+// lower time bound. to.IsZero() omits the upper time bound. ORDER BY is
+// always ts DESC (newest first) so callers reading data[0] get the latest
+// observation. The returned args slice is positional and matches the $N
+// placeholders in the query string.
+func buildObservationQuery(vehicleID int64, signalName string, from, to time.Time, limit int) (string, []any) {
+	args := []any{vehicleID}
+	var b strings.Builder
+	b.WriteString(`SELECT vehicle_id, ts, signal_name, value_numeric, value_text, value_bool, source
+		FROM signal_observations
+		WHERE vehicle_id = $1`)
+
+	if signalName != "" {
+		args = append(args, signalName)
+		fmt.Fprintf(&b, ` AND signal_name = $%d`, len(args))
+	}
+	if !from.IsZero() {
+		args = append(args, from)
+		fmt.Fprintf(&b, ` AND ts >= $%d`, len(args))
+	}
+	if !to.IsZero() {
+		args = append(args, to)
+		fmt.Fprintf(&b, ` AND ts <= $%d`, len(args))
+	}
+
+	args = append(args, limit)
+	fmt.Fprintf(&b, ` ORDER BY ts DESC LIMIT $%d`, len(args))
+	return b.String(), args
+}
+
 // NewSignalObservationRepo constructs a SignalObservationRepo bound to db.
 func NewSignalObservationRepo(db *DB) *SignalObservationRepo {
 	return &SignalObservationRepo{db: db}
@@ -88,17 +120,21 @@ func (r *SignalObservationRepo) GetLatest(ctx context.Context, vehicleID int64,
 	return &o, nil
 }
 
-// ListByVehicle returns signal observations for a vehicle within the inclusive
-// time window [from, to], ordered by ts ASC and capped by limit.
+// ListByVehicle returns signal observations for a vehicle, ordered most
+// recent first (ts DESC) and capped by limit. Time bounds [from, to] are
+// applied only when non-zero; passing time.Time{} for either bound omits
+// that side of the predicate so callers can request "the latest N
+// observations regardless of age" (used by the cold-signal panels on
+// /driving-dynamics, the SignalLogWidget event feed, etc.).
+//
+// DESC ordering matches the frontend `latestNumeric()` helper which reads
+// `data[0]` as "most recent". Switching from ASC to DESC also exploits
+// the (vehicle_id, signal_name, ts DESC) compression order so the
+// hypertable can satisfy LIMIT-bounded scans without an extra sort.
 func (r *SignalObservationRepo) ListByVehicle(ctx context.Context, vehicleID int64, from, to time.Time, limit int) ([]models.SignalObservation, error) {
-	const query = `
-		SELECT vehicle_id, ts, signal_name, value_numeric, value_text, value_bool, source
-		FROM signal_observations
-		WHERE vehicle_id = $1 AND ts BETWEEN $2 AND $3
-		ORDER BY ts ASC
-		LIMIT $4`
+	query, args := buildObservationQuery(vehicleID, "", from, to, limit)
 
-	rows, err := r.db.Pool.Query(ctx, query, vehicleID, from, to, limit)
+	rows, err := r.db.Pool.Query(ctx, query, args...)
 	if err != nil {
 		return nil, fmt.Errorf("signal-observations-repo-list-by-vehicle: %w", err)
 	}
@@ -127,18 +163,18 @@ func (r *SignalObservationRepo) ListByVehicle(ctx context.Context, vehicleID int
 }
 
 // ListByName returns signal observations for a vehicle filtered by signal
-// name within the inclusive time window [from, to], ordered by ts ASC and
-// capped by limit. signal_name is the FK into signal_catalog.name (ADR-009),
-// so an explicit join is unnecessary for filtering.
+// name, ordered most recent first (ts DESC) and capped by limit. Time bounds
+// [from, to] are applied only when non-zero; passing time.Time{} for either
+// bound omits that side of the predicate. signal_name is the FK into
+// signal_catalog.name (ADR-009), so an explicit join is unnecessary for
+// filtering.
+//
+// The (vehicle_id, signal_name, ts DESC) idx_signal_obs_vehicle_signal_ts
+// index serves this query in index-only fashion for any limit.
 func (r *SignalObservationRepo) ListByName(ctx context.Context, vehicleID int64, name string, from, to time.Time, limit int) ([]models.SignalObservation, error) {
-	const query = `
-		SELECT vehicle_id, ts, signal_name, value_numeric, value_text, value_bool, source
-		FROM signal_observations
-		WHERE vehicle_id = $1 AND signal_name = $2 AND ts BETWEEN $3 AND $4
-		ORDER BY ts ASC
-		LIMIT $5`
+	query, args := buildObservationQuery(vehicleID, name, from, to, limit)
 
-	rows, err := r.db.Pool.Query(ctx, query, vehicleID, name, from, to, limit)
+	rows, err := r.db.Pool.Query(ctx, query, args...)
 	if err != nil {
 		return nil, fmt.Errorf("signal-observations-repo-list-by-name: %w", err)
 	}

internal/database/signal_observation_repo_test.go

@@ -0,0 +1,71 @@
+package database
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Regression coverage for buildObservationQuery — the SQL builder behind
+// SignalObservationRepo.ListByName and ListByVehicle. The shape of these
+// queries is the contract the cold-signal panels (G-force / pedals / cruise
+// on /driving-dynamics) and SignalLogWidget rely on; getting it wrong
+// renders the panels empty or stale.
+
+func TestBuildObservationQuery_ByNameAlwaysDESC(t *testing.T) {
+	q, _ := buildObservationQuery(42, "PedalPosition", time.Time{}, time.Time{}, 1)
+	if !strings.Contains(q, "ORDER BY ts DESC") {
+		t.Fatalf("expected ORDER BY ts DESC, got %q", q)
+	}
+	if strings.Contains(q, "ORDER BY ts ASC") {
+		t.Fatalf("must not order ASC — frontend reads data[0] as latest: %q", q)
+	}
+}
+
+func TestBuildObservationQuery_OmitsTimeBoundsWhenZero(t *testing.T) {
+	q, args := buildObservationQuery(42, "PedalPosition", time.Time{}, time.Time{}, 1)
+	if strings.Contains(q, "ts >=") || strings.Contains(q, "ts <=") || strings.Contains(q, "BETWEEN") {
+		t.Fatalf("zero time bounds must omit ts predicates entirely, got %q", q)
+	}
+	// args = [vehicle_id, signal_name, limit]
+	if len(args) != 3 {
+		t.Fatalf("expected 3 args [vehicle, signal_name, limit], got %d: %v", len(args), args)
+	}
+}
+
+func TestBuildObservationQuery_AppliesBothTimeBoundsWhenSet(t *testing.T) {
+	from := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+	to := time.Date(2026, 5, 2, 0, 0, 0, 0, time.UTC)
+	q, args := buildObservationQuery(42, "PedalPosition", from, to, 100)
+	if !strings.Contains(q, "ts >=") || !strings.Contains(q, "ts <=") {
+		t.Fatalf("expected both ts >= and ts <= predicates, got %q", q)
+	}
+	// args = [vehicle_id, signal_name, from, to, limit]
+	if len(args) != 5 {
+		t.Fatalf("expected 5 args, got %d: %v", len(args), args)
+	}
+}
+
+func TestBuildObservationQuery_OmitsSignalNameWhenEmpty(t *testing.T) {
+	q, args := buildObservationQuery(42, "", time.Time{}, time.Time{}, 20)
+	if strings.Contains(q, "signal_name =") {
+		t.Fatalf("empty signal_name must omit signal_name predicate, got %q", q)
+	}
+	// args = [vehicle_id, limit]
+	if len(args) != 2 {
+		t.Fatalf("expected 2 args [vehicle, limit], got %d: %v", len(args), args)
+	}
+}
+
+func TestBuildObservationQuery_PlaceholdersAreSequential(t *testing.T) {
+	from := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+	q, args := buildObservationQuery(42, "PedalPosition", from, time.Time{}, 50)
+	// Expect $1=vehicle, $2=signal, $3=from, $4=limit
+	for i := 1; i <= len(args); i++ {
+		marker := "$" + strconv.Itoa(i)
+		if !strings.Contains(q, marker) {
+			t.Fatalf("expected placeholder %s in query, got %q", marker, q)
+		}
+	}
+}