fix(export): bind reconciliation to snapshot order

Reporting snapshots must agree with daily usage on survivor selection and must not let pre-snapshot fallback state mask catalog rows visible to the snapshot. Binding timestamp comparison to SQLite text order and making fallback conditional on transaction-visible catalog emptiness preserves exact totals under mixed precision and concurrent catalog initialization.

Author: wesm

cmd/agentsview/export_reporting.go

@@ -214,12 +214,7 @@ func openReportingExportDB(
 	if err != nil {
 		return nil, func() {}, err
 	}
-	if err := ensureExportSessionsPricing(
-		cmd.Context(), database, appConfig,
-	); err != nil {
-		_ = database.Close()
-		return nil, func() {}, err
-	}
+	applyEmptyCatalogPricing(database, appConfig.CustomModelPricing)
 	return database, func() {
 		_ = database.Close()
 	}, nil

cmd/agentsview/export_reporting_test.go

@@ -348,6 +348,87 @@ func TestExportReportingFallbackPricingOnUnseededArchive(t *testing.T) {
 	assert.Positive(t, hour.Activity.Totals.Cost.Microdollars)
 }
 
+func TestExportReportingSnapshotStoredPricingOverridesInstalledFallback(
+	t *testing.T,
+) {
+	dataDir := testDataDir(t)
+	database := dbtest.OpenTestDBAt(t, filepath.Join(dataDir, "sessions.db"))
+	t.Cleanup(func() {
+		require.NoError(t, database.Close())
+	})
+	model := exactFallbackPricedModel(t)
+	require.NoError(t, database.UpsertSession(db.Session{
+		ID:               "fixture-snapshot-pricing",
+		Machine:          "fixture-machine",
+		Agent:            "agent snapshot",
+		StartedAt:        dbtest.Ptr("2026-07-28T10:00:00Z"),
+		EndedAt:          dbtest.Ptr("2026-07-28T10:06:00Z"),
+		MessageCount:     2,
+		UserMessageCount: 1,
+	}))
+	require.NoError(t, database.InsertMessages([]db.Message{
+		{
+			SessionID:     "fixture-snapshot-pricing",
+			Ordinal:       0,
+			Role:          "user",
+			Content:       "synthetic question",
+			ContentLength: len("synthetic question"),
+			Timestamp:     "2026-07-28T10:00:00Z",
+		},
+		{
+			SessionID:     "fixture-snapshot-pricing",
+			Ordinal:       1,
+			Role:          "assistant",
+			Content:       "synthetic answer",
+			ContentLength: len("synthetic answer"),
+			Timestamp:     "2026-07-28T10:05:00Z",
+			Model:         model,
+			TokenUsage: json.RawMessage(
+				`{"input_tokens":1000,"output_tokens":500}`,
+			),
+		},
+	}))
+
+	deps := defaultExportReportingDeps()
+	deps.now = func() time.Time {
+		return time.Date(2026, 7, 29, 14, 37, 0, 0, time.UTC)
+	}
+	openDatabase := deps.openDatabase
+	deps.openDatabase = func(
+		cmd *cobra.Command,
+	) (*db.DB, func(), error) {
+		reader, cleanup, err := openDatabase(cmd)
+		if err != nil {
+			return nil, func() {}, err
+		}
+		if err := database.UpsertModelPricing([]db.ModelPricing{{
+			ModelPattern:  model,
+			InputPerMTok:  money.MustParseDollars("123"),
+			OutputPerMTok: money.MustParseDollars("456"),
+		}}); err != nil {
+			cleanup()
+			return nil, func() {}, err
+		}
+		return reader, cleanup, nil
+	}
+
+	stdout, stderr, err := executeExportSessionsCommand(
+		newExportReportingTestRootWithDeps(deps),
+		"export", "hour", "2026-07-28-10",
+	)
+	require.NoError(t, err)
+	assert.Empty(t, stderr)
+
+	var hour export.ReportingHour
+	require.NoError(t, json.Unmarshal([]byte(stdout), &hour))
+	assert.Equal(
+		t,
+		money.Money{Microdollars: 351_000},
+		hour.Usage.Totals.Cost,
+	)
+	assert.Equal(t, hour.Usage.Totals.Cost, hour.Activity.Totals.Cost)
+}
+
 func newExportReportingTestRoot(now time.Time) *cobra.Command {
 	deps := defaultExportReportingDeps()
 	deps.now = func() time.Time { return now }

cmd/agentsview/usage.go

@@ -420,6 +420,18 @@ func ensureUsagePricing(
 func applyFallbackPricing(
 	database *db.DB, custom map[string]config.CustomModelRate,
 ) {
+	database.SetEffectivePricing(fallbackPricingRates(custom))
+}
+
+func applyEmptyCatalogPricing(
+	database *db.DB, custom map[string]config.CustomModelRate,
+) {
+	database.SetEmptyCatalogPricing(fallbackPricingRates(custom))
+}
+
+func fallbackPricingRates(
+	custom map[string]config.CustomModelRate,
+) map[string]export.ModelRates {
 	rates := make(map[string]export.ModelRates)
 	for _, p := range pricing.FallbackPricing() {
 		// These keys are the same concrete model-pattern keys that the
@@ -462,7 +474,7 @@ func applyFallbackPricing(
 			Source: export.PricingRowSourceCustom,
 		}
 	}
-	database.SetEffectivePricing(rates)
+	return rates
 }
 
 func fetchHTTPDailyUsage(

internal/activity/activity.go

@@ -53,7 +53,8 @@ type ActivityEvent struct {
 // UsageRow is one cost/token row from the usage-row union, with cost already
 // computed by the backend (so cost logic stays in each backend, matching
 // GetDailyUsage). Rows MUST be delivered ordered by
-// (ts ASC, session_id ASC, COALESCE(message_ordinal,-1) ASC).
+// (ts text in SQLite BINARY order, session_id ASC,
+// COALESCE(message_ordinal,-1) ASC).
 type UsageRow struct {
 	SessionID           string
 	Model               string

internal/db/activityreport.go

@@ -463,7 +463,6 @@ func (db *DB) activityReportUsageFrom(
 type activityReportUsageCandidate struct {
 	row     activity.UsageRow
 	scan    dailyUsageScanRow
-	ts      time.Time
 	ordinal int64
 }
 
@@ -520,9 +519,7 @@ func (db *DB) loadActivityReportUsageCandidatesFrom(
 			if r.messageOrdinal.Valid {
 				ord = r.messageOrdinal.Int64
 			}
-			parsedTS, _ := parseTimestamp(r.ts)
 			candidates = append(candidates, activityReportUsageCandidate{
-				ts:      parsedTS,
 				ordinal: ord,
 				scan:    r,
 				row: activity.UsageRow{
@@ -554,8 +551,10 @@ func sortActivityReportUsageCandidates(
 ) {
 	sort.SliceStable(candidates, func(i, j int) bool {
 		a, b := candidates[i], candidates[j]
-		if !a.ts.Equal(b.ts) {
-			return a.ts.Before(b.ts)
+		if compared := compareDailyUsageTimestampText(
+			a.row.Timestamp, b.row.Timestamp,
+		); compared != 0 {
+			return compared < 0
 		}
 		if a.row.SessionID != b.row.SessionID {
 			return a.row.SessionID < b.row.SessionID
@@ -567,6 +566,12 @@ func sortActivityReportUsageCandidates(
 	})
 }
 
+// compareDailyUsageTimestampText mirrors SQLite's default BINARY ordering for
+// the u.ts column used by GetDailyUsage's first-seen-wins survivor pass.
+func compareDailyUsageTimestampText(a, b string) int {
+	return cmp.Compare(a, b)
+}
+
 // activityReportUsageCandidatesFrom returns normalized padded-range rows
 // without sorting or applying a survivor mask. Reporting export merges these
 // rows with standalone candidates before imposing either operation.

internal/db/db.go

@@ -546,8 +546,9 @@ type DB struct {
 	cursorMu     sync.RWMutex
 	cursorSecret []byte
 
-	customPricing    map[string]config.CustomModelRate
-	effectivePricing map[string]export.ModelRates
+	customPricing       map[string]config.CustomModelRate
+	effectivePricing    map[string]export.ModelRates
+	emptyCatalogPricing map[string]export.ModelRates
 
 	checkpointMu   sync.Mutex
 	checkpointStop chan struct{}
@@ -808,6 +809,18 @@ func (db *DB) SetEffectivePricing(
 	}
 }
 
+// SetEmptyCatalogPricing installs in-memory rates that are used only when the
+// query source loading pricing sees no stored catalog rows.
+func (db *DB) SetEmptyCatalogPricing(
+	p map[string]export.ModelRates,
+) {
+	db.emptyCatalogPricing = make(map[string]export.ModelRates, len(p))
+	for model, rates := range p {
+		rates.Bands = append([]export.PricingBand(nil), rates.Bands...)
+		db.emptyCatalogPricing[model] = rates
+	}
+}
+
 // SetCursorSecret updates the secret key used for cursor signing.
 func (db *DB) SetCursorSecret(secret []byte) {
 	db.cursorMu.Lock()

internal/db/reporting_export.go

@@ -377,13 +377,10 @@ func (db *DB) reportingStandaloneUsageCandidatesFrom(
 func sortReportingUsage(rows []activity.UsageRow) {
 	sort.SliceStable(rows, func(i, j int) bool {
 		a, b := rows[i], rows[j]
-		aTime, aErr := parseTimestamp(a.Timestamp)
-		bTime, bErr := parseTimestamp(b.Timestamp)
-		if aErr == nil && bErr == nil && !aTime.Equal(bTime) {
-			return aTime.Before(bTime)
-		}
-		if a.Timestamp != b.Timestamp {
-			return a.Timestamp < b.Timestamp
+		if compared := compareDailyUsageTimestampText(
+			a.Timestamp, b.Timestamp,
+		); compared != 0 {
+			return compared < 0
 		}
 		if a.SessionID != b.SessionID {
 			return a.SessionID < b.SessionID

internal/db/reporting_export_test.go

@@ -649,6 +649,64 @@ func TestReportingExportDeduplicatesMergedUsageInputs(t *testing.T) {
 	assert.Zero(t, hour.Activity.Totals.NewModels)
 }
 
+func TestReportingExportDedupMatchesDailyUsageForMixedTimestampPrecision(
+	t *testing.T,
+) {
+	d := testDB(t)
+	insertSession(t, d, "fixture-mixed-precision", "project precision", func(s *Session) {
+		s.Agent = "agent precision"
+		s.StartedAt = Ptr("2026-07-28T09:00:00Z")
+		s.EndedAt = Ptr("2026-07-28T09:01:00Z")
+	})
+	sessionCost := money.MustParseDollars("0.002")
+	require.NoError(t, d.ReplaceSessionUsageEvents(
+		"fixture-mixed-precision",
+		[]UsageEvent{{
+			Source:       "fixture-source",
+			Model:        "model earlier instant",
+			InputTokens:  41,
+			OutputTokens: 7,
+			Cost:         &sessionCost,
+			CostStatus:   "exact",
+			CostSource:   "reported",
+			OccurredAt:   "2026-07-28T09:00:00Z",
+			DedupKey:     "shared",
+		}},
+	))
+	require.NoError(t, d.InsertCursorUsageEvents([]CursorUsageEvent{{
+		OccurredAt:   "2026-07-28T09:00:00.123Z",
+		Model:        "model text-order winner",
+		Kind:         "usage",
+		InputTokens:  17,
+		OutputTokens: 3,
+		Charged:      money.MustParseDollars("0.007"),
+		DedupKey:     "fixture-mixed-precision:fixture-source:shared",
+	}}))
+
+	day, err := d.ExportReportingDay(context.Background(), ReportingExportOptions{
+		Date: time.Date(2026, 7, 28, 0, 0, 0, 0, time.UTC),
+		Now:  time.Date(2026, 7, 29, 12, 0, 0, 0, time.UTC),
+	})
+	require.NoError(t, err)
+	daily, err := d.GetDailyUsage(context.Background(), UsageFilter{
+		From:       "2026-07-28",
+		To:         "2026-07-28",
+		Timezone:   "UTC",
+		Breakdowns: true,
+	})
+	require.NoError(t, err)
+
+	hour := day.Hours[9]
+	assert.Equal(t, int64(17), hour.Usage.Totals.InputTokens)
+	assert.Equal(t, int64(3), hour.Usage.Totals.OutputTokens)
+	assert.Equal(t, money.MustParseDollars("0.007"), hour.Usage.Totals.Cost)
+	require.Len(t, hour.Usage.ByModel, 1)
+	assert.Equal(t, "model text-order winner", hour.Usage.ByModel[0].Key)
+	assert.Equal(t, daily.Totals.InputTokens, int(hour.Usage.Totals.InputTokens))
+	assert.Equal(t, daily.Totals.OutputTokens, int(hour.Usage.Totals.OutputTokens))
+	assert.Equal(t, daily.Totals.TotalCost, hour.Usage.Totals.Cost)
+}
+
 func TestReportingExportPreservesMessageOrdinalForDedup(t *testing.T) {
 	d := testDB(t)
 	insertSession(t, d, "fixture-ordinal", "", func(s *Session) {

internal/db/usage.go

@@ -1808,6 +1808,12 @@ func (db *DB) loadPricingMapFrom(
 		out[p.ModelPattern] = rates
 	}
 
+	if len(out) == 0 {
+		for model, rates := range db.emptyCatalogPricing {
+			rates.Bands = append([]export.PricingBand(nil), rates.Bands...)
+			out[model] = rates
+		}
+	}
 	for model, cp := range db.customPricing {
 		rates := export.ModelRates{
 			InputPerMTok: money.Money{