fix(activity): correct usage dedup ordering and zero-cost primary model

SQLite activityReportUsage sorted usage rows by RFC3339 text, so within one second a fractional timestamp ("...00.123Z") sorted before a whole-second one ("...00Z") because '.' < 'Z'. With first-seen-wins dedup this could keep a different duplicate row than PostgreSQL/DuckDB and diverge on token and cost totals. Carry a parsed time.Time on each row and sort on the instant, matching the other backends.

primaryAndModels chose a model only when its weight was greater than zero. For usage-only sessions model weight comes from cost, so zero-cost or unpriced usage left primary_model blank while the models list still named the model, showing a known-model session with no model in the table. Fall back to the first model in sorted order when no model has positive weight.

Both paths get a regression test: the SQLite usage sort with same-second duplicate keys, and the aggregator with a zero-cost usage-only session.

Author: wesm

internal/activity/activity.go

@@ -767,8 +767,11 @@ func minutesOf(s SessionRow) float64 {
 	return *s.AgentMinutes
 }
 
-// primaryAndModels returns the highest-weight model and the sorted set; the
-// primary is "" when no model has weight. Caller renders "mixed" when len>1.
+// primaryAndModels returns the highest-weight model and the sorted set. When
+// no model carries positive weight (e.g. zero-cost or unpriced usage) it falls
+// back to the first model in sorted order, so a known-model session still
+// reports a primary; the primary is "" only when the set is empty. Caller
+// renders "mixed" when len>1.
 func primaryAndModels(w map[string]float64) (string, []string) {
 	var keys []string
 	primary := ""
@@ -783,5 +786,8 @@ func primaryAndModels(w map[string]float64) (string, []string) {
 		}
 	}
 	sort.Strings(keys)
+	if primary == "" && len(keys) > 0 {
+		primary = keys[0]
+	}
 	return primary, keys
 }

internal/activity/activity_test.go

@@ -511,3 +511,35 @@ func TestAggregate_BreakdownCostAndAutomatedSegments(t *testing.T) {
 	assert.InDelta(t, 5.0, r.ByModel[0].AutomatedCost, 1e-9)
 	assert.InDelta(t, 2.0, r.ByModel[0].InteractiveCost, 1e-9)
 }
+
+// TestAggregate_UsageOnlySessionZeroCostKeepsPrimaryModel confirms a session
+// whose only signal is zero-cost or unpriced usage still reports its known
+// model as the primary. Model weight for usage-only sessions comes from cost,
+// so a zero cost left primary_model blank while models listed the model,
+// showing a known-model session with no model in the table.
+func TestAggregate_UsageOnlySessionZeroCostKeepsPrimaryModel(t *testing.T) {
+	loc := mustLoad(t, "UTC")
+	start := mustStart(t, "2026-06-16T00:00:00Z")
+	end := start.AddDate(0, 0, 1)
+	p := Params{
+		RangeStart: start, RangeEnd: end, Loc: loc,
+		EffectiveEnd: end, Partial: false,
+		GapCapSeconds: 300, Bucket: BucketSpec{BucketMinute, 300},
+	}
+	// One untimed session (no activity events) whose single usage row has a
+	// known model but ZERO cost.
+	usage := []UsageRow{
+		{SessionID: "u", Model: "m1", Timestamp: "2026-06-16T10:00:00Z",
+			OutputTokens: 0, Cost: 0, ClaudeMessageID: "u", ClaudeRequestID: "r"},
+	}
+	sessions := []SessionMeta{
+		{SessionID: "u", Project: "P", Agent: "claude"},
+	}
+	r := Aggregate(p, sessions, nil, usage)
+
+	require.Len(t, r.BySession, 1)
+	row := r.BySession[0]
+	assert.Equal(t, "m1", row.PrimaryModel,
+		"zero-cost usage must still report its known model as primary")
+	assert.Equal(t, []string{"m1"}, row.Models)
+}

internal/db/activityreport.go

@@ -178,7 +178,11 @@ func (db *DB) activityReportActivity(
 // within the padded range bounds, with per-row cost computed up front
 // (mirroring GetDailyUsage) so cost logic stays in the backend. Rows
 // are ordered by (ts, session_id, message_ordinal) as the aggregator
-// requires for its first-seen-wins dedup.
+// requires for its first-seen-wins dedup. The order is computed on the
+// parsed instant, not the RFC3339 text, so a whole-second value ("...00Z")
+// and a fractional one ("...00.123Z") in the same second sort
+// chronologically (matching PostgreSQL/DuckDB); lexically '.' < 'Z' would
+// otherwise invert them and let SQLite keep a different duplicate row.
 func (db *DB) activityReportUsage(
 	ctx context.Context, ids []string, lowerBound, upperBound string,
 ) ([]activity.UsageRow, error) {
@@ -192,13 +196,14 @@ func (db *DB) activityReportUsage(
 		return nil, fmt.Errorf("loading pricing: %w", err)
 	}
 
-	// Accumulate the per-row dedup ordinal alongside the mapped row so we
-	// can impose one global (ts, session_id, ordinal) order across all
+	// Accumulate the parsed ts and dedup ordinal alongside each mapped row so
+	// we can impose one global (ts, session_id, ordinal) order across all
 	// chunks. The same (claude_message_id, claude_request_id) can recur in
 	// different sessions (resumed/forked) and thus different chunks, so
 	// per-chunk ordering is not enough for the aggregator's first-seen dedup.
 	type ordered struct {
 		row     activity.UsageRow
+		ts      time.Time
 		ordinal int64
 	}
 	var rowsAcc []ordered
@@ -236,7 +241,9 @@ func (db *DB) activityReportUsage(
 			if r.messageOrdinal.Valid {
 				ord = r.messageOrdinal.Int64
 			}
+			parsedTS, _ := parseTimestamp(r.ts)
 			rowsAcc = append(rowsAcc, ordered{
+				ts:      parsedTS,
 				ordinal: ord,
 				row: activity.UsageRow{
 					SessionID:       r.sessionID,
@@ -258,8 +265,8 @@ func (db *DB) activityReportUsage(
 
 	sort.SliceStable(rowsAcc, func(i, j int) bool {
 		a, b := rowsAcc[i], rowsAcc[j]
-		if a.row.Timestamp != b.row.Timestamp {
-			return a.row.Timestamp < b.row.Timestamp
+		if !a.ts.Equal(b.ts) {
+			return a.ts.Before(b.ts)
 		}
 		if a.row.SessionID != b.row.SessionID {
 			return a.row.SessionID < b.row.SessionID

internal/db/activityreport_test.go

@@ -333,3 +333,52 @@ func TestGetActivityReport_HourlyRange(t *testing.T) {
 	}
 	assert.True(t, found, "the 2026-06-17T10:00 hourly bucket must be present")
 }
+
+// TestGetActivityReport_UsageDedupSubSecondOrder confirms the SQLite usage
+// stream is ordered by the PARSED instant, not the RFC3339 text. A
+// resumed/forked pair shares one (claude_message_id, claude_request_id) dedup
+// key in the same second: one whole-second instant ("...00Z", 500 output
+// tokens) and one fractional ("...00.123Z", 9000). Lexically "...00.123Z"
+// sorts before "...00Z" ('.' < 'Z'), so a TEXT sort would keep the 9000 row;
+// chronologically the whole-second row is first. First-seen-wins dedup must
+// keep the 500 row, matching PostgreSQL/DuckDB which order on the parsed time.
+func TestGetActivityReport_UsageDedupSubSecondOrder(t *testing.T) {
+	d := testDB(t)
+	ctx := context.Background()
+	require.NoError(t, d.UpsertModelPricing([]ModelPricing{{
+		ModelPattern:  "claude-sonnet-4-20250514",
+		InputPerMTok:  3.0,
+		OutputPerMTok: 15.0,
+	}}), "UpsertModelPricing")
+
+	insertSession(t, d, "earlier", "proj1", func(s *Session) {
+		s.Agent = "claude"
+		s.StartedAt = Ptr("2026-06-16T10:30:00Z")
+		s.EndedAt = Ptr("2026-06-16T10:30:00Z")
+	})
+	insertMessages(t, d, Message{
+		SessionID: "earlier", Ordinal: 0, Role: "assistant", Content: "x",
+		Timestamp:       "2026-06-16T10:30:00Z",
+		Model:           "claude-sonnet-4-20250514",
+		ClaudeMessageID: "m-dup", ClaudeRequestID: "r-dup",
+		TokenUsage: json.RawMessage(`{"input_tokens":1000,"output_tokens":500}`),
+	})
+	insertSession(t, d, "later", "proj2", func(s *Session) {
+		s.Agent = "claude"
+		s.StartedAt = Ptr("2026-06-16T10:30:00Z")
+		s.EndedAt = Ptr("2026-06-16T10:30:00Z")
+	})
+	insertMessages(t, d, Message{
+		SessionID: "later", Ordinal: 0, Role: "assistant", Content: "x",
+		Timestamp:       "2026-06-16T10:30:00.123Z",
+		Model:           "claude-sonnet-4-20250514",
+		ClaudeMessageID: "m-dup", ClaudeRequestID: "r-dup",
+		TokenUsage: json.RawMessage(`{"input_tokens":1000,"output_tokens":9000}`),
+	})
+
+	r, err := d.GetActivityReport(ctx, AnalyticsFilter{Timezone: "UTC"},
+		dayQuery(t, "2026-06-16", "UTC"))
+	require.NoError(t, err)
+	assert.Equal(t, 500, r.Totals.OutputTokens,
+		"first-seen dedup keeps the chronologically earlier whole-second row")
+}