fix: use MAX of turn/updated/created timestamps for last-active calculation

lastActiveExpr previously used COALESCE(max_turn, updated_at, created_at)
which always preferred turn timestamps even when stale. Sessions with
unindexed turns appeared older than their actual last activity.

Changed to MAX() of all three timestamps so the most recent signal wins,
whether it comes from indexed turns or session metadata.

Adds 4 regression tests covering stale-turn, fresh-turn, no-turn, and
time-filter visibility scenarios.

Co-authored-by: Copilot <[email protected]>

Author: jongio

internal/data/models.go

@@ -20,9 +20,10 @@ type Session struct {
 	CreatedAt  string `json:"created_at"`
 	UpdatedAt  string `json:"updated_at"`
 
-	// LastActiveAt is computed at query time as the latest turn timestamp,
-	// falling back to updated_at then created_at. This avoids the problem
-	// where the Copilot CLI reindex resets updated_at on all sessions.
+	// LastActiveAt is computed at query time as the MAX of the latest
+	// turn timestamp, updated_at, and created_at — whichever is most
+	// recent.  Indexed turns may lag (stale reindex) while updated_at
+	// may be noisy, so taking the maximum gives the best estimate.
 	LastActiveAt string `json:"last_active_at"`
 
 	// Computed fields – populated by JOIN aggregates, not stored in the table.

internal/data/store.go

@@ -173,13 +173,18 @@ func escapeLIKE(s string) string {
 }
 
 // lastActiveExpr is the SQL expression that computes a session's true
-// "last active" time: the latest turn timestamp, falling back to
-// updated_at then created_at.  Use this in WHERE/GROUP BY clauses
-// where column aliases are not available.
-const lastActiveExpr = `COALESCE(
-	(SELECT MAX(t.timestamp) FROM turns t WHERE t.session_id = s.id),
-	s.updated_at,
-	s.created_at
+// "last active" time as the most recent signal across indexed turns,
+// updated_at, and created_at.  Indexed turns may lag behind actual
+// activity (reindex hasn't run), while updated_at may occasionally be
+// noisy (metadata-only updates).  Taking the MAX of all three gives
+// the best available estimate.
+//
+// Each value is COALESCE'd to '' so that SQLite's multi-arg MAX()
+// never sees NULL (which would poison the result to NULL).
+const lastActiveExpr = `MAX(
+	COALESCE((SELECT MAX(t.timestamp) FROM turns t WHERE t.session_id = s.id), ''),
+	COALESCE(s.updated_at, ''),
+	COALESCE(s.created_at, '')
 )`
 
 // filterBuilder accumulates JOIN and WHERE clauses with parameterised args.
@@ -296,9 +301,10 @@ func pivotExpr(p PivotField) string {
 }
 
 // sessionColumns is the shared SELECT list used by session queries.
-// last_active_at is computed as the most recent turn timestamp, falling
-// back to updated_at then created_at so that reindex-clobbered dates
-// don't make old sessions appear recent.
+// last_active_at is the MAX of the most recent turn timestamp,
+// updated_at, and created_at — whichever is newest wins.  This
+// handles both stale turn indexes (updated_at is more recent) and
+// noisy updated_at values (turns are more recent).
 var sessionColumns = `s.id, ` + coalesceCwd + `, COALESCE(s.repository,''), COALESCE(s.branch,''),
 	COALESCE(s.summary,''), COALESCE(s.created_at,''), COALESCE(s.updated_at,''),
 	` + lastActiveExpr + ` AS last_active_at,

internal/data/store_test.go

@@ -2370,3 +2370,102 @@ func TestDeepSearchWithGroupSessions(t *testing.T) {
 		t.Fatalf("expected 1 session matching file path in groups, got %d", totalSessions)
 	}
 }
+
+// ---------------------------------------------------------------------------
+// lastActiveExpr regression tests — ensures the MAX-of-three logic picks
+// the most recent timestamp regardless of which source it comes from.
+// ---------------------------------------------------------------------------
+
+func TestLastActive_StaleTurnsUsesUpdatedAt(t *testing.T) {
+	// When turns are stale (not yet reindexed) but updated_at is recent,
+	// lastActiveAt should reflect updated_at.
+	s := newTestStore(t)
+	defer func() { _ = s.Close() }()
+
+	seedSession(t, s.db, "s1", "/work", "r", "main", "Stale turns",
+		"2026-04-20T00:00:00Z", "2026-04-27T12:00:00Z")
+	seedTurn(t, s.db, "s1", 0, "hello", "hi", "2026-04-20T10:00:00Z")
+
+	sessions, err := s.ListSessions(FilterOptions{}, SortOptions{Field: SortByUpdated, Order: Descending}, 0)
+	if err != nil {
+		t.Fatalf("ListSessions: %v", err)
+	}
+	if len(sessions) != 1 {
+		t.Fatalf("expected 1 session, got %d", len(sessions))
+	}
+	if sessions[0].LastActiveAt != "2026-04-27T12:00:00Z" {
+		t.Errorf("LastActiveAt = %q, want updated_at %q", sessions[0].LastActiveAt, "2026-04-27T12:00:00Z")
+	}
+}
+
+func TestLastActive_FreshTurnsUsedOverUpdatedAt(t *testing.T) {
+	// When turns are more recent than updated_at, lastActiveAt should
+	// use the turn timestamp.
+	s := newTestStore(t)
+	defer func() { _ = s.Close() }()
+
+	seedSession(t, s.db, "s1", "/work", "r", "main", "Fresh turns",
+		"2026-04-20T00:00:00Z", "2026-04-22T00:00:00Z")
+	seedTurn(t, s.db, "s1", 0, "hello", "hi", "2026-04-25T10:00:00Z")
+
+	sessions, err := s.ListSessions(FilterOptions{}, SortOptions{Field: SortByUpdated, Order: Descending}, 0)
+	if err != nil {
+		t.Fatalf("ListSessions: %v", err)
+	}
+	if len(sessions) != 1 {
+		t.Fatalf("expected 1 session, got %d", len(sessions))
+	}
+	if sessions[0].LastActiveAt != "2026-04-25T10:00:00Z" {
+		t.Errorf("LastActiveAt = %q, want turn timestamp %q", sessions[0].LastActiveAt, "2026-04-25T10:00:00Z")
+	}
+}
+
+func TestLastActive_NoTurnsFallsBackToUpdatedAt(t *testing.T) {
+	// Sessions with no turns should fall back to updated_at (or created_at).
+	s := newTestStore(t)
+	defer func() { _ = s.Close() }()
+
+	// Insert a session with a turn so it passes the "EXISTS turns" filter,
+	// then test a second session that does have turns but where updated_at
+	// is the winner. For the no-turns case the session is excluded by the
+	// zero-turn filter, so we test indirectly via GetSession.
+	seedSession(t, s.db, "s1", "/work", "r", "main", "No turns",
+		"2026-04-10T00:00:00Z", "2026-04-15T00:00:00Z")
+
+	detail, err := s.GetSession("s1")
+	if err != nil {
+		t.Fatalf("GetSession: %v", err)
+	}
+	if detail.Session.LastActiveAt != "2026-04-15T00:00:00Z" {
+		t.Errorf("LastActiveAt = %q, want updated_at %q", detail.Session.LastActiveAt, "2026-04-15T00:00:00Z")
+	}
+}
+
+func TestLastActive_StaleTurnsVisibleInDayFilter(t *testing.T) {
+	// Regression: a session with stale turn data but recent updated_at
+	// must appear under a "since 1 day ago" filter.
+	s := newTestStore(t)
+	defer func() { _ = s.Close() }()
+
+	now := time.Now()
+	recent := now.Add(-6 * time.Hour).UTC().Format(time.RFC3339)
+	old := now.Add(-72 * time.Hour).UTC().Format(time.RFC3339)
+
+	seedSession(t, s.db, "s1", "/msbench", "r", "main", "MSBench",
+		old, recent) // created 3d ago, updated 6h ago
+	seedTurn(t, s.db, "s1", 0, "build", "ok", old) // turn from 3d ago
+
+	since := now.Add(-24 * time.Hour)
+	sessions, err := s.ListSessions(
+		FilterOptions{Since: &since},
+		SortOptions{Field: SortByUpdated, Order: Descending}, 0)
+	if err != nil {
+		t.Fatalf("ListSessions: %v", err)
+	}
+	if len(sessions) != 1 {
+		t.Fatalf("expected 1 session within day filter, got %d", len(sessions))
+	}
+	if sessions[0].ID != "s1" {
+		t.Errorf("expected s1, got %s", sessions[0].ID)
+	}
+}