fix: fall back to embedded pricing in session export

Author: wesm

cmd/agentsview/export.go

@@ -203,6 +203,9 @@ func runExportSessions(cmd *cobra.Command, cfg exportSessionsConfig) error {
 	defer database.Close()
 
 	ctx := cmd.Context()
+	if err := ensureExportSessionsPricing(ctx, database, appCfg); err != nil {
+		return err
+	}
 	databaseID, err := database.GetDatabaseID(ctx)
 	if err != nil {
 		if errors.Is(err, db.ErrDatabaseIDMissing) {
@@ -244,6 +247,25 @@ func runExportSessions(cmd *cobra.Command, cfg exportSessionsConfig) error {
 	return enc.Encode(output)
 }
 
+// ensureExportSessionsPricing installs embedded fallback plus custom pricing
+// for archives whose model_pricing table was never seeded (fresh sync-only
+// archives, before serve or usage commands run). The read-only export cannot
+// seed the table, and the overlay would override newer fetched rows, so it is
+// gated on the table being empty.
+func ensureExportSessionsPricing(
+	ctx context.Context, database *db.DB, appCfg config.Config,
+) error {
+	seeded, err := database.HasModelPricingRows(ctx)
+	if err != nil {
+		return fmt.Errorf("checking export pricing: %w", err)
+	}
+	if seeded {
+		return nil
+	}
+	applyFallbackPricing(database, appCfg.CustomModelPricing)
+	return nil
+}
+
 func validateExportSessionsCursorFlags(flags *pflag.FlagSet) error {
 	for _, name := range []string{
 		"project",

cmd/agentsview/export_sessions_test.go

@@ -18,6 +18,7 @@ import (
 	"go.kenn.io/agentsview/internal/db"
 	"go.kenn.io/agentsview/internal/dbtest"
 	"go.kenn.io/agentsview/internal/export"
+	"go.kenn.io/agentsview/internal/pricing"
 )
 
 type exportSessionsDocument struct {
@@ -505,6 +506,81 @@ func firstExportSessionsCursor(t *testing.T) string {
 	return doc.Cursor.Next
 }
 
+func TestExportSessionsFallbackPricingOnUnseededArchive(t *testing.T) {
+	dataDir := testDataDir(t)
+	database := dbtest.OpenTestDBAt(t, filepath.Join(dataDir, "sessions.db"))
+	require.NoError(t, database.SetDatabaseIDForTest(
+		context.Background(), "fallback-pricing-test-db"))
+
+	model := exactFallbackPricedModel(t)
+	insertExportSessionsTestSession(t, database, db.Session{
+		ID:               "fallback-priced",
+		Project:          "alpha",
+		Machine:          "local",
+		Agent:            "claude",
+		StartedAt:        dbtest.Ptr("2026-06-01T10:00:00Z"),
+		EndedAt:          dbtest.Ptr("2026-06-01T10:10:00Z"),
+		MessageCount:     3,
+		UserMessageCount: 2,
+	})
+	require.NoError(t, database.InsertMessages([]db.Message{
+		{
+			SessionID: "fallback-priced", Ordinal: 0, Role: "user",
+			Content: "question", ContentLength: len("question"),
+			Timestamp: "2026-06-01T10:00:00Z",
+		},
+		{
+			SessionID: "fallback-priced", Ordinal: 1, Role: "assistant",
+			Content: "answer", ContentLength: len("answer"),
+			Timestamp: "2026-06-01T10:05:00Z", Model: model,
+			TokenUsage: json.RawMessage(
+				`{"input_tokens":1000,"output_tokens":500}`),
+		},
+		{
+			SessionID: "fallback-priced", Ordinal: 2, Role: "user",
+			Content: "follow up", ContentLength: len("follow up"),
+			Timestamp: "2026-06-01T10:06:00Z",
+		},
+	}), "insert messages")
+	require.NoError(t, database.Close(), "close seeded archive")
+
+	stdout, stderr, err := executeExportSessionsCommand(
+		newRootCommand(), "export", "sessions")
+	require.NoError(t, err, "export sessions on unseeded archive")
+	assert.Empty(t, stderr)
+
+	doc := decodeExportSessionsDocument(t, stdout)
+	require.Len(t, doc.Sessions, 1, "exported sessions")
+	usage := doc.Sessions[0].ModelUsage
+	require.NotNil(t, usage, "model usage")
+	assert.True(t, usage.HasCost,
+		"fallback-priced model %s should have cost", model)
+	assert.Greater(t, usage.CostUSD, 0.0, "fallback-priced cost")
+
+	fallback, ok := doc.Pricing["fallback"].(map[string]any)
+	require.True(t, ok, "pricing fallback block")
+	assert.Equal(t, true, fallback["used"], "fallback used")
+	assert.Contains(t, doc.Pricing["source"], "embedded",
+		"pricing source provenance")
+}
+
+// exactFallbackPricedModel returns an embedded fallback model pattern with
+// non-wildcard name and nonzero input/output rates, so lookups resolve
+// deterministically regardless of snapshot contents.
+func exactFallbackPricedModel(t *testing.T) string {
+	t.Helper()
+	for _, p := range pricing.FallbackPricing() {
+		if strings.ContainsAny(p.ModelPattern, "*/_") {
+			continue
+		}
+		if p.InputPerMTok > 0 && p.OutputPerMTok > 0 {
+			return p.ModelPattern
+		}
+	}
+	t.Fatal("no exact fallback-priced model in embedded snapshot")
+	return ""
+}
+
 func executeExportSessionsCommand(
 	root *cobra.Command, args ...string,
 ) (string, string, error) {

internal/db/pricing.go

@@ -289,6 +289,21 @@ func (db *DB) InsertMissingModelPricing(
 
 // GetModelPricing returns pricing for an exact model match.
 // Returns nil, nil if not found.
+// HasModelPricingRows reports whether any non-meta pricing rows are
+// stored, using the same meta-row exclusion as pricing map loads.
+func (db *DB) HasModelPricingRows(ctx context.Context) (bool, error) {
+	var exists bool
+	err := db.getReader().QueryRowContext(ctx,
+		`SELECT EXISTS(
+			SELECT 1 FROM model_pricing
+			WHERE model_pattern NOT LIKE '\_%' ESCAPE '\')`,
+	).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("checking pricing rows: %w", err)
+	}
+	return exists, nil
+}
+
 func (db *DB) GetModelPricing(
 	model string,
 ) (*ModelPricing, error) {