perf(app): lazy tab reload after mutations, add benchmarks

Replace reloadAll() in mutation paths (save, undo, redo, inline edit)
with reloadAfterMutation() which only refreshes the effective tab and
marks all others as stale. Stale tabs are lazily reloaded when the user
navigates to them (tab switch, dashboard jump, FK link follow).

Before: every mutation reloaded all 5 tabs + lookups + house + dashboard
        ~3ms, 680KB, 15,670 allocs per mutation

After:  only the active tab + dashboard (if visible)
        ~489us (dashboard hidden), ~1ms (dashboard visible)
        6.2x faster with dashboard hidden, 3x with it open

Also adds comprehensive benchmarks for render, reload, and data layer
hot paths to track regressions.

refs #53

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: cpcloud

internal/app/bench_test.go

@@ -0,0 +1,188 @@
+// Copyright 2026 Phillip Cloud
+// Licensed under the Apache License, Version 2.0
+
+package app
+
+import (
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/cpcloud/micasa/internal/data"
+	"github.com/cpcloud/micasa/internal/fake"
+)
+
+// benchModel returns a Model populated with demo data, sized for a
+// realistic terminal. Reusable across benchmarks.
+func benchModel(b *testing.B) *Model {
+	b.Helper()
+	path := filepath.Join(b.TempDir(), "bench.db")
+	store, err := data.Open(path)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.Cleanup(func() { _ = store.Close() })
+	if err := store.AutoMigrate(); err != nil {
+		b.Fatal(err)
+	}
+	if err := store.SeedDefaults(); err != nil {
+		b.Fatal(err)
+	}
+	if err := store.SeedDemoDataFrom(fake.New(42)); err != nil {
+		b.Fatal(err)
+	}
+	m, err := NewModel(store, Options{DBPath: path})
+	if err != nil {
+		b.Fatal(err)
+	}
+	m.width = 120
+	m.height = 40
+	m.showDashboard = false
+	if err := m.reloadAllTabs(); err != nil {
+		b.Fatal(err)
+	}
+	return m
+}
+
+func BenchmarkView(b *testing.B) {
+	m := benchModel(b)
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.View()
+	}
+}
+
+func BenchmarkViewDashboard(b *testing.B) {
+	m := benchModel(b)
+	m.showDashboard = true
+	if err := m.loadDashboardAt(time.Now()); err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.View()
+	}
+}
+
+func BenchmarkReloadAll(b *testing.B) {
+	m := benchModel(b)
+	b.ResetTimer()
+	for b.Loop() {
+		m.reloadAll()
+	}
+}
+
+func BenchmarkReloadActiveTab(b *testing.B) {
+	m := benchModel(b)
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.reloadActiveTab()
+	}
+}
+
+func BenchmarkReloadAfterMutation(b *testing.B) {
+	m := benchModel(b)
+	b.ResetTimer()
+	for b.Loop() {
+		m.reloadAfterMutation()
+	}
+}
+
+func BenchmarkReloadAfterMutationWithDashboard(b *testing.B) {
+	m := benchModel(b)
+	m.showDashboard = true
+	if err := m.loadDashboardAt(time.Now()); err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for b.Loop() {
+		m.reloadAfterMutation()
+	}
+}
+
+func BenchmarkLoadDashboard(b *testing.B) {
+	m := benchModel(b)
+	now := time.Now()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.loadDashboardAt(now)
+	}
+}
+
+func BenchmarkColumnWidths(b *testing.B) {
+	m := benchModel(b)
+	tab := m.activeTab()
+	visSpecs, visCells, _, _, _ := visibleProjection(tab)
+	sepW := 3
+	b.ResetTimer()
+	for b.Loop() {
+		_ = columnWidths(visSpecs, visCells, 120, sepW)
+	}
+}
+
+func BenchmarkNaturalWidths(b *testing.B) {
+	m := benchModel(b)
+	tab := m.activeTab()
+	visSpecs, visCells, _, _, _ := visibleProjection(tab)
+	b.ResetTimer()
+	for b.Loop() {
+		_ = naturalWidths(visSpecs, visCells)
+	}
+}
+
+func BenchmarkVisibleProjection(b *testing.B) {
+	m := benchModel(b)
+	tab := m.activeTab()
+	b.ResetTimer()
+	for b.Loop() {
+		_, _, _, _, _ = visibleProjection(tab)
+	}
+}
+
+func BenchmarkComputeTableViewport(b *testing.B) {
+	m := benchModel(b)
+	tab := m.activeTab()
+	sep := m.styles.TableSeparator.Render(" │ ")
+	b.ResetTimer()
+	for b.Loop() {
+		_ = computeTableViewport(tab, 120, sep, m.styles)
+	}
+}
+
+func BenchmarkTableView(b *testing.B) {
+	m := benchModel(b)
+	tab := m.activeTab()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.tableView(tab)
+	}
+}
+
+func BenchmarkDashboardView(b *testing.B) {
+	m := benchModel(b)
+	m.showDashboard = true
+	if err := m.loadDashboardAt(time.Now()); err != nil {
+		b.Fatal(err)
+	}
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.dashboardView(30)
+	}
+}
+
+func BenchmarkBuildBaseView(b *testing.B) {
+	m := benchModel(b)
+	b.ResetTimer()
+	for b.Loop() {
+		_ = m.buildBaseView()
+	}
+}
+
+func BenchmarkDimBackground(b *testing.B) {
+	m := benchModel(b)
+	base := m.buildBaseView()
+	b.ResetTimer()
+	for b.Loop() {
+		_ = dimBackground(base)
+	}
+}

internal/app/dashboard.go

@@ -776,8 +776,13 @@ func (m *Model) dashJump() {
 	entry := nav[m.dashCursor]
 	m.showDashboard = false
 	m.active = tabIndex(entry.Tab)
-	_ = m.reloadActiveTab()
-	if tab := m.activeTab(); tab != nil {
+	tab := m.activeTab()
+	if tab != nil && tab.Stale {
+		_ = m.reloadIfStale(tab)
+	} else {
+		_ = m.reloadActiveTab()
+	}
+	if tab != nil {
 		selectRowByID(tab, entry.ID)
 	}
 }

internal/app/forms.go

@@ -1113,13 +1113,14 @@ func (m *Model) openDatePicker(
 	m.editID = &id
 	m.formKind = kind
 	m.formData = values
+	savedKind := kind
 	m.openCalendar(dateField, func() {
 		m.snapshotForUndo()
 		if err := m.handleFormSubmit(); err != nil {
 			m.setStatusError(err.Error())
 		} else {
 			m.setStatusInfo("Saved.")
-			m.reloadAll()
+			m.reloadAfterFormSave(savedKind)
 		}
 		m.formKind = formNone
 		m.formData = nil

internal/app/lazy_reload_test.go

@@ -0,0 +1,96 @@
+// Copyright 2026 Phillip Cloud
+// Licensed under the Apache License, Version 2.0
+
+package app
+
+import (
+	"testing"
+)
+
+func TestReloadAfterMutationMarksOtherTabsStale(t *testing.T) {
+	m := newTestModelWithDemoData(t, 42)
+	m.width = 120
+	m.height = 40
+
+	// Start on the Projects tab (index 0).
+	m.active = 0
+	m.reloadAfterMutation()
+
+	// Active tab (0) should NOT be stale.
+	if m.tabs[0].Stale {
+		t.Error("active tab should not be stale after reloadAfterMutation")
+	}
+
+	// All other tabs should be stale.
+	for i := 1; i < len(m.tabs); i++ {
+		if !m.tabs[i].Stale {
+			t.Errorf("tab %d (%s) should be stale after mutation on tab 0", i, m.tabs[i].Name)
+		}
+	}
+}
+
+func TestNavigatingToStaleTabClearsStaleFlag(t *testing.T) {
+	m := newTestModelWithDemoData(t, 42)
+	m.width = 120
+	m.height = 40
+
+	// Simulate a mutation on tab 0 to mark others stale.
+	m.active = 0
+	m.reloadAfterMutation()
+
+	// Navigate to the next tab.
+	m.nextTab()
+	if m.active != 1 {
+		t.Fatalf("expected active=1, got %d", m.active)
+	}
+
+	// After navigation, the new active tab should not be stale.
+	if m.tabs[1].Stale {
+		t.Error("tab 1 should not be stale after navigating to it")
+	}
+
+	// But tab 2 should still be stale (we haven't visited it).
+	if !m.tabs[2].Stale {
+		t.Error("tab 2 should still be stale")
+	}
+}
+
+func TestPrevTabClearsStaleFlag(t *testing.T) {
+	m := newTestModelWithDemoData(t, 42)
+	m.width = 120
+	m.height = 40
+
+	// Start on tab 2, mutate to mark others stale.
+	m.active = 2
+	m.reloadAfterMutation()
+
+	// Navigate backward.
+	m.prevTab()
+	if m.active != 1 {
+		t.Fatalf("expected active=1, got %d", m.active)
+	}
+	if m.tabs[1].Stale {
+		t.Error("tab 1 should not be stale after navigating to it via prevTab")
+	}
+}
+
+func TestReloadAllClearsAllStaleFlags(t *testing.T) {
+	m := newTestModelWithDemoData(t, 42)
+	m.width = 120
+	m.height = 40
+
+	// Mark tabs stale.
+	for i := range m.tabs {
+		m.tabs[i].Stale = true
+	}
+
+	// reloadAllTabs resets all data, and reloadIfStale clears per-tab.
+	m.reloadAll()
+
+	// After reloadAll, no tabs should be stale (they were all freshly loaded).
+	for i := range m.tabs {
+		if m.tabs[i].Stale {
+			t.Errorf("tab %d (%s) should not be stale after reloadAll", i, m.tabs[i].Name)
+		}
+	}
+}