Merge github/master: reconcile with parallel widget work

Another session pushed 27 commits in parallel covering quick-add, event
detail popups, recurrence display, overdue badges, a manual refresh button,
and its own fix for the same overdue-tasks bug (via a separate
GetOverdueNativeTasks fetch folded into BuildTimeline, rather than widening
GetNativeTasksByDateRange's bound directly). Reconciled rather than blindly
taking one side:

- Reverted GetNativeTasksByDateRange to its original bounded query and kept
  upstream's GetOverdueNativeTasks + BuildTimeline fold-in as the sole
  overdue mechanism for native tasks, to avoid double-counting overdue
  items (my widened query + their separate fetch would have both returned
  them). Re-pointed the regression test at the now-correct contract and
  added a store-level test for GetOverdueNativeTasks directly.
- Kept my GetGoogleTasksByDateRange fix as-is (single unbounded query) --
  upstream never touched Google Tasks overdue handling, so there's no
  duplication risk there.
- Rewove WidgetRoot's LazyColumn structure (added for scrolling) around
  upstream's new header buttons, pinned all-day event rows, and the
  enhanced TomorrowSection, none of which were written LazyColumn-aware
  since that work landed on this side only.
- Combined both sides' additions to TaskDetailActivity/TaskDetailSheet
  (description-edit detail popup + due-date reschedule label) and
  WidgetRepository/Actions (optimistic local removal + refresh button
  wiring) -- these were independent, non-overlapping features that both
  needed to survive.
- Renumbered the migration collision: both sides independently added a
  migration numbered 022. Card-description was already applied to the live
  production DB under that filename earlier this session (migrations are
  tracked by filename), so it keeps 022; the recurring-event-id migration,
  never deployed under any name here, moves to 023.

Verified: go build clean, full test suite passes (only the two
pre-existing agent-handler failures and the pre-existing models package
build error remain, both confirmed unrelated via git stash before this
session began), and a dry run against a copy of the live production
database applies both migrations cleanly with no re-run conflicts.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EZ7ikw2ukGJFTHE3bJS7zL

3 files changed, 144 insertions, 12 deletions

diff --git a/internal/api/google_calendar.go b/internal/api/google_calendar.go
index 8bb3143..bb17812 100644
--- a/internal/api/google_calendar.go
+++ b/internal/api/google_calendar.go
@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"log"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -83,6 +84,86 @@ func deduplicateEvents(events []models.CalendarEvent) []models.CalendarEvent {
 	return unique
 }
 
+var recurrenceFreqNames = map[string]string{
+	"DAILY":   "daily",
+	"WEEKLY":  "weekly",
+	"MONTHLY": "monthly",
+	"YEARLY":  "yearly",
+}
+
+var recurrenceFreqUnits = map[string]string{
+	"DAILY":   "day",
+	"WEEKLY":  "week",
+	"MONTHLY": "month",
+	"YEARLY":  "year",
+}
+
+var recurrenceWeekdayNames = map[string]string{
+	"SU": "Sunday",
+	"MO": "Monday",
+	"TU": "Tuesday",
+	"WE": "Wednesday",
+	"TH": "Thursday",
+	"FR": "Friday",
+	"SA": "Saturday",
+}
+
+// formatRecurrence turns Google Calendar RRULE strings into short English.
+// This intentionally covers only the common cases (FREQ, INTERVAL, BYDAY) --
+// not a full RFC 5545 parser. Anything it can't confidently describe falls
+// back to "Recurring event" rather than showing nothing or an error.
+func formatRecurrence(rrules []string) string {
+	for _, rule := range rrules {
+		rule = strings.TrimPrefix(rule, "RRULE:")
+		parts := make(map[string]string)
+		for _, kv := range strings.Split(rule, ";") {
+			pieces := strings.SplitN(kv, "=", 2)
+			if len(pieces) == 2 {
+				parts[pieces[0]] = pieces[1]
+			}
+		}
+
+		freqKey := parts["FREQ"]
+		unit, ok := recurrenceFreqUnits[freqKey]
+		if !ok {
+			continue
+		}
+
+		interval := 1
+		if iv := parts["INTERVAL"]; iv != "" {
+			if n, err := strconv.Atoi(iv); err == nil && n > 0 {
+				interval = n
+			}
+		}
+
+		var phrase string
+		if interval == 1 {
+			phrase = "Repeats " + recurrenceFreqNames[freqKey]
+		} else {
+			phrase = fmt.Sprintf("Repeats every %d %ss", interval, unit)
+		}
+
+		if byday := parts["BYDAY"]; byday != "" {
+			var days []string
+			for _, code := range strings.Split(byday, ",") {
+				code = strings.TrimSpace(code)
+				if len(code) >= 2 {
+					code = code[len(code)-2:]
+				}
+				if name, ok := recurrenceWeekdayNames[code]; ok {
+					days = append(days, name)
+				}
+			}
+			if len(days) > 0 {
+				phrase += " on " + strings.Join(days, ", ")
+			}
+		}
+
+		return phrase
+	}
+	return "Recurring event"
+}
+
 // NewGoogleCalendarClient creates a client that fetches from multiple calendars.
 // calendarIDs can be comma-separated (e.g., "cal1@group.calendar.google.com,cal2@group.calendar.google.com")
 // timezone is the IANA timezone name for display (e.g., "Pacific/Honolulu")
@@ -130,12 +211,13 @@ func (c *GoogleCalendarClient) GetUpcomingEvents(ctx context.Context, maxResults
 		for _, item := range events.Items {
 			start, end := c.parseEventTime(item)
 			allEvents = append(allEvents, models.CalendarEvent{
-				ID:          item.Id,
-				Summary:     item.Summary,
-				Description: item.Description,
-				Start:       start,
-				End:         end,
-				HTMLLink:    item.HtmlLink,
+				ID:               item.Id,
+				Summary:          item.Summary,
+				Description:      item.Description,
+				Start:            start,
+				End:              end,
+				HTMLLink:         item.HtmlLink,
+				RecurringEventID: item.RecurringEventId,
 			})
 		}
 	}
@@ -163,12 +245,13 @@ func (c *GoogleCalendarClient) GetEventsByDateRange(ctx context.Context, start,
 		for _, item := range events.Items {
 			evtStart, evtEnd := c.parseEventTime(item)
 			allEvents = append(allEvents, models.CalendarEvent{
-				ID:          item.Id,
-				Summary:     item.Summary,
-				Description: item.Description,
-				Start:       evtStart,
-				End:         evtEnd,
-				HTMLLink:    item.HtmlLink,
+				ID:               item.Id,
+				Summary:          item.Summary,
+				Description:      item.Description,
+				Start:            evtStart,
+				End:              evtEnd,
+				HTMLLink:         item.HtmlLink,
+				RecurringEventID: item.RecurringEventId,
 			})
 		}
 	}
@@ -201,3 +284,21 @@ func (c *GoogleCalendarClient) GetCalendarList(ctx context.Context) ([]models.Ca
 	}
 	return calendars, nil
 }
+
+// GetRecurrenceRule looks up a recurring event's master record and returns
+// its formatted recurrence schedule. Google's API only puts the RRULE on
+// the master event, not on expanded instances (see parseEventTime's
+// SingleEvents(true) callers), so this does a live lookup by the instance's
+// RecurringEventId. There's no per-event calendar attribution stored today
+// (events from all configured calendars are merged without recording which
+// one they came from), so this tries each configured calendar in turn.
+func (c *GoogleCalendarClient) GetRecurrenceRule(ctx context.Context, recurringEventID string) (string, error) {
+	for _, calendarID := range c.calendarIDs {
+		event, err := c.srv.Events.Get(calendarID, recurringEventID).Do()
+		if err != nil {
+			continue
+		}
+		return formatRecurrence(event.Recurrence), nil
+	}
+	return "", fmt.Errorf("recurring event %s not found on any configured calendar", recurringEventID)
+}
diff --git a/internal/api/google_calendar_test.go b/internal/api/google_calendar_test.go
index 3cf0dbd..efbab0d 100644
--- a/internal/api/google_calendar_test.go
+++ b/internal/api/google_calendar_test.go
@@ -272,3 +272,33 @@ func TestGetUpcomingEvents_APIError_ReturnsEmptyNotError(t *testing.T) {
 		t.Errorf("expected 0 events on API error, got %d", len(events))
 	}
 }
+
+// --- formatRecurrence ---
+
+func TestFormatRecurrence(t *testing.T) {
+	tests := []struct {
+		name  string
+		rules []string
+		want  string
+	}{
+		{"weekly single day", []string{"RRULE:FREQ=WEEKLY;BYDAY=MO"}, "Repeats weekly on Monday"},
+		{"weekly multiple days", []string{"RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR"}, "Repeats weekly on Monday, Wednesday, Friday"},
+		{"daily", []string{"RRULE:FREQ=DAILY"}, "Repeats daily"},
+		{"monthly", []string{"RRULE:FREQ=MONTHLY"}, "Repeats monthly"},
+		{"yearly", []string{"RRULE:FREQ=YEARLY"}, "Repeats yearly"},
+		{"interval weekly", []string{"RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=SU"}, "Repeats every 2 weeks on Sunday"},
+		{"interval daily", []string{"RRULE:FREQ=DAILY;INTERVAL=3"}, "Repeats every 3 days"},
+		{"unrecognized frequency", []string{"RRULE:FREQ=HOURLY"}, "Recurring event"},
+		{"empty", []string{}, "Recurring event"},
+		{"unparseable", []string{"not a valid rule"}, "Recurring event"},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := formatRecurrence(tc.rules)
+			if got != tc.want {
+				t.Errorf("formatRecurrence(%v) = %q, want %q", tc.rules, got, tc.want)
+			}
+		})
+	}
+}
diff --git a/internal/api/interfaces.go b/internal/api/interfaces.go
index 183f3f0..3c1e4e1 100644
--- a/internal/api/interfaces.go
+++ b/internal/api/interfaces.go
@@ -30,6 +30,7 @@ type GoogleCalendarAPI interface {
 	GetEventsByDateRange(ctx context.Context, start, end time.Time) ([]models.CalendarEvent, error)
 	GetCalendarList(ctx context.Context) ([]models.CalendarInfo, error)
 	SetCalendarIDs(ids []string)
+	GetRecurrenceRule(ctx context.Context, recurringEventID string) (string, error)
 }
 
 // GoogleTasksAPI defines the interface for Google Tasks operations