feat(ui): add easter egg mag mode for order-of-magnitude display

Press `m` to toggle mag mode: all numbers are replaced with their
order of magnitude (floor of log10). Dollar signs and other units
are preserved, so ,234.23 becomes $🠡 3.

Applies to table cells and dashboard spending/budget figures.

closes #125

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

Author: cpcloud

docs/content/development/testing.md

@@ -39,6 +39,7 @@ Tests live alongside the code they test:
 | `internal/app/inline_input_test.go` | Inline text input editing |
 | `internal/app/calendar_test.go` | Date picker overlay |
 | `internal/app/column_finder_test.go` | Fuzzy column finder |
+| `internal/app/mag_test.go` | Mag mode (order-of-magnitude easter egg) |
 | `internal/app/notes_test.go` | Note preview overlay |
 | `internal/app/vendor_test.go` | Vendor tab operations |
 | `internal/app/rows_test.go` | Row building helpers |

internal/app/dashboard.go

@@ -639,8 +639,14 @@ func (m *Model) dashProjectRows() []dashRow {
 		budgetText := ""
 		budgetStyle := m.styles.Money
 		if p.BudgetCents != nil {
-			act := data.FormatCompactOptionalCents(p.ActualCents)
-			bud := data.FormatCompactCents(*p.BudgetCents)
+			fmtCents := data.FormatCompactCents
+			fmtOpt := data.FormatCompactOptionalCents
+			if m.magMode {
+				fmtCents = magCents
+				fmtOpt = magOptionalCents
+			}
+			act := fmtOpt(p.ActualCents)
+			bud := fmtCents(*p.BudgetCents)
 			if act != "" {
 				budgetText = act + " / " + bud
 				if p.ActualCents != nil && *p.ActualCents > *p.BudgetCents {
@@ -726,22 +732,26 @@ func (m *Model) dashSpendingLine() string {
 	if total == 0 {
 		return ""
 	}
+	fmtCents := data.FormatCompactCents
+	if m.magMode {
+		fmtCents = magCents
+	}
 	var parts []string
 	if d.ServiceSpendCents > 0 {
 		parts = append(parts,
 			m.styles.DashLabel.Render("Maintenance ")+
-				m.styles.Money.Render(data.FormatCompactCents(d.ServiceSpendCents)))
+				m.styles.Money.Render(fmtCents(d.ServiceSpendCents)))
 	}
 	if d.ProjectSpendCents > 0 {
 		parts = append(parts,
 			m.styles.DashLabel.Render("Projects ")+
-				m.styles.Money.Render(data.FormatCompactCents(d.ProjectSpendCents)))
+				m.styles.Money.Render(fmtCents(d.ProjectSpendCents)))
 	}
 	sep := m.styles.DashLabel.Render(" \u00b7 ")
 	line := strings.Join(parts, sep)
 	if d.ServiceSpendCents > 0 && d.ProjectSpendCents > 0 {
 		line += sep + m.styles.DashLabel.Render("Total ") +
-			m.styles.Money.Render(data.FormatCompactCents(total))
+			m.styles.Money.Render(fmtCents(total))
 	}
 	return line
 }

internal/app/mag.go

@@ -0,0 +1,89 @@
+// Copyright 2026 Phillip Cloud
+// Licensed under the Apache License, Version 2.0
+
+package app
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/cpcloud/micasa/internal/data"
+)
+
+const magArrow = "\U0001F821" // 🠡
+
+// magValue converts a numeric cell value to order-of-magnitude notation.
+// Non-numeric values are returned unchanged. Dollar prefixes are preserved.
+func magValue(c cell) string {
+	value := strings.TrimSpace(c.Value)
+	if value == "" || value == "\u2014" {
+		return value
+	}
+
+	// Only transform kinds that carry numeric data.
+	switch c.Kind {
+	case cellText, cellMoney, cellReadonly, cellDrilldown:
+		// Potentially numeric; continue to parsing below.
+	case cellDate, cellWarranty, cellUrgency, cellNotes, cellStatus:
+		return value
+	}
+
+	prefix := ""
+	numStr := value
+
+	// Handle negative money: "-$123.45"
+	if strings.HasPrefix(numStr, "-$") {
+		prefix = "-$"
+		numStr = numStr[2:]
+	} else if strings.HasPrefix(numStr, "$") {
+		prefix = "$"
+		numStr = numStr[1:]
+	}
+
+	numStr = strings.ReplaceAll(numStr, ",", "")
+
+	f, err := strconv.ParseFloat(numStr, 64)
+	if err != nil {
+		return value
+	}
+
+	if f == 0 {
+		return prefix + magArrow + " 0"
+	}
+
+	mag := int(math.Floor(math.Log10(math.Abs(f))))
+	return fmt.Sprintf("%s%s %d", prefix, magArrow, mag)
+}
+
+// magCents converts a cent amount to magnitude notation (e.g. 523423 → "$🠡 3").
+func magCents(cents int64) string {
+	return magValue(cell{Value: data.FormatCents(cents), Kind: cellMoney})
+}
+
+// magOptionalCents converts an optional cent amount to magnitude notation.
+func magOptionalCents(cents *int64) string {
+	if cents == nil {
+		return ""
+	}
+	return magCents(*cents)
+}
+
+// magTransformCells returns a copy of the cell grid with numeric values
+// replaced by their order-of-magnitude representation.
+func magTransformCells(rows [][]cell) [][]cell {
+	out := make([][]cell, len(rows))
+	for i, row := range rows {
+		transformed := make([]cell, len(row))
+		for j, c := range row {
+			transformed[j] = cell{
+				Value:  magValue(c),
+				Kind:   c.Kind,
+				LinkID: c.LinkID,
+			}
+		}
+		out[i] = transformed
+	}
+	return out
+}

internal/app/mag_test.go

@@ -0,0 +1,139 @@
+// Copyright 2026 Phillip Cloud
+// Licensed under the Apache License, Version 2.0
+
+package app
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMagValueMoney(t *testing.T) {
+	tests := []struct {
+		name  string
+		value string
+		want  string
+	}{
+		{"thousands", "$5,234.23", "$\U0001F821 3"},
+		{"hundreds", "$500.00", "$\U0001F821 2"},
+		{"millions", "$1,000,000.00", "$\U0001F821 6"},
+		{"tens", "$42.00", "$\U0001F821 1"},
+		{"single digit", "$7.50", "$\U0001F821 0"},
+		{"sub-dollar", "$0.50", "$\U0001F821 -1"},
+		{"zero", "$0.00", "$\U0001F821 0"},
+		{"negative", "-$5.00", "-$\U0001F821 0"},
+		{"negative large", "-$12,345.00", "-$\U0001F821 4"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := cell{Value: tt.value, Kind: cellMoney}
+			assert.Equal(t, tt.want, magValue(c))
+		})
+	}
+}
+
+func TestMagValuePlainNumbers(t *testing.T) {
+	tests := []struct {
+		name  string
+		value string
+		want  string
+	}{
+		{"integer", "42", "\U0001F821 1"},
+		{"zero", "0", "\U0001F821 0"},
+		{"large", "1000000", "\U0001F821 6"},
+		{"decimal", "3.14", "\U0001F821 0"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := cell{Value: tt.value, Kind: cellReadonly}
+			assert.Equal(t, tt.want, magValue(c))
+		})
+	}
+}
+
+func TestMagValueSkipsNonNumeric(t *testing.T) {
+	tests := []struct {
+		name  string
+		value string
+		kind  cellKind
+	}{
+		{"text", "Kitchen Remodel", cellText},
+		{"status", "underway", cellStatus},
+		{"date", "2026-02-12", cellDate},
+		{"warranty date", "2027-06-15", cellWarranty},
+		{"urgency date", "2026-03-01", cellUrgency},
+		{"notes", "Some long note", cellNotes},
+		{"empty", "", cellText},
+		{"dash", "\u2014", cellMoney},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			c := cell{Value: tt.value, Kind: tt.kind}
+			assert.Equal(t, tt.value, magValue(c), "non-numeric value should be unchanged")
+		})
+	}
+}
+
+func TestMagTransformCells(t *testing.T) {
+	rows := [][]cell{
+		{
+			{Value: "Kitchen Remodel", Kind: cellText},
+			{Value: "$5,234.23", Kind: cellMoney},
+			{Value: "3", Kind: cellDrilldown},
+		},
+		{
+			{Value: "Deck", Kind: cellText},
+			{Value: "$100.00", Kind: cellMoney},
+			{Value: "0", Kind: cellDrilldown},
+		},
+	}
+	out := magTransformCells(rows)
+
+	// Text cells unchanged.
+	assert.Equal(t, "Kitchen Remodel", out[0][0].Value)
+	assert.Equal(t, "Deck", out[1][0].Value)
+
+	// Money cells transformed.
+	assert.Equal(t, "$\U0001F821 3", out[0][1].Value)
+	assert.Equal(t, "$\U0001F821 2", out[1][1].Value)
+
+	// Drilldown counts transformed.
+	assert.Equal(t, "\U0001F821 0", out[0][2].Value)
+	assert.Equal(t, "\U0001F821 0", out[1][2].Value)
+
+	// Original rows are not modified.
+	assert.Equal(t, "$5,234.23", rows[0][1].Value)
+}
+
+func TestMagModeToggle(t *testing.T) {
+	m := newTestModel()
+	assert.False(t, m.magMode)
+	sendKey(m, "m")
+	assert.True(t, m.magMode)
+	sendKey(m, "m")
+	assert.False(t, m.magMode)
+}
+
+func TestMagModeWorksInEditMode(t *testing.T) {
+	m := newTestModel()
+	m.enterEditMode()
+	assert.False(t, m.magMode)
+	sendKey(m, "m")
+	assert.True(t, m.magMode)
+}
+
+func TestMagCents(t *testing.T) {
+	assert.Equal(t, "$\U0001F821 3", magCents(523423))
+	assert.Equal(t, "$\U0001F821 2", magCents(50000))
+	assert.Equal(t, "$\U0001F821 0", magCents(100))
+}
+
+func TestMagOptionalCentsNil(t *testing.T) {
+	assert.Equal(t, "", magOptionalCents(nil))
+}
+
+func TestMagOptionalCentsPresent(t *testing.T) {
+	cents := int64(100000)
+	assert.Equal(t, "$\U0001F821 3", magOptionalCents(&cents))
+}

internal/app/model.go

@@ -64,6 +64,7 @@ type Model struct {
 	inlineInput           *inlineInputState
 	undoStack             []undoEntry
 	redoStack             []undoEntry
+	magMode               bool // easter egg: display numbers as order-of-magnitude
 	status                statusMsg
 	projectTypes          []data.ProjectType
 	maintenanceCategories []data.MaintenanceCategory
@@ -289,6 +290,9 @@ func (m *Model) handleCommonKeys(key tea.KeyMsg) (tea.Cmd, bool) {
 		m.showHouse = !m.showHouse
 		m.resizeTables()
 		return nil, true
+	case "m":
+		m.magMode = !m.magMode
+		return nil, true
 	case "h", "left":
 		if tab := m.effectiveTab(); tab != nil {
 			tab.ColCursor = nextVisibleCol(tab.Specs, tab.ColCursor, false)

internal/app/view.go

@@ -903,6 +903,9 @@ func (m *Model) tableView(tab *Tab) string {
 		effectiveHeight = 2
 	}
 	displayCells := compactMoneyCells(vp.Cells)
+	if m.magMode {
+		displayCells = magTransformCells(displayCells)
+	}
 	rows := renderRows(
 		vp.Specs,
 		displayCells,