ics feed

cmd/server/main.go

···
 	"net/http"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 
···
 	listHandler := handlers.NewListHandler(authHandler.Client())
 	settingsHandler := handlers.NewSettingsHandler(authHandler.Client())
 	pushHandler := handlers.NewPushHandler(notificationRepo)
+	calendarHandler := handlers.NewCalendarHandler(authHandler.Client())
+	icalHandler := handlers.NewICalHandler(authHandler.Client())
 
 	// Initialize Stripe client and supporter handler (only if Stripe keys are configured)
 	var supporterHandler *handlers.SupporterHandler
···
 
 	// Initialize push notification sender (only if VAPID keys are configured)
 	var pushSender *push.Sender
-	var jobRunner *jobs.Runner
+	var taskJobRunner *jobs.Runner
+	var calendarJobRunner *jobs.Runner
 	if cfg.VAPIDPublicKey != "" && cfg.VAPIDPrivateKey != "" {
 		pushSender = push.NewSender(cfg.VAPIDPublicKey, cfg.VAPIDPrivateKey, cfg.VAPIDSubscriber)
 		pushHandler.SetSender(pushSender)
 		log.Println("Push notification sender initialized")
 
-		// Initialize background job runner (check every 5 minutes)
-		jobRunner = jobs.NewRunner(5 * time.Minute)
-
-		// Create and register notification check job
+		// Initialize background job runner for task notifications (check every 5 minutes)
+		taskJobRunner = jobs.NewRunner(5 * time.Minute)
 		notificationJob := jobs.NewNotificationCheckJob(notificationRepo, authHandler.Client(), pushSender)
-		jobRunner.AddJob(notificationJob)
+		taskJobRunner.AddJob(notificationJob)
+		taskJobRunner.Start()
+		log.Println("Task notification job runner started (5 minute interval)")
 
-		// Start job runner
-		jobRunner.Start()
-		log.Println("Background job runner started")
+		// Initialize background job runner for calendar notifications (check every 30 minutes)
+		calendarJobRunner = jobs.NewRunner(30 * time.Minute)
+		calendarNotificationJob := jobs.NewCalendarNotificationJob(notificationRepo, authHandler.Client(), pushSender, settingsHandler)
+		calendarJobRunner.AddJob(calendarNotificationJob)
+		calendarJobRunner.Start()
+		log.Println("Calendar notification job runner started (30 minute interval)")
 	} else {
 		log.Println("VAPID keys not configured - push notifications disabled")
 		log.Println("Run 'go run ./cmd/vapid' to generate VAPID keys")
···
 	mux.HandleFunc("/list/", listHandler.HandlePublicListView)
 	logRoute("GET /list/*")
 
+	// Public iCal feed routes
+	mux.HandleFunc("/calendar/feed/", icalHandler.GenerateCalendarFeed)
+	logRoute("GET /calendar/feed/{did}/events.ics")
+	mux.HandleFunc("/tasks/feed/", icalHandler.GenerateTasksFeed)
+	logRoute("GET /tasks/feed/{did}/tasks.ics")
+
 	// Protected routes
 	mux.Handle("/app", authMiddleware.RequireAuth(http.HandlerFunc(handleDashboard)))
 	logRoute("GET /app [protected]")
···
 	logRoute("POST /app/push/test [protected]")
 	mux.Handle("/app/push/check", authMiddleware.RequireAuth(http.HandlerFunc(pushHandler.HandleCheckTasks)))
 	logRoute("POST /app/push/check [protected]")
+
+	// Calendar routes
+	mux.Handle("/app/calendar/events", authMiddleware.RequireAuth(http.HandlerFunc(calendarHandler.ListEvents)))
+	logRoute("GET /app/calendar/events [protected]")
+	mux.Handle("/app/calendar/upcoming", authMiddleware.RequireAuth(http.HandlerFunc(calendarHandler.ListUpcomingEvents)))
+	logRoute("GET /app/calendar/upcoming [protected]")
+	// Note: These must be after the specific routes above to avoid matching them
+	mux.Handle("/app/calendar/events/", authMiddleware.RequireAuth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Route to either GetEvent or GetEventRSVPs based on URL
+		if strings.HasSuffix(r.URL.Path, "/rsvps") {
+			calendarHandler.GetEventRSVPs(w, r)
+		} else {
+			calendarHandler.GetEvent(w, r)
+		}
+	})))
+	logRoute("GET /app/calendar/events/:rkey [protected]")
+	logRoute("GET /app/calendar/events/:rkey/rsvps [protected]")
 
 	// Supporter routes (only if Stripe is configured)
 	if supporterHandler != nil {
···
 	log.Println("Shutting down gracefully...")
 
 	// Stop background jobs
-	if jobRunner != nil {
-		jobRunner.Stop()
+	if taskJobRunner != nil {
+		taskJobRunner.Stop()
+	}
+	if calendarJobRunner != nil {
+		calendarJobRunner.Stop()
 	}
 
 	log.Println("Shutdown complete")

docs/features.md

···
 - [User Interface Preferences](#user-interface-preferences)
 - [Notifications](#notifications)
 - [Lists](#lists)
+- [Calendar Events](#calendar-events)
 - [Progressive Web App](#progressive-web-app)
 
 ---
···
 4. Share with anyone
 
 **Shared lists are public** - anyone with the link can view tasks in that list (but not edit them).
+
+---
+
+## Calendar Events
+
+AT Todo integrates with the AT Protocol calendar ecosystem, allowing you to view calendar events created by other calendar applications like [Smokesignal](https://smokesignal.events).
+
+### What are Calendar Events?
+
+Calendar events are social events stored in the AT Protocol using the `community.lexicon.calendar.event` lexicon. Unlike tasks (which are personal todo items), calendar events are typically:
+
+- **Public or shared**: Visible to others in the AT Protocol network
+- **Time-specific**: Have defined start/end times
+- **Social**: Support RSVPs and attendance tracking
+- **External**: Created by dedicated calendar apps like Smokesignal
+
+### Viewing Calendar Events
+
+**Access calendar events:**
+1. Navigate to the **📅 Events** tab in your dashboard
+2. Choose between two views:
+   - **Upcoming Events**: Shows events in the next 7 days
+   - **All Events**: Shows all calendar events
+
+**Event display includes:**
+- 📅 Event name and description
+- 🕐 Start and end times (in your local timezone)
+- 📍 Location information (for in-person events)
+- 💻 Attendance mode (Virtual, In Person, or Hybrid)
+- 🔗 Links to related resources
+- 💨 Direct link to view on Smokesignal
+
+### Event Details
+
+**View detailed information:**
+1. Click "View Details" on any event card
+2. A modal opens showing:
+   - Full event description
+   - Complete date/time information
+   - Event status (Planned, Scheduled, Rescheduled, Cancelled)
+   - Location details with addresses
+   - Attendance mode with visual indicators
+   - Related URLs and resources
+   - Your personal RSVP status (if you've RSVP'd)
+   - Link to view all RSVPs on Smokesignal
+
+**Visual indicators:**
+- 💻 **Virtual**: Online-only events
+- 📍 **In Person**: Physical location events
+- 🔄 **Hybrid**: Both online and in-person options
+
+### Event Sources
+
+AT Todo displays events from two sources:
+
+1. **Your own events**: Calendar events in your AT Protocol repository
+2. **RSVP'd events**: Events you've RSVP'd to via calendar apps
+
+All events are read-only in AT Todo. To create or manage events, use a dedicated calendar app like [Smokesignal](https://smokesignal.events).
+
+### Calendar Notifications
+
+Stay informed about upcoming events with automatic notifications.
+
+**Enabling calendar notifications:**
+1. Open Settings
+2. Scroll to "Calendar Notification Settings"
+3. Toggle "Enable calendar event notifications"
+4. Set your preferred lead time (default: 1 hour before event)
+5. Ensure push notifications are enabled
+
+**Notification timing:**
+- Choose how far in advance to be notified (e.g., "1h", "30m", "2h")
+- Notifications sent when events fall within your lead time window
+- Default: 1 hour before event start time
+- Respects quiet hours settings
+
+**What you'll receive:**
+```
+Upcoming Event: Community Meetup
+💻 Virtual event starts in 1 hour
+```
+
+**Smart notification features:**
+- ✅ Shows event mode (Virtual/In-Person/Hybrid)
+- ✅ Calculates time until event starts
+- ✅ Links to Smokesignal for full details
+- ✅ Sent to all registered devices
+- ✅ Won't spam (24-hour cooldown per event)
+
+**Notification frequency:**
+Calendar events are checked every 30 minutes for upcoming events (separate from task notifications which run every 5 minutes).
+
+### RSVPs and Attendance
+
+**Viewing your RSVP:**
+- Open event details to see your RSVP status
+- Status indicators:
+  - ✓ **Going** (green)
+  - ⓘ **Interested** (blue)
+  - ✗ **Not Going** (red)
+
+**Managing RSVPs:**
+RSVPs are managed through calendar applications like Smokesignal. AT Todo displays your RSVP status but doesn't provide RSVP functionality.
+
+**To RSVP to an event:**
+1. Click the 💨 Smokesignal link in the event details
+2. RSVP on Smokesignal
+3. Your RSVP status will appear in AT Todo automatically
+
+### Event Status Badges
+
+Events display status badges to indicate their current state:
+
+- **Scheduled** (green): Confirmed and finalized
+- **Planned** (blue): Created but not yet finalized
+- **Rescheduled** (orange): Date/time has been changed
+- **Cancelled** (red): Event has been cancelled
+- **Postponed** (red): Event delayed with no new date
+
+Cancelled and postponed events still appear in your calendar but are clearly marked.
+
+### Integration with Smokesignal
+
+AT Todo integrates seamlessly with [Smokesignal](https://smokesignal.events), the premier AT Protocol calendar application.
+
+**Smokesignal features:**
+- Create and manage calendar events
+- RSVP to events
+- View all RSVPs and attendees
+- Share event links
+- Event discovery and search
+
+**Quick access:**
+- Click the 💨 emoji next to any event name
+- Opens the event directly on Smokesignal
+- View full attendee list
+- Manage your RSVP
+- Share event with others
+
+### Google Calendar & iCal Subscription
+
+Subscribe to your AT Protocol calendar events **and tasks** in Google Calendar, Apple Calendar, Outlook, or any calendar app that supports iCal feeds.
+
+**Getting your iCal feed URLs:**
+
+AT Todo provides two separate feeds:
+
+**Calendar Events Feed:**
+```
+https://attodo.app/calendar/feed/{your-did}/events.ics
+```
+
+**Tasks Feed (tasks with due dates):**
+```
+https://attodo.app/tasks/feed/{your-did}/tasks.ics
+```
+
+To find your DID:
+1. Open AT Todo and navigate to the 📅 Events tab
+2. Open your browser's developer console (F12)
+3. Your DID appears in the console when loading events, or
+4. Check your AT Protocol profile on Bluesky
+
+**Subscribing in Google Calendar:**
+
+You can subscribe to both feeds separately:
+
+**For Events:**
+1. Open [Google Calendar](https://calendar.google.com)
+2. Click the **+** next to "Other calendars"
+3. Select **"From URL"**
+4. Paste your events feed URL: `https://attodo.app/calendar/feed/{your-did}/events.ics`
+5. Click **"Add calendar"**
+
+**For Tasks:**
+1. Click the **+** next to "Other calendars" again
+2. Select **"From URL"**
+3. Paste your tasks feed URL: `https://attodo.app/tasks/feed/{your-did}/tasks.ics`
+4. Click **"Add calendar"**
+
+Your AT Protocol events and tasks will now appear in Google Calendar and sync automatically!
+
+**Subscribing in Apple Calendar:**
+
+Subscribe to both feeds for complete coverage:
+
+1. Open Calendar app
+2. Go to **File** → **New Calendar Subscription**
+3. Paste your events feed URL, click **Subscribe**
+4. Choose auto-refresh frequency (recommended: every hour)
+5. Repeat for tasks feed URL
+
+**Subscribing in Outlook:**
+
+Subscribe to both feeds separately:
+
+1. Open Outlook
+2. Go to **File** → **Account Settings** → **Internet Calendars**
+3. Click **New**
+4. Paste your events feed URL, click **Add**
+5. Repeat for tasks feed URL
+
+**What syncs from Events Feed:**
+- ✅ Event names and descriptions
+- ✅ Start and end times (in your timezone)
+- ✅ Location information
+- ✅ Event status (confirmed, tentative, cancelled)
+- ✅ Links to Smokesignal
+- ✅ Event mode (virtual/in-person/hybrid) as categories
+
+**What syncs from Tasks Feed:**
+- ✅ Task titles and descriptions
+- ✅ Due dates (in your timezone)
+- ✅ Completion status
+- ✅ Tags as categories
+- ✅ Only tasks with due dates (no due date = not included)
+
+**Auto-refresh:**
+- Calendar apps check for updates periodically
+- Google Calendar: Every few hours
+- Apple Calendar: Configurable (hourly recommended)
+- Outlook: Configurable
+
+**Privacy note:**
+Calendar events and tasks in AT Protocol are public by design. Anyone with your iCal feed URLs can view your events and tasks. This is the same as viewing them on Smokesignal or other AT Protocol apps.
+
+**Tips:**
+- Subscribe to both feeds to see your complete schedule in one place
+- Tasks appear as "todos" in most calendar apps
+- Completed tasks remain in the feed with completion status
+- Use separate calendar colors to distinguish events from tasks
+
+### Event Timezone Handling
+
+All event times are automatically converted to your local timezone:
+- **Displayed**: In your browser's timezone
+- **Stored**: In UTC in AT Protocol
+- **Notifications**: Respect your local time
+- **Created date**: Shows when the event was created (in local time)
+
+### Read-Only Access
+
+**Important notes:**
+- 📖 Calendar events in AT Todo are **read-only**
+- ✏️ To create or edit events, use a calendar app like Smokesignal
+- 🔄 AT Todo automatically syncs events from your AT Protocol repository
+- 📅 Perfect for viewing your event schedule alongside your tasks
+
+### Calendar Best Practices
+
+**Organizing your calendar:**
+1. **Use Smokesignal** for event creation and management
+2. **View in AT Todo** to see events alongside tasks
+3. **Enable notifications** to stay informed
+4. **RSVP on Smokesignal** to indicate attendance
+5. **Share event links** from Smokesignal with others
+
+**Integrating with tasks:**
+- Create tasks for event preparation (e.g., "Prepare presentation for Monday meetup")
+- Use tags to link tasks to events (e.g., #meetup, #conference)
+- Set task due dates relative to event times
+- Enable both task and calendar notifications
 
 ---
 

internal/handlers/calendar.go

···
+package handlers
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/shindakun/attodo/internal/models"
+	"github.com/shindakun/attodo/internal/session"
+	"github.com/shindakun/bskyoauth"
+)
+
+const (
+	CalendarEventCollection = "community.lexicon.calendar.event"
+	CalendarRSVPCollection  = "community.lexicon.calendar.rsvp"
+)
+
+type CalendarHandler struct {
+	client *bskyoauth.Client
+}
+
+func NewCalendarHandler(client *bskyoauth.Client) *CalendarHandler {
+	return &CalendarHandler{client: client}
+}
+
+// withRetry executes an operation with automatic token refresh on DPoP errors
+func (h *CalendarHandler) withRetry(ctx context.Context, sess *bskyoauth.Session, operation func(*bskyoauth.Session) error) (*bskyoauth.Session, error) {
+	var err error
+
+	for attempt := 0; attempt < 2; attempt++ {
+		err = operation(sess)
+		if err == nil {
+			return sess, nil
+		}
+
+		// Check if it's a DPoP replay error or 401
+		if strings.Contains(err.Error(), "invalid_dpop_proof") || strings.Contains(err.Error(), "401") {
+			// Refresh the token
+			sess, err = h.client.RefreshToken(ctx, sess)
+			if err != nil {
+				return sess, err
+			}
+			continue
+		}
+
+		// Other errors, don't retry
+		break
+	}
+
+	return sess, err
+}
+
+// ListEvents fetches all calendar events (both owned and RSVP'd)
+func (h *CalendarHandler) ListEvents(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	sess, ok := session.GetSession(r)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var events []*models.CalendarEvent
+	var err error
+
+	sess, err = h.withRetry(ctx, sess, func(s *bskyoauth.Session) error {
+		// Fetch events from user's own repository
+		ownEvents, err := h.ListEventRecords(ctx, s)
+		if err != nil {
+			fmt.Printf("WARNING: Failed to fetch own events: %v\n", err)
+		} else {
+			events = append(events, ownEvents...)
+		}
+
+		// Fetch events user has RSVP'd to
+		rsvpEvents, err := h.ListEventsFromRSVPs(ctx, s)
+		if err != nil {
+			fmt.Printf("WARNING: Failed to fetch RSVP'd events: %v\n", err)
+		} else {
+			events = append(events, rsvpEvents...)
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		http.Error(w, getUserFriendlyError(err, "Failed to fetch calendar events"), http.StatusInternalServerError)
+		return
+	}
+
+	// Sort events by StartsAt in reverse chronological order (newest first)
+	sortEventsByDate(events)
+
+	// Check if client wants HTML or JSON based on Accept header
+	acceptHeader := r.Header.Get("Accept")
+	if strings.Contains(acceptHeader, "text/html") || r.Header.Get("HX-Request") == "true" {
+		// Return HTML for HTMX
+		if len(events) == 0 {
+			w.Header().Set("Content-Type", "text/html")
+			w.Write([]byte("<p style=\"color: var(--pico-muted-color); text-align: center; padding: 2rem;\">No calendar events found. Events created in other AT Protocol calendar apps will appear here.</p>"))
+			return
+		}
+
+		w.Header().Set("Content-Type", "text/html")
+		for _, event := range events {
+			Render(w, "calendar-event-card.html", event)
+		}
+		return
+	}
+
+	// Return JSON for API calls
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(events)
+}
+
+// GetEvent fetches a single calendar event by rkey
+func (h *CalendarHandler) GetEvent(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	sess, ok := session.GetSession(r)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Extract rkey from URL path
+	rkey := strings.TrimPrefix(r.URL.Path, "/app/calendar/events/")
+	if idx := strings.Index(rkey, "/"); idx != -1 {
+		rkey = rkey[:idx]
+	}
+
+	if rkey == "" {
+		http.Error(w, "Missing event ID", http.StatusBadRequest)
+		return
+	}
+
+	var event *models.CalendarEvent
+	var err error
+
+	// Try to fetch from user's own repository first
+	sess, err = h.withRetry(ctx, sess, func(s *bskyoauth.Session) error {
+		event, err = h.getEventRecord(ctx, s, rkey)
+		return err
+	})
+
+	// If not found in user's repository, search through all events (including RSVP'd)
+	if err != nil && (strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "400") || strings.Contains(err.Error(), "RecordNotFound")) {
+		fmt.Printf("DEBUG: Event %s not found in user's own repository, searching RSVP'd events...\n", rkey)
+		sess, err = h.withRetry(ctx, sess, func(s *bskyoauth.Session) error {
+			// Get all events (own + RSVP'd)
+			var allEvents []*models.CalendarEvent
+
+			ownEvents, err := h.ListEventRecords(ctx, s)
+			if err == nil {
+				allEvents = append(allEvents, ownEvents...)
+			}
+
+			rsvpEvents, err := h.ListEventsFromRSVPs(ctx, s)
+			if err == nil {
+				allEvents = append(allEvents, rsvpEvents...)
+			}
+
+			fmt.Printf("DEBUG: Searching through %d total events for rkey %s\n", len(allEvents), rkey)
+
+			// Find event with matching rkey
+			for _, e := range allEvents {
+				if e.RKey == rkey {
+					fmt.Printf("DEBUG: Found event %s in all events list\n", rkey)
+					event = e
+					return nil
+				}
+			}
+
+			return fmt.Errorf("event not found: %s", rkey)
+		})
+	}
+
+	if err != nil {
+		fmt.Printf("ERROR: Failed to fetch event %s: %v\n", rkey, err)
+		if strings.Contains(err.Error(), "not found") || strings.Contains(err.Error(), "404") || strings.Contains(err.Error(), "RecordNotFound") {
+			http.Error(w, "Event not found", http.StatusNotFound)
+			return
+		}
+		http.Error(w, getUserFriendlyError(err, "Failed to fetch event"), http.StatusInternalServerError)
+		return
+	}
+
+	fmt.Printf("DEBUG: Successfully fetched event %s\n", rkey)
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(event)
+}
+
+// GetEventRSVPs fetches RSVPs for a specific event
+func (h *CalendarHandler) GetEventRSVPs(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	sess, ok := session.GetSession(r)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Extract rkey from URL path
+	path := strings.TrimPrefix(r.URL.Path, "/app/calendar/events/")
+	parts := strings.Split(path, "/")
+	if len(parts) < 2 {
+		http.Error(w, "Invalid URL", http.StatusBadRequest)
+		return
+	}
+	rkey := parts[0]
+
+	// Construct the event URI
+	eventURI := fmt.Sprintf("at://%s/%s/%s", sess.DID, CalendarEventCollection, rkey)
+
+	var rsvps []*models.CalendarRSVP
+	var err error
+
+	sess, err = h.withRetry(ctx, sess, func(s *bskyoauth.Session) error {
+		allRSVPs, err := h.listRSVPRecords(ctx, s)
+		if err != nil {
+			return err
+		}
+
+		// Filter for this event
+		for _, rsvp := range allRSVPs {
+			if rsvp.Subject.URI == eventURI {
+				rsvps = append(rsvps, rsvp)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		http.Error(w, getUserFriendlyError(err, "Failed to fetch RSVPs"), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(rsvps)
+}
+
+// ListUpcomingEvents fetches events starting within a specified time window
+func (h *CalendarHandler) ListUpcomingEvents(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	sess, ok := session.GetSession(r)
+	if !ok {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	// Parse duration from query params (default: 7 days)
+	durationStr := r.URL.Query().Get("within")
+	duration := 7 * 24 * time.Hour // default 7 days
+	if durationStr != "" {
+		if parsed, err := time.ParseDuration(durationStr); err == nil {
+			duration = parsed
+		}
+	}
+
+	var events []*models.CalendarEvent
+	var err error
+
+	sess, err = h.withRetry(ctx, sess, func(s *bskyoauth.Session) error {
+		allEvents, err := h.ListEventRecords(ctx, s)
+		if err != nil {
+			return err
+		}
+
+		// Filter for upcoming events
+		for _, event := range allEvents {
+			if event.IsUpcoming() && event.StartsWithin(duration) && !event.IsCancelled() {
+				events = append(events, event)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		http.Error(w, getUserFriendlyError(err, "Failed to fetch upcoming events"), http.StatusInternalServerError)
+		return
+	}
+
+	// Check if client wants HTML or JSON based on Accept header
+	acceptHeader := r.Header.Get("Accept")
+	if strings.Contains(acceptHeader, "text/html") || r.Header.Get("HX-Request") == "true" {
+		// Return HTML for HTMX
+		if len(events) == 0 {
+			w.Header().Set("Content-Type", "text/html")
+			w.Write([]byte("<p style=\"color: var(--pico-muted-color); text-align: center; padding: 2rem;\">No upcoming events in the next 7 days.</p>"))
+			return
+		}
+
+		w.Header().Set("Content-Type", "text/html")
+		for _, event := range events {
+			Render(w, "calendar-event-card.html", event)
+		}
+		return
+	}
+
+	// Return JSON for API calls
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(events)
+}
+
+// listEventRecords fetches all calendar events using direct XRPC call
+func (h *CalendarHandler) ListEventRecords(ctx context.Context, sess *bskyoauth.Session) ([]*models.CalendarEvent, error) {
+	// Build the XRPC URL
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s",
+		sess.PDS, sess.DID, CalendarEventCollection)
+
+	// Create request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add authorization header
+	req.Header.Set("Authorization", "Bearer "+sess.AccessToken)
+
+	// Make request
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("XRPC ERROR %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Parse response
+	var result struct {
+		Records []struct {
+			Uri   string                 `json:"uri"`
+			Cid   string                 `json:"cid"`
+			Value map[string]interface{} `json:"value"`
+		} `json:"records"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	fmt.Printf("DEBUG: Received %d calendar event records from AT Protocol\n", len(result.Records))
+
+	// Convert to CalendarEvent models
+	events := make([]*models.CalendarEvent, 0, len(result.Records))
+	for _, record := range result.Records {
+		event, err := models.ParseCalendarEvent(record.Value, record.Uri, record.Cid)
+		if err != nil {
+			// Log error but continue with other events
+			fmt.Printf("WARNING: Failed to parse calendar event %s: %v\n", record.Uri, err)
+			continue
+		}
+		events = append(events, event)
+	}
+
+	fmt.Printf("DEBUG: Fetched %d calendar events from repository\n", len(events))
+
+	return events, nil
+}
+
+// getEventRecord fetches a single event using direct XRPC call
+func (h *CalendarHandler) getEventRecord(ctx context.Context, sess *bskyoauth.Session, rkey string) (*models.CalendarEvent, error) {
+	// Build the XRPC URL
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",
+		sess.PDS, sess.DID, CalendarEventCollection, rkey)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add authorization header
+	req.Header.Set("Authorization", "Bearer "+sess.AccessToken)
+
+	// Make request
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("XRPC ERROR %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Parse response
+	var result struct {
+		Uri   string                 `json:"uri"`
+		Cid   string                 `json:"cid"`
+		Value map[string]interface{} `json:"value"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to CalendarEvent model
+	event, err := models.ParseCalendarEvent(result.Value, result.Uri, result.Cid)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse event: %w", err)
+	}
+
+	return event, nil
+}
+
+// listEventsFromRSVPs fetches events that the user has RSVP'd to
+func (h *CalendarHandler) ListEventsFromRSVPs(ctx context.Context, sess *bskyoauth.Session) ([]*models.CalendarEvent, error) {
+	// First, fetch all RSVPs
+	rsvps, err := h.listRSVPRecords(ctx, sess)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch RSVPs: %w", err)
+	}
+
+	fmt.Printf("DEBUG: Found %d RSVPs\n", len(rsvps))
+
+	// Extract unique event URIs from RSVPs
+	eventURIs := make(map[string]bool)
+	for _, rsvp := range rsvps {
+		if rsvp.Subject != nil && rsvp.Subject.URI != "" {
+			eventURIs[rsvp.Subject.URI] = true
+		}
+	}
+
+	fmt.Printf("DEBUG: Found %d unique event URIs from RSVPs\n", len(eventURIs))
+
+	// Fetch each event by URI
+	events := make([]*models.CalendarEvent, 0, len(eventURIs))
+	for eventURI := range eventURIs {
+		event, err := h.getEventByURI(ctx, sess, eventURI)
+		if err != nil {
+			fmt.Printf("WARNING: Failed to fetch event %s: %v\n", eventURI, err)
+			continue
+		}
+		events = append(events, event)
+	}
+
+	fmt.Printf("DEBUG: Successfully fetched %d events from RSVPs\n", len(events))
+
+	return events, nil
+}
+
+// getEventByURI fetches an event by its AT URI
+func (h *CalendarHandler) getEventByURI(ctx context.Context, sess *bskyoauth.Session, uri string) (*models.CalendarEvent, error) {
+	// Parse URI: at://did:plc:xxx/community.lexicon.calendar.event/rkey
+	// Extract DID, collection, and rkey
+	if len(uri) < 5 || uri[:5] != "at://" {
+		return nil, fmt.Errorf("invalid AT URI: %s", uri)
+	}
+
+	parts := strings.Split(uri[5:], "/")
+	if len(parts) != 3 {
+		return nil, fmt.Errorf("invalid AT URI format: %s", uri)
+	}
+
+	did := parts[0]
+	collection := parts[1]
+	rkey := parts[2]
+
+	// Build XRPC URL - use the repo from the URI, not the session DID
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",
+		sess.PDS, did, collection, rkey)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add authorization header
+	req.Header.Set("Authorization", "Bearer "+sess.AccessToken)
+
+	// Make request
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("XRPC ERROR %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Parse response
+	var result struct {
+		Uri   string                 `json:"uri"`
+		Cid   string                 `json:"cid"`
+		Value map[string]interface{} `json:"value"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to CalendarEvent model
+	event, err := models.ParseCalendarEvent(result.Value, result.Uri, result.Cid)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse event: %w", err)
+	}
+
+	return event, nil
+}
+
+// listRSVPRecords fetches all RSVP records using direct XRPC call
+func (h *CalendarHandler) listRSVPRecords(ctx context.Context, sess *bskyoauth.Session) ([]*models.CalendarRSVP, error) {
+	// Build the XRPC URL
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s",
+		sess.PDS, sess.DID, CalendarRSVPCollection)
+
+	// Create request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add authorization header
+	req.Header.Set("Authorization", "Bearer "+sess.AccessToken)
+
+	// Make request
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("XRPC ERROR %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Parse response
+	var result struct {
+		Records []struct {
+			Uri   string                 `json:"uri"`
+			Cid   string                 `json:"cid"`
+			Value map[string]interface{} `json:"value"`
+		} `json:"records"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to CalendarRSVP models
+	rsvps := make([]*models.CalendarRSVP, 0, len(result.Records))
+	for _, record := range result.Records {
+		rsvp, err := models.ParseCalendarRSVP(record.Value, record.Uri, record.Cid)
+		if err != nil {
+			// Log error but continue with other RSVPs
+			continue
+		}
+		rsvps = append(rsvps, rsvp)
+	}
+
+	return rsvps, nil
+}
+
+// sortEventsByDate sorts events by StartsAt in reverse chronological order (newest first)
+// Events without StartsAt are placed at the end, sorted by CreatedAt
+func sortEventsByDate(events []*models.CalendarEvent) {
+	sort.Slice(events, func(i, j int) bool {
+		eventI := events[i]
+		eventJ := events[j]
+
+		// If both have StartsAt, sort by StartsAt (newest first)
+		if eventI.StartsAt != nil && eventJ.StartsAt != nil {
+			return eventI.StartsAt.After(*eventJ.StartsAt)
+		}
+
+		// Events with StartsAt come before events without
+		if eventI.StartsAt != nil {
+			return true
+		}
+		if eventJ.StartsAt != nil {
+			return false
+		}
+
+		// Both don't have StartsAt, sort by CreatedAt (newest first)
+		return eventI.CreatedAt.After(eventJ.CreatedAt)
+	})
+}

internal/handlers/ical.go

···
+package handlers
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/shindakun/attodo/internal/models"
+	"github.com/shindakun/bskyoauth"
+)
+
+// ICalHandler handles iCal feed generation
+type ICalHandler struct {
+	client *bskyoauth.Client
+}
+
+// NewICalHandler creates a new iCal handler
+func NewICalHandler(client *bskyoauth.Client) *ICalHandler {
+	return &ICalHandler{
+		client: client,
+	}
+}
+
+// GenerateCalendarFeed generates an iCal feed for a user's calendar events
+func (h *ICalHandler) GenerateCalendarFeed(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	// Extract DID from path: /calendar/feed/{did}/events.ics
+	pathParts := strings.Split(r.URL.Path, "/")
+	if len(pathParts) < 5 {
+		http.Error(w, "Invalid feed URL", http.StatusBadRequest)
+		return
+	}
+
+	did := pathParts[3]
+	if did == "" {
+		http.Error(w, "Missing DID", http.StatusBadRequest)
+		return
+	}
+
+	// Fetch events from AT Protocol (public read, no auth needed)
+	events, err := h.fetchEventsForDID(ctx, did)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Failed to fetch events: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	// Generate iCal feed
+	ical := h.generateCalendarICalendar(did, events)
+
+	// Set headers for iCal feed
+	w.Header().Set("Content-Type", "text/calendar; charset=utf-8")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=\"%s-events.ics\"", sanitizeDID(did)))
+	w.Header().Set("Cache-Control", "no-cache, must-revalidate")
+
+	// Write iCal content
+	w.Write([]byte(ical))
+}
+
+// GenerateTasksFeed generates an iCal feed for a user's tasks with due dates
+func (h *ICalHandler) GenerateTasksFeed(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	// Extract DID from path: /tasks/feed/{did}/tasks.ics
+	pathParts := strings.Split(r.URL.Path, "/")
+	if len(pathParts) < 5 {
+		http.Error(w, "Invalid feed URL", http.StatusBadRequest)
+		return
+	}
+
+	did := pathParts[3]
+	if did == "" {
+		http.Error(w, "Missing DID", http.StatusBadRequest)
+		return
+	}
+
+	// Fetch tasks from AT Protocol (public read, no auth needed)
+	tasks, err := h.fetchTasksForDID(ctx, did)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("Failed to fetch tasks: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	// Generate iCal feed
+	ical := h.generateTasksICalendar(did, tasks)
+
+	// Set headers for iCal feed
+	w.Header().Set("Content-Type", "text/calendar; charset=utf-8")
+	w.Header().Set("Content-Disposition", fmt.Sprintf("inline; filename=\"%s-tasks.ics\"", sanitizeDID(did)))
+	w.Header().Set("Cache-Control", "no-cache, must-revalidate")
+
+	// Write iCal content
+	w.Write([]byte(ical))
+}
+
+// fetchEventsForDID fetches calendar events for a given DID using public read
+func (h *ICalHandler) fetchEventsForDID(ctx context.Context, did string) ([]*models.CalendarEvent, error) {
+	// Resolve PDS endpoint for this DID
+	pds, err := h.resolvePDSEndpoint(ctx, did)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve PDS endpoint: %w", err)
+	}
+
+	// Build the XRPC URL for public read
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s",
+		pds, did, CalendarEventCollection)
+
+	// Create and execute request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("XRPC error %d", resp.StatusCode)
+	}
+
+	// Parse response (reuse the same struct from calendar.go)
+	var result struct {
+		Records []struct {
+			Uri   string                 `json:"uri"`
+			Cid   string                 `json:"cid"`
+			Value map[string]interface{} `json:"value"`
+		} `json:"records"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to CalendarEvent models
+	events := make([]*models.CalendarEvent, 0, len(result.Records))
+	for _, record := range result.Records {
+		event, err := models.ParseCalendarEvent(record.Value, record.Uri, record.Cid)
+		if err != nil {
+			// Skip invalid events but don't fail the whole feed
+			continue
+		}
+		events = append(events, event)
+	}
+
+	return events, nil
+}
+
+// resolvePDSEndpoint resolves the PDS endpoint for a given DID
+func (h *ICalHandler) resolvePDSEndpoint(ctx context.Context, did string) (string, error) {
+	dir := identity.DefaultDirectory()
+	atid, err := syntax.ParseAtIdentifier(did)
+	if err != nil {
+		return "", err
+	}
+
+	ident, err := dir.Lookup(ctx, *atid)
+	if err != nil {
+		return "", err
+	}
+
+	return ident.PDSEndpoint(), nil
+}
+
+// generateCalendarICalendar generates an iCal format string from calendar events
+func (h *ICalHandler) generateCalendarICalendar(did string, events []*models.CalendarEvent) string {
+	var ical strings.Builder
+
+	// iCal header
+	ical.WriteString("BEGIN:VCALENDAR\r\n")
+	ical.WriteString("VERSION:2.0\r\n")
+	ical.WriteString("PRODID:-//AT Todo//Calendar Feed//EN\r\n")
+	ical.WriteString(fmt.Sprintf("X-WR-CALNAME:AT Protocol Events - %s\r\n", sanitizeDID(did)))
+	ical.WriteString("X-WR-TIMEZONE:UTC\r\n")
+	ical.WriteString("CALSCALE:GREGORIAN\r\n")
+	ical.WriteString("METHOD:PUBLISH\r\n")
+
+	// Add each event
+	for _, event := range events {
+		h.addEventToICalendar(&ical, event)
+	}
+
+	// iCal footer
+	ical.WriteString("END:VCALENDAR\r\n")
+
+	return ical.String()
+}
+
+// addEventToICalendar adds a single event to the iCalendar
+func (h *ICalHandler) addEventToICalendar(ical *strings.Builder, event *models.CalendarEvent) {
+	ical.WriteString("BEGIN:VEVENT\r\n")
+
+	// UID - unique identifier (use AT Protocol URI)
+	ical.WriteString(fmt.Sprintf("UID:%s\r\n", event.URI))
+
+	// DTSTAMP - when the event was created
+	ical.WriteString(fmt.Sprintf("DTSTAMP:%s\r\n", formatICalTime(event.CreatedAt)))
+
+	// DTSTART - event start time
+	if event.StartsAt != nil {
+		ical.WriteString(fmt.Sprintf("DTSTART:%s\r\n", formatICalTime(*event.StartsAt)))
+	}
+
+	// DTEND - event end time
+	if event.EndsAt != nil {
+		ical.WriteString(fmt.Sprintf("DTEND:%s\r\n", formatICalTime(*event.EndsAt)))
+	}
+
+	// SUMMARY - event title
+	ical.WriteString(fmt.Sprintf("SUMMARY:%s\r\n", escapeICalText(event.Name)))
+
+	// DESCRIPTION - event description
+	if event.Description != "" {
+		ical.WriteString(fmt.Sprintf("DESCRIPTION:%s\r\n", escapeICalText(event.Description)))
+	}
+
+	// LOCATION - event location
+	if len(event.Locations) > 0 {
+		location := event.Locations[0]
+		if location.Name != "" {
+			ical.WriteString(fmt.Sprintf("LOCATION:%s\r\n", escapeICalText(location.Name)))
+		} else if location.Address != "" {
+			ical.WriteString(fmt.Sprintf("LOCATION:%s\r\n", escapeICalText(location.Address)))
+		}
+	}
+
+	// URL - link to Smokesignal
+	if smokesignalURL := event.SmokesignalURL(); smokesignalURL != "" {
+		ical.WriteString(fmt.Sprintf("URL:%s\r\n", smokesignalURL))
+	}
+
+	// STATUS - event status
+	status := "CONFIRMED"
+	switch event.Status {
+	case models.EventStatusCancelled:
+		status = "CANCELLED"
+	case models.EventStatusPlanned:
+		status = "TENTATIVE"
+	}
+	ical.WriteString(fmt.Sprintf("STATUS:%s\r\n", status))
+
+	// CATEGORIES - attendance mode
+	if event.Mode != "" {
+		ical.WriteString(fmt.Sprintf("CATEGORIES:%s\r\n", strings.ToUpper(event.Mode)))
+	}
+
+	ical.WriteString("END:VEVENT\r\n")
+}
+
+// fetchTasksForDID fetches tasks for a given DID using public read
+func (h *ICalHandler) fetchTasksForDID(ctx context.Context, did string) ([]*models.Task, error) {
+	// Resolve PDS endpoint for this DID
+	pds, err := h.resolvePDSEndpoint(ctx, did)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve PDS endpoint: %w", err)
+	}
+
+	// Build the XRPC URL for public read
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s",
+		pds, did, TaskCollection)
+
+	// Create and execute request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("XRPC error %d", resp.StatusCode)
+	}
+
+	// Parse response
+	var result struct {
+		Records []struct {
+			Uri   string                 `json:"uri"`
+			Cid   string                 `json:"cid"`
+			Value map[string]interface{} `json:"value"`
+		} `json:"records"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to Task models and filter for tasks with due dates
+	tasks := make([]*models.Task, 0)
+	for _, record := range result.Records {
+		task := parseTaskFieldsForICal(record.Value)
+		task.URI = record.Uri
+		task.RKey = extractRKeyForICal(record.Uri)
+
+		// Only include tasks with due dates
+		if task.DueDate != nil {
+			tasks = append(tasks, &task)
+		}
+	}
+
+	return tasks, nil
+}
+
+// generateTasksICalendar generates an iCal format string from tasks
+func (h *ICalHandler) generateTasksICalendar(did string, tasks []*models.Task) string {
+	var ical strings.Builder
+
+	// iCal header
+	ical.WriteString("BEGIN:VCALENDAR\r\n")
+	ical.WriteString("VERSION:2.0\r\n")
+	ical.WriteString("PRODID:-//AT Todo//Tasks Feed//EN\r\n")
+	ical.WriteString(fmt.Sprintf("X-WR-CALNAME:AT Protocol Tasks - %s\r\n", sanitizeDID(did)))
+	ical.WriteString("X-WR-TIMEZONE:UTC\r\n")
+	ical.WriteString("CALSCALE:GREGORIAN\r\n")
+	ical.WriteString("METHOD:PUBLISH\r\n")
+
+	// Add each task
+	for _, task := range tasks {
+		h.addTaskToICalendar(&ical, task)
+	}
+
+	// iCal footer
+	ical.WriteString("END:VCALENDAR\r\n")
+
+	return ical.String()
+}
+
+// addTaskToICalendar adds a single task to the iCalendar
+func (h *ICalHandler) addTaskToICalendar(ical *strings.Builder, task *models.Task) {
+	ical.WriteString("BEGIN:VTODO\r\n")
+
+	// UID - unique identifier (use AT Protocol URI)
+	ical.WriteString(fmt.Sprintf("UID:%s\r\n", task.URI))
+
+	// DTSTAMP - when the task was created
+	ical.WriteString(fmt.Sprintf("DTSTAMP:%s\r\n", formatICalTime(task.CreatedAt)))
+
+	// DUE - task due date
+	if task.DueDate != nil {
+		ical.WriteString(fmt.Sprintf("DUE:%s\r\n", formatICalTime(*task.DueDate)))
+	}
+
+	// SUMMARY - task title
+	ical.WriteString(fmt.Sprintf("SUMMARY:%s\r\n", escapeICalText(task.Title)))
+
+	// DESCRIPTION - task description
+	if task.Description != "" {
+		ical.WriteString(fmt.Sprintf("DESCRIPTION:%s\r\n", escapeICalText(task.Description)))
+	}
+
+	// STATUS - task completion status
+	if task.Completed {
+		ical.WriteString("STATUS:COMPLETED\r\n")
+		if task.CompletedAt != nil {
+			ical.WriteString(fmt.Sprintf("COMPLETED:%s\r\n", formatICalTime(*task.CompletedAt)))
+		}
+	} else {
+		ical.WriteString("STATUS:NEEDS-ACTION\r\n")
+	}
+
+	// PRIORITY - map task priority (0=none, 1-10)
+	// iCal priority: 1=high, 5=medium, 9=low
+	priority := 5 // default medium
+	ical.WriteString(fmt.Sprintf("PRIORITY:%d\r\n", priority))
+
+	// CATEGORIES - tags
+	if len(task.Tags) > 0 {
+		categories := strings.Join(task.Tags, ",")
+		ical.WriteString(fmt.Sprintf("CATEGORIES:%s\r\n", escapeICalText(categories)))
+	}
+
+	// URL - link to AT Todo
+	// We could link to the specific task on attodo.app if we had that route
+	// For now, just link to the dashboard
+	ical.WriteString("URL:https://attodo.app/app\r\n")
+
+	ical.WriteString("END:VTODO\r\n")
+}
+
+// formatICalTime formats a time.Time to iCal format (UTC)
+func formatICalTime(t time.Time) string {
+	// iCal format: 20060102T150405Z
+	return t.UTC().Format("20060102T150405Z")
+}
+
+// escapeICalText escapes special characters in iCal text fields
+func escapeICalText(text string) string {
+	// Escape backslashes, commas, semicolons, and newlines
+	text = strings.ReplaceAll(text, "\\", "\\\\")
+	text = strings.ReplaceAll(text, ",", "\\,")
+	text = strings.ReplaceAll(text, ";", "\\;")
+	text = strings.ReplaceAll(text, "\n", "\\n")
+	text = strings.ReplaceAll(text, "\r", "")
+	return text
+}
+
+// sanitizeDID creates a filename-safe version of a DID
+func sanitizeDID(did string) string {
+	// Remove "did:plc:" prefix and use just the identifier
+	parts := strings.Split(did, ":")
+	if len(parts) >= 3 {
+		return parts[2][:min(len(parts[2]), 16)] // Truncate to 16 chars for filename
+	}
+	return "calendar"
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// parseTaskFieldsForICal parses task fields from a record map
+func parseTaskFieldsForICal(record map[string]interface{}) models.Task {
+	task := models.Task{}
+
+	if title, ok := record["title"].(string); ok {
+		task.Title = title
+	}
+	if desc, ok := record["description"].(string); ok {
+		task.Description = desc
+	}
+	if completed, ok := record["completed"].(bool); ok {
+		task.Completed = completed
+	}
+	if createdAt, ok := record["createdAt"].(string); ok {
+		if t, err := time.Parse(time.RFC3339, createdAt); err == nil {
+			task.CreatedAt = t
+		}
+	}
+	if completedAt, ok := record["completedAt"].(string); ok {
+		if t, err := time.Parse(time.RFC3339, completedAt); err == nil {
+			task.CompletedAt = &t
+		}
+	}
+	// Parse due date if present
+	if dueDate, ok := record["dueDate"].(string); ok {
+		if t, err := time.Parse(time.RFC3339, dueDate); err == nil {
+			task.DueDate = &t
+		}
+	}
+	// Parse tags if present
+	if tags, ok := record["tags"].([]interface{}); ok {
+		task.Tags = make([]string, 0, len(tags))
+		for _, tag := range tags {
+			if tagStr, ok := tag.(string); ok {
+				task.Tags = append(task.Tags, tagStr)
+			}
+		}
+	}
+
+	return task
+}
+
+// extractRKeyForICal extracts the record key from an AT URI
+func extractRKeyForICal(uri string) string {
+	parts := strings.Split(uri, "/")
+	if len(parts) > 0 {
+		return parts[len(parts)-1]
+	}
+	return ""
+}

internal/handlers/settings.go

···
 	var err error
 	sess, err = h.WithRetry(r.Context(), sess, func(s *bskyoauth.Session) error {
 		var fetchErr error
-		record, fetchErr = h.getRecord(r.Context(), s, SettingsRKey)
+		record, fetchErr = h.GetRecord(r.Context(), s, SettingsRKey)
 		return fetchErr
 	})
 
···
 		settings = models.DefaultNotificationSettings()
 	} else {
 		// Parse existing settings
-		settings = parseSettingsRecord(record)
+		settings = ParseSettingsRecord(record)
 		settings.RKey = SettingsRKey
 		settings.URI = fmt.Sprintf("at://%s/%s/%s", sess.DID, SettingsCollection, SettingsRKey)
 	}
···
 
 	// Convert to map for AT Protocol
 	record := map[string]interface{}{
-		"$type":             SettingsCollection,
-		"notifyOverdue":     settings.NotifyOverdue,
-		"notifyToday":       settings.NotifyToday,
-		"notifySoon":        settings.NotifySoon,
-		"hoursBefore":       settings.HoursBefore,
-		"checkFrequency":    settings.CheckFrequency,
-		"quietHoursEnabled": settings.QuietHoursEnabled,
-		"quietStart":        settings.QuietStart,
-		"quietEnd":          settings.QuietEnd,
-		"pushEnabled":       settings.PushEnabled,
-		"taskInputCollapsed": settings.TaskInputCollapsed,
-		"updatedAt":         settings.UpdatedAt.Format(time.RFC3339),
+		"$type":                        SettingsCollection,
+		"notifyOverdue":                settings.NotifyOverdue,
+		"notifyToday":                  settings.NotifyToday,
+		"notifySoon":                   settings.NotifySoon,
+		"hoursBefore":                  settings.HoursBefore,
+		"checkFrequency":               settings.CheckFrequency,
+		"quietHoursEnabled":            settings.QuietHoursEnabled,
+		"quietStart":                   settings.QuietStart,
+		"quietEnd":                     settings.QuietEnd,
+		"pushEnabled":                  settings.PushEnabled,
+		"taskInputCollapsed":           settings.TaskInputCollapsed,
+		"calendarNotificationsEnabled": settings.CalendarNotificationsEnabled,
+		"calendarNotificationLeadTime": settings.CalendarNotificationLeadTime,
+		"updatedAt":                    settings.UpdatedAt.Format(time.RFC3339),
 	}
 
 	// Include appUsageHours if present
···
 		record["appUsageHours"] = settings.AppUsageHours
 	}
 
+	// Include notificationSentHistory if present
+	if settings.NotificationSentHistory != nil {
+		record["notificationSentHistory"] = settings.NotificationSentHistory
+	}
+
 	// Check if settings record already exists
 	var err error
 	sess, err = h.WithRetry(r.Context(), sess, func(s *bskyoauth.Session) error {
-		_, fetchErr := h.getRecord(r.Context(), s, SettingsRKey)
+		_, fetchErr := h.GetRecord(r.Context(), s, SettingsRKey)
 		return fetchErr
 	})
 
···
 	json.NewEncoder(w).Encode(settings)
 }
 
-// parseSettingsRecord parses a settings record from AT Protocol
-func parseSettingsRecord(record map[string]interface{}) *models.NotificationSettings {
+// ParseSettingsRecord parses a settings record from AT Protocol
+func ParseSettingsRecord(record map[string]interface{}) *models.NotificationSettings {
 	settings := models.DefaultNotificationSettings()
 
 	if v, ok := record["notifyOverdue"].(bool); ok {
···
 	if v, ok := record["taskInputCollapsed"].(bool); ok {
 		settings.TaskInputCollapsed = v
 	}
+	if v, ok := record["calendarNotificationsEnabled"].(bool); ok {
+		settings.CalendarNotificationsEnabled = v
+	}
+	if v, ok := record["calendarNotificationLeadTime"].(string); ok {
+		settings.CalendarNotificationLeadTime = v
+	}
 
 	// Parse appUsageHours if present
 	if usageMap, ok := record["appUsageHours"].(map[string]interface{}); ok {
···
 		}
 	}
 
+	// Parse notificationSentHistory if present
+	if historyMap, ok := record["notificationSentHistory"].(map[string]interface{}); ok {
+		settings.NotificationSentHistory = make(map[string]string)
+		for k, v := range historyMap {
+			if timestamp, ok := v.(string); ok {
+				settings.NotificationSentHistory[k] = timestamp
+			}
+		}
+	}
+
 	// Parse updatedAt
 	if v, ok := record["updatedAt"].(string); ok {
 		if t, err := time.Parse(time.RFC3339, v); err == nil {
···
 	return settings
 }
 
-// getRecord retrieves a settings record using com.atproto.repo.getRecord
-func (h *SettingsHandler) getRecord(ctx context.Context, sess *bskyoauth.Session, rkey string) (map[string]interface{}, error) {
+// GetRecord retrieves a settings record using com.atproto.repo.getRecord
+func (h *SettingsHandler) GetRecord(ctx context.Context, sess *bskyoauth.Session, rkey string) (map[string]interface{}, error) {
 	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",
 		sess.PDS, sess.DID, SettingsCollection, rkey)
 

internal/jobs/calendar_notification_check.go

···
+package jobs
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/shindakun/attodo/internal/database"
+	"github.com/shindakun/attodo/internal/handlers"
+	"github.com/shindakun/attodo/internal/models"
+	"github.com/shindakun/attodo/internal/push"
+	"github.com/shindakun/bskyoauth"
+)
+
+// CalendarNotificationJob checks for upcoming calendar events and sends notifications
+type CalendarNotificationJob struct {
+	repo            *database.NotificationRepo
+	client          *bskyoauth.Client
+	sender          *push.Sender
+	calendarHandler *handlers.CalendarHandler
+	settingsHandler *handlers.SettingsHandler
+}
+
+// NewCalendarNotificationJob creates a new calendar notification job
+func NewCalendarNotificationJob(repo *database.NotificationRepo, client *bskyoauth.Client, sender *push.Sender, settingsHandler *handlers.SettingsHandler) *CalendarNotificationJob {
+	return &CalendarNotificationJob{
+		repo:            repo,
+		client:          client,
+		sender:          sender,
+		calendarHandler: handlers.NewCalendarHandler(client),
+		settingsHandler: settingsHandler,
+	}
+}
+
+// Name returns the job name
+func (c *CalendarNotificationJob) Name() string {
+	return "CalendarNotificationCheck"
+}
+
+// Run executes the calendar notification check job
+func (c *CalendarNotificationJob) Run(ctx context.Context) error {
+	// Get all users with notifications enabled
+	users, err := c.repo.GetEnabledNotificationUsers()
+	if err != nil {
+		return fmt.Errorf("failed to get enabled users: %w", err)
+	}
+
+	if len(users) == 0 {
+		log.Println("[CalendarNotificationCheck] No users with notifications enabled")
+		return nil
+	}
+
+	log.Printf("[CalendarNotificationCheck] Checking calendar events for %d user(s)", len(users))
+
+	// Check events for each user
+	for _, user := range users {
+		if err := c.checkUserEvents(ctx, user); err != nil {
+			log.Printf("[CalendarNotificationCheck] Error checking events for %s: %v", user.DID, err)
+			// Continue to next user instead of failing the whole job
+			continue
+		}
+	}
+
+	return nil
+}
+
+// checkUserEvents checks calendar events for a single user and sends notifications
+func (c *CalendarNotificationJob) checkUserEvents(ctx context.Context, user *models.NotificationUser) error {
+	// Get user's push subscriptions
+	subscriptions, err := c.repo.GetPushSubscriptionsByDID(user.DID)
+	if err != nil {
+		return fmt.Errorf("failed to get push subscriptions: %w", err)
+	}
+
+	if len(subscriptions) == 0 {
+		log.Printf("[CalendarNotificationCheck] User %s has no push subscriptions", user.DID)
+		return nil
+	}
+
+	// Get user's calendar notification settings
+	settings, err := c.getUserSettings(ctx, user.DID)
+	if err != nil {
+		log.Printf("[CalendarNotificationCheck] Failed to get settings for %s: %v", user.DID, err)
+		// Continue with defaults
+		settings = models.DefaultNotificationSettings()
+	}
+
+	// Skip if calendar notifications are disabled
+	if !settings.CalendarNotificationsEnabled {
+		log.Printf("[CalendarNotificationCheck] Calendar notifications disabled for %s", user.DID)
+		return nil
+	}
+
+	// Get notification lead time (default 1 hour)
+	leadTime := time.Hour
+	if settings.CalendarNotificationLeadTime != "" {
+		parsed, err := time.ParseDuration(settings.CalendarNotificationLeadTime)
+		if err == nil {
+			leadTime = parsed
+		}
+	}
+
+	// Fetch upcoming events within the lead time window
+	events, err := c.fetchUpcomingEventsForUser(ctx, user.DID, leadTime)
+	if err != nil {
+		return fmt.Errorf("failed to fetch upcoming events: %w", err)
+	}
+
+	if len(events) == 0 {
+		return nil // No upcoming events
+	}
+
+	log.Printf("[CalendarNotificationCheck] Found %d upcoming events for %s", len(events), user.DID)
+
+	// Send notifications for events
+	for _, event := range events {
+		if err := c.sendEventNotification(ctx, user.DID, event, leadTime, subscriptions); err != nil {
+			log.Printf("WARNING: Failed to send notification for event %s: %v", event.RKey, err)
+			continue
+		}
+	}
+
+	return nil
+}
+
+// getUserSettings fetches user settings without requiring a session (public read)
+func (c *CalendarNotificationJob) getUserSettings(ctx context.Context, did string) (*models.NotificationSettings, error) {
+	// Resolve PDS endpoint for this DID
+	pds, err := c.resolvePDSEndpoint(ctx, did)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve PDS endpoint: %w", err)
+	}
+
+	// Build the XRPC URL for public read (no auth needed)
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.getRecord?repo=%s&collection=%s&rkey=%s",
+		pds, did, handlers.SettingsCollection, handlers.SettingsRKey)
+
+	// Create request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make request (no auth needed for public reads)
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		// Settings not found is okay, return defaults
+		return models.DefaultNotificationSettings(), nil
+	}
+
+	// Parse response
+	var result struct {
+		Value map[string]interface{} `json:"value"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Parse settings
+	settings := handlers.ParseSettingsRecord(result.Value)
+	return settings, nil
+}
+
+// fetchUpcomingEventsForUser fetches events for a user without requiring a session (public read)
+func (c *CalendarNotificationJob) fetchUpcomingEventsForUser(ctx context.Context, did string, within time.Duration) ([]*models.CalendarEvent, error) {
+	// Resolve PDS endpoint for this DID
+	pds, err := c.resolvePDSEndpoint(ctx, did)
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve PDS endpoint: %w", err)
+	}
+
+	// Build the XRPC URL for public read (no auth needed)
+	url := fmt.Sprintf("%s/xrpc/com.atproto.repo.listRecords?repo=%s&collection=%s",
+		pds, did, handlers.CalendarEventCollection)
+
+	// Create request
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make request (no auth needed for public reads)
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("XRPC error %d", resp.StatusCode)
+	}
+
+	// Parse response
+	var result struct {
+		Records []struct {
+			Uri   string                 `json:"uri"`
+			Cid   string                 `json:"cid"`
+			Value map[string]interface{} `json:"value"`
+		} `json:"records"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+
+	// Convert to CalendarEvent models and filter for upcoming events
+	upcomingEvents := make([]*models.CalendarEvent, 0)
+	for _, record := range result.Records {
+		event, err := models.ParseCalendarEvent(record.Value, record.Uri, record.Cid)
+		if err != nil {
+			log.Printf("WARNING: Failed to parse calendar event %s: %v", record.Uri, err)
+			continue
+		}
+
+		// Filter for upcoming events within the time window
+		if event.StartsWithin(within) && !event.IsCancelled() {
+			upcomingEvents = append(upcomingEvents, event)
+		}
+	}
+
+	return upcomingEvents, nil
+}
+
+// resolvePDSEndpoint resolves the PDS endpoint for a given DID
+func (c *CalendarNotificationJob) resolvePDSEndpoint(ctx context.Context, did string) (string, error) {
+	dir := identity.DefaultDirectory()
+	atid, err := syntax.ParseAtIdentifier(did)
+	if err != nil {
+		return "", err
+	}
+
+	ident, err := dir.Lookup(ctx, *atid)
+	if err != nil {
+		return "", err
+	}
+
+	return ident.PDSEndpoint(), nil
+}
+
+// sendEventNotification sends a notification for an event
+func (c *CalendarNotificationJob) sendEventNotification(ctx context.Context, did string, event *models.CalendarEvent, leadTime time.Duration, subscriptions []*models.PushSubscription) error {
+	// Check if we've already sent a notification for this event
+	eventURI := event.URI
+	recent, err := c.repo.GetRecentNotification(did, eventURI, 24) // Don't spam within 24 hours
+	if err != nil {
+		log.Printf("WARNING: Error checking notification history: %v", err)
+	}
+	if recent != nil {
+		// Already notified recently, skip
+		log.Printf("INFO: Skipping notification for event %s - already sent within 24h", event.RKey)
+		return nil
+	}
+
+	// Build notification message
+	title := fmt.Sprintf("Upcoming Event: %s", event.Name)
+	body := c.buildNotificationBody(event, leadTime)
+
+	notification := &push.Notification{
+		Title: title,
+		Body:  body,
+		Icon:  "/static/icon-192.png",
+		Badge: "/static/icon-192.png",
+		Tag:   fmt.Sprintf("calendar-event-%s", event.RKey),
+		Data: map[string]interface{}{
+			"type":     "calendar_event",
+			"eventURI": eventURI,
+			"url":      event.SmokesignalURL(),
+		},
+	}
+
+	// Send to all subscriptions
+	successCount, errors := c.sender.SendToAll(subscriptions, notification)
+	log.Printf("INFO: Sent calendar notification for event %s to %d/%d subscriptions", event.RKey, successCount, len(subscriptions))
+
+	// Record notification history
+	status := "sent"
+	var errMsg string
+	if successCount == 0 {
+		status = "failed"
+		if len(errors) > 0 {
+			errMsg = fmt.Sprintf("%v", errors[0])
+		}
+	} else if len(errors) > 0 {
+		errMsg = fmt.Sprintf("Sent to %d/%d subscriptions. Errors: %v", successCount, len(subscriptions), errors[0])
+	}
+
+	history := &models.NotificationHistory{
+		DID:              did,
+		TaskURI:          eventURI, // Reuse TaskURI field for event URI
+		NotificationType: "calendar_event",
+		Status:           status,
+		ErrorMessage:     errMsg,
+	}
+	if err := c.repo.CreateNotificationHistory(history); err != nil {
+		log.Printf("WARNING: Failed to create notification history: %v", err)
+	}
+
+	if successCount == 0 {
+		return fmt.Errorf("failed to send to all subscriptions: %v", errors)
+	}
+
+	return nil
+}
+
+// buildNotificationBody builds the notification message body
+func (c *CalendarNotificationJob) buildNotificationBody(event *models.CalendarEvent, leadTime time.Duration) string {
+	if event.StartsAt == nil {
+		return event.Description
+	}
+
+	timeUntil := time.Until(*event.StartsAt)
+
+	var timeMessage string
+	if timeUntil < time.Hour {
+		minutes := int(timeUntil.Minutes())
+		timeMessage = fmt.Sprintf("starts in %d minutes", minutes)
+	} else if timeUntil < 24*time.Hour {
+		hours := int(timeUntil.Hours())
+		timeMessage = fmt.Sprintf("starts in %d hours", hours)
+	} else {
+		days := int(timeUntil.Hours() / 24)
+		timeMessage = fmt.Sprintf("starts in %d days", days)
+	}
+
+	// Add mode information
+	var modeInfo string
+	switch event.Mode {
+	case models.AttendanceModeVirtual:
+		modeInfo = "💻 Virtual event"
+	case models.AttendanceModeInPerson:
+		modeInfo = "📍 In-person event"
+	case models.AttendanceModeHybrid:
+		modeInfo = "🔄 Hybrid event"
+	}
+
+	if modeInfo != "" {
+		return fmt.Sprintf("%s %s", modeInfo, timeMessage)
+	}
+
+	return timeMessage
+}

internal/models/calendar.go

···
+package models
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Event status constants
+const (
+	EventStatusPlanned     = "planned"     // Created but not finalized
+	EventStatusScheduled   = "scheduled"   // Created and finalized
+	EventStatusRescheduled = "rescheduled" // Event time/details changed
+	EventStatusCancelled   = "cancelled"   // Event removed
+	EventStatusPostponed   = "postponed"   // No new date set
+)
+
+// Attendance mode constants
+const (
+	AttendanceModeVirtual   = "virtual"    // Online only
+	AttendanceModeInPerson  = "in-person"  // Physical location only
+	AttendanceModeHybrid    = "hybrid"     // Both online and in-person
+)
+
+// RSVP status constants
+const (
+	RSVPStatusInterested = "interested" // Interested in the event
+	RSVPStatusGoing      = "going"      // Going to the event
+	RSVPStatusNotGoing   = "notgoing"   // Not going to the event
+)
+
+// CalendarEvent represents a community.lexicon.calendar.event record
+type CalendarEvent struct {
+	Name        string     `json:"name"`
+	Description string     `json:"description,omitempty"`
+	CreatedAt   time.Time  `json:"createdAt"`
+	StartsAt    *time.Time `json:"startsAt,omitempty"`
+	EndsAt      *time.Time `json:"endsAt,omitempty"`
+	Mode        string     `json:"mode,omitempty"`        // hybrid, in-person, virtual
+	Status      string     `json:"status,omitempty"`      // planned, scheduled, etc.
+	Locations   []Location `json:"locations,omitempty"`
+	URIs        []string   `json:"uris,omitempty"`
+
+	// AT Protocol metadata
+	RKey string `json:"rKey,omitempty"`
+	URI  string `json:"uri,omitempty"`
+	CID  string `json:"cid,omitempty"`
+}
+
+// Location represents a location where an event takes place
+type Location struct {
+	Name    string  `json:"name,omitempty"`
+	Address string  `json:"address,omitempty"`
+	Lat     float64 `json:"lat,omitempty"`
+	Lon     float64 `json:"lon,omitempty"`
+}
+
+// CalendarRSVP represents a community.lexicon.calendar.rsvp record
+type CalendarRSVP struct {
+	Subject *StrongRef `json:"subject"` // Reference to event
+	Status  string     `json:"status"`  // interested, going, notgoing
+
+	// AT Protocol metadata
+	RKey string `json:"-"`
+	URI  string `json:"-"`
+	CID  string `json:"-"`
+}
+
+// StrongRef represents a com.atproto.repo.strongRef
+type StrongRef struct {
+	URI string `json:"uri"`
+	CID string `json:"cid"`
+}
+
+// IsUpcoming returns true if the event starts in the future
+func (e *CalendarEvent) IsUpcoming() bool {
+	if e.StartsAt == nil {
+		return false
+	}
+	return e.StartsAt.After(time.Now())
+}
+
+// IsPast returns true if the event has already ended
+func (e *CalendarEvent) IsPast() bool {
+	if e.EndsAt != nil {
+		return e.EndsAt.Before(time.Now())
+	}
+	if e.StartsAt != nil {
+		return e.StartsAt.Before(time.Now())
+	}
+	return false
+}
+
+// IsCancelled returns true if the event is cancelled or postponed
+func (e *CalendarEvent) IsCancelled() bool {
+	return e.Status == EventStatusCancelled || e.Status == EventStatusPostponed
+}
+
+// StartsWithin returns true if the event starts within the given duration
+func (e *CalendarEvent) StartsWithin(d time.Duration) bool {
+	if e.StartsAt == nil {
+		return false
+	}
+	now := time.Now()
+	return e.StartsAt.After(now) && e.StartsAt.Before(now.Add(d))
+}
+
+// FormatStatus returns a human-readable status string
+func (e *CalendarEvent) FormatStatus() string {
+	switch e.Status {
+	case EventStatusPlanned:
+		return "Planned"
+	case EventStatusScheduled:
+		return "Scheduled"
+	case EventStatusRescheduled:
+		return "Rescheduled"
+	case EventStatusCancelled:
+		return "Cancelled"
+	case EventStatusPostponed:
+		return "Postponed"
+	case "": // Empty status
+		return ""
+	default:
+		return ""
+	}
+}
+
+// HasKnownStatus returns true if the event has a recognized status
+func (e *CalendarEvent) HasKnownStatus() bool {
+	switch e.Status {
+	case EventStatusPlanned, EventStatusScheduled, EventStatusRescheduled, EventStatusCancelled, EventStatusPostponed:
+		return true
+	default:
+		return false
+	}
+}
+
+// FormatMode returns a human-readable attendance mode string
+func (e *CalendarEvent) FormatMode() string {
+	switch e.Mode {
+	case AttendanceModeVirtual:
+		return "Virtual"
+	case AttendanceModeInPerson:
+		return "In Person"
+	case AttendanceModeHybrid:
+		return "Hybrid"
+	default:
+		return ""
+	}
+}
+
+// FormatRSVPStatus returns a human-readable RSVP status string
+func (r *CalendarRSVP) FormatStatus() string {
+	switch r.Status {
+	case RSVPStatusInterested:
+		return "Interested"
+	case RSVPStatusGoing:
+		return "Going"
+	case RSVPStatusNotGoing:
+		return "Not Going"
+	default:
+		return "Unknown"
+	}
+}
+
+// ExtractDID extracts the DID from the event URI
+// Example: at://did:plc:xxx/community.lexicon.calendar.event/abc123 -> did:plc:xxx
+func (e *CalendarEvent) ExtractDID() string {
+	if e.URI == "" {
+		return ""
+	}
+
+	// Remove "at://" prefix
+	uri := e.URI
+	if len(uri) > 5 && uri[:5] == "at://" {
+		uri = uri[5:]
+	}
+
+	// Find first slash to get DID
+	slashIndex := -1
+	for i := 0; i < len(uri); i++ {
+		if uri[i] == '/' {
+			slashIndex = i
+			break
+		}
+	}
+
+	if slashIndex > 0 {
+		return uri[:slashIndex]
+	}
+
+	return ""
+}
+
+// SmokesignalURL returns the Smokesignal event URL if this is a Smokesignal event
+// Returns empty string if not a Smokesignal event or if URI cannot be parsed
+func (e *CalendarEvent) SmokesignalURL() string {
+	did := e.ExtractDID()
+	if did == "" || e.RKey == "" {
+		return ""
+	}
+
+	// Smokesignal URL format: https://smokesignal.events/{did}/{rkey}
+	return fmt.Sprintf("https://smokesignal.events/%s/%s", did, e.RKey)
+}
+
+// TruncatedDescription returns a truncated version of the description
+func (e *CalendarEvent) TruncatedDescription(maxLen int) string {
+	if len(e.Description) <= maxLen {
+		return e.Description
+	}
+	return e.Description[:maxLen] + "..."
+}
+
+// ParseCalendarEvent parses an AT Protocol record into a CalendarEvent
+func ParseCalendarEvent(record map[string]interface{}, uri, cid string) (*CalendarEvent, error) {
+	event := &CalendarEvent{
+		URI:  uri,
+		CID:  cid,
+		RKey: extractRKey(uri),
+	}
+
+	// Required: name
+	if name, ok := record["name"].(string); ok {
+		event.Name = name
+	} else {
+		return nil, fmt.Errorf("missing required field: name")
+	}
+
+	// Required: createdAt
+	if createdAtStr, ok := record["createdAt"].(string); ok {
+		createdAt, err := time.Parse(time.RFC3339, createdAtStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid createdAt: %w", err)
+		}
+		event.CreatedAt = createdAt
+	} else {
+		return nil, fmt.Errorf("missing required field: createdAt")
+	}
+
+	// Optional: description
+	if description, ok := record["description"].(string); ok {
+		event.Description = description
+	}
+
+	// Optional: startsAt
+	if startsAtStr, ok := record["startsAt"].(string); ok {
+		startsAt, err := time.Parse(time.RFC3339, startsAtStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid startsAt: %w", err)
+		}
+		event.StartsAt = &startsAt
+	}
+
+	// Optional: endsAt
+	if endsAtStr, ok := record["endsAt"].(string); ok {
+		endsAt, err := time.Parse(time.RFC3339, endsAtStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid endsAt: %w", err)
+		}
+		event.EndsAt = &endsAt
+	}
+
+	// Optional: mode
+	if mode, ok := record["mode"].(string); ok {
+		// Strip lexicon prefix if present (e.g., "community.lexicon.calendar.event#hybrid" -> "hybrid")
+		if idx := strings.LastIndex(mode, "#"); idx != -1 {
+			event.Mode = mode[idx+1:]
+		} else {
+			event.Mode = mode
+		}
+	}
+
+	// Optional: status
+	if status, ok := record["status"].(string); ok {
+		// Strip lexicon prefix if present (e.g., "community.lexicon.calendar.event#scheduled" -> "scheduled")
+		if idx := strings.LastIndex(status, "#"); idx != -1 {
+			event.Status = status[idx+1:]
+		} else {
+			event.Status = status
+		}
+	}
+
+	// Optional: locations
+	if locationsRaw, ok := record["locations"].([]interface{}); ok {
+		for _, locRaw := range locationsRaw {
+			if locMap, ok := locRaw.(map[string]interface{}); ok {
+				loc := Location{}
+				if name, ok := locMap["name"].(string); ok {
+					loc.Name = name
+				}
+				if address, ok := locMap["address"].(string); ok {
+					loc.Address = address
+				}
+				if lat, ok := locMap["lat"].(float64); ok {
+					loc.Lat = lat
+				}
+				if lon, ok := locMap["lon"].(float64); ok {
+					loc.Lon = lon
+				}
+				event.Locations = append(event.Locations, loc)
+			}
+		}
+	}
+
+	// Optional: uris
+	if urisRaw, ok := record["uris"].([]interface{}); ok {
+		for _, uriRaw := range urisRaw {
+			if uri, ok := uriRaw.(string); ok {
+				event.URIs = append(event.URIs, uri)
+			}
+		}
+	}
+
+	return event, nil
+}
+
+// ParseCalendarRSVP parses an AT Protocol record into a CalendarRSVP
+func ParseCalendarRSVP(record map[string]interface{}, uri, cid string) (*CalendarRSVP, error) {
+	rsvp := &CalendarRSVP{
+		URI:  uri,
+		CID:  cid,
+		RKey: extractRKey(uri),
+	}
+
+	// Required: subject
+	if subjectRaw, ok := record["subject"].(map[string]interface{}); ok {
+		subject := &StrongRef{}
+		if subjectURI, ok := subjectRaw["uri"].(string); ok {
+			subject.URI = subjectURI
+		} else {
+			return nil, fmt.Errorf("missing subject.uri")
+		}
+		if subjectCID, ok := subjectRaw["cid"].(string); ok {
+			subject.CID = subjectCID
+		} else {
+			return nil, fmt.Errorf("missing subject.cid")
+		}
+		rsvp.Subject = subject
+	} else {
+		return nil, fmt.Errorf("missing required field: subject")
+	}
+
+	// Required: status
+	if status, ok := record["status"].(string); ok {
+		// Strip lexicon prefix if present (e.g., "community.lexicon.calendar.rsvp#going" -> "going")
+		if idx := strings.LastIndex(status, "#"); idx != -1 {
+			rsvp.Status = status[idx+1:]
+		} else {
+			rsvp.Status = status
+		}
+	} else {
+		return nil, fmt.Errorf("missing required field: status")
+	}
+
+	return rsvp, nil
+}
+
+// extractRKey extracts the record key from an AT URI
+// Example: at://did:plc:xxx/community.lexicon.calendar.event/abc123 -> abc123
+func extractRKey(uri string) string {
+	// Simple extraction - find last slash and return everything after it
+	for i := len(uri) - 1; i >= 0; i-- {
+		if uri[i] == '/' {
+			return uri[i+1:]
+		}
+	}
+	return ""
+}

internal/models/settings.go

···
 	// UI preferences
 	TaskInputCollapsed bool `json:"taskInputCollapsed"` // Whether task input form is collapsed
 
+	// Calendar notification settings
+	CalendarNotificationsEnabled  bool              `json:"calendarNotificationsEnabled"`            // Enable calendar event notifications
+	CalendarNotificationLeadTime  string            `json:"calendarNotificationLeadTime,omitempty"`  // Lead time for notifications (e.g. "1h", "30m")
+	NotificationSentHistory       map[string]string `json:"notificationSentHistory,omitempty"`       // Event RKey -> last sent timestamp
+
 	// Usage pattern tracking (for smart notification scheduling in Phase 3)
 	AppUsageHours map[string]int `json:"appUsageHours,omitempty"` // Hour (0-23) -> count
 
···
 // DefaultNotificationSettings returns default notification settings
 func DefaultNotificationSettings() *NotificationSettings {
 	return &NotificationSettings{
-		NotifyOverdue:      true,
-		NotifyToday:        true,
-		NotifySoon:         false,
-		HoursBefore:        1,
-		CheckFrequency:     30,
-		QuietHoursEnabled:  false,
-		QuietStart:         22,
-		QuietEnd:           8,
-		PushEnabled:        false,
-		TaskInputCollapsed: false,
-		UpdatedAt:          time.Now().UTC(),
-		RKey:               "settings",
+		NotifyOverdue:                true,
+		NotifyToday:                  true,
+		NotifySoon:                   false,
+		HoursBefore:                  1,
+		CheckFrequency:               30,
+		QuietHoursEnabled:            false,
+		QuietStart:                   22,
+		QuietEnd:                     8,
+		PushEnabled:                  false,
+		TaskInputCollapsed:           false,
+		CalendarNotificationsEnabled: true,
+		CalendarNotificationLeadTime: "1h",
+		NotificationSentHistory:      make(map[string]string),
+		UpdatedAt:                    time.Now().UTC(),
+		RKey:                         "settings",
 	}
 }

templates/dashboard.html

···
         #task-input-container header button:hover {
             transform: scale(1.1);
         }
+        /* Calendar event styles */
+        .event-card {
+            padding: 1rem;
+            margin: 0.5rem 0;
+            border: 1px solid var(--pico-muted-border-color);
+            border-radius: var(--pico-border-radius);
+        }
+        .event-card h4 {
+            margin: 0 0 0.5rem 0;
+        }
+        .event-status-badge {
+            display: inline-block;
+            padding: 0.25rem 0.5rem;
+            font-size: 0.75rem;
+            font-weight: bold;
+            border-radius: 4px;
+            text-transform: uppercase;
+        }
+        .event-status-badge.status-scheduled {
+            background-color: #10b981;
+            color: white;
+        }
+        .event-status-badge.status-planned {
+            background-color: #3b82f6;
+            color: white;
+        }
+        .event-status-badge.status-rescheduled {
+            background-color: #f59e0b;
+            color: white;
+        }
+        .event-status-badge.status-cancelled,
+        .event-status-badge.status-postponed {
+            background-color: #ef4444;
+            color: white;
+        }
+        .event-meta {
+            font-size: 0.875rem;
+            color: var(--pico-muted-color);
+            margin-top: 0.75rem;
+        }
+        .event-meta > div {
+            margin: 0.25rem 0;
+        }
+        .event-actions {
+            display: flex;
+            gap: 0.5rem;
+            justify-content: flex-end;
+        }
     </style>
     <script>
         // Toast notification system
···
 
             const tasksContainer = document.getElementById(tabName + '-tasks');
 
-            // Skip reload logic for lists tab (it doesn't have a tasks container)
-            if (tabName === 'lists') {
+            // Skip reload logic for lists and calendar tabs (they don't have a tasks container)
+            if (tabName === 'lists' || tabName === 'calendar') {
                 return;
             }
 
···
                 <button onclick="switchTab('completed')">Completed</button>
                 <button onclick="switchTab('due')">Due</button>
                 <button onclick="switchTab('lists')">Lists</button>
+                <button onclick="switchTab('calendar')">📅 Events</button>
             </div>
 
             <!-- Incomplete Tasks Tab -->
···
                     <p style="margin-top: 1rem; color: var(--pico-muted-color);">Loading lists...</p>
                 </div>
             </div>
+
+            <!-- Calendar Events Tab -->
+            <div id="calendar-tab" class="tab-content">
+                <article style="margin-bottom: 1rem; background-color: var(--pico-card-background-color); padding: 1rem; border-radius: var(--pico-border-radius);">
+                    <p style="margin: 0; color: var(--pico-muted-color);">
+                        <strong>Note:</strong> Calendar events are read-only. AT Todo displays events from your AT Protocol repository that were created by other calendar apps.
+                    </p>
+                </article>
+
+                <!-- Event Filters -->
+                <div style="margin-bottom: 1rem; display: flex; gap: 0.5rem; flex-wrap: wrap;">
+                    <button class="secondary active" data-filter="upcoming" onclick="filterEvents('upcoming')" style="padding: 0.25rem 0.75rem; margin: 0;">
+                        Upcoming
+                    </button>
+                    <button class="secondary" data-filter="all" onclick="filterEvents('all')" style="padding: 0.25rem 0.75rem; margin: 0;">
+                        All Events
+                    </button>
+                </div>
+
+                <!-- Upcoming Events (next 7 days) -->
+                <div id="upcoming-events-container">
+                    <h3>Upcoming Events (Next 7 Days)</h3>
+                    <div id="upcoming-events"
+                         hx-get="/app/calendar/upcoming?within=168h"
+                         hx-trigger="load, reload-calendar from:body"
+                         hx-swap="innerHTML"
+                         hx-indicator="#calendar-loading">
+                        <!-- Upcoming events will be loaded here -->
+                    </div>
+                </div>
+
+                <!-- All Events -->
+                <div id="all-events-container" style="display: none;">
+                    <h3>All Calendar Events</h3>
+                    <div id="all-events"
+                         hx-get="/app/calendar/events"
+                         hx-trigger="reload-calendar from:body, load-all-events from:body"
+                         hx-swap="innerHTML"
+                         hx-indicator="#calendar-loading">
+                        <!-- All events will be loaded here -->
+                    </div>
+                </div>
+
+                <!-- Loading indicator for calendar -->
+                <div id="calendar-loading" class="htmx-indicator" style="text-align: center; padding: 2rem; display: none;">
+                    <div style="display: inline-block; width: 40px; height: 40px; border: 4px solid var(--pico-primary); border-radius: 50%; border-top-color: transparent; animation: spin 0.8s linear infinite;"></div>
+                    <p style="margin-top: 1rem; color: var(--pico-muted-color);">Loading events...</p>
+                </div>
+            </div>
         </section>
+
+        <!-- Calendar Event Detail Modal -->
+        {{template "calendar-event-modal.html"}}
 
         <!-- Settings Dialog (Modal) -->
         <dialog id="settings-dialog">
···
     <script>
         // Convert all timestamps to user's local timezone
         function formatLocalTime() {
-            document.querySelectorAll('time.local-time').forEach(function(timeElement) {
+            document.querySelectorAll('time.local-time, time.utc-time').forEach(function(timeElement) {
                 const datetime = timeElement.getAttribute('datetime');
                 if (datetime) {
                     try {
···
             e.stopPropagation();
         });
         })(); // End of IIFE
+
+        // Calendar event functions
+        function filterEvents(filter) {
+            // Update button states
+            document.querySelectorAll('[data-filter]').forEach(btn => {
+                btn.classList.remove('active');
+            });
+            event.target.classList.add('active');
+
+            // Show/hide event containers
+            if (filter === 'upcoming') {
+                document.getElementById('upcoming-events-container').style.display = 'block';
+                document.getElementById('all-events-container').style.display = 'none';
+            } else {
+                document.getElementById('upcoming-events-container').style.display = 'none';
+                document.getElementById('all-events-container').style.display = 'block';
+
+                // Trigger HTMX load for all-events container
+                const allEventsDiv = document.getElementById('all-events');
+                if (allEventsDiv) {
+                    // Always trigger to ensure fresh data
+                    htmx.trigger(allEventsDiv, 'load-all-events');
+                }
+            }
+        }
+
+        async function viewEventDetails(rkey) {
+            try {
+                // Fetch event details
+                const response = await fetch(`/app/calendar/events/${rkey}`);
+                if (!response.ok) {
+                    throw new Error('Failed to fetch event');
+                }
+                const event = await response.json();
+
+                // Populate modal
+                document.getElementById('event-modal-title').textContent = event.name || 'Event';
+
+                // Smokesignal link - build URL from event URI and rkey
+                const smokesignalLink = document.getElementById('event-modal-smokesignal-link');
+                if (event.uri && event.rKey) {
+                    // Extract DID from URI (format: at://did:plc:xxx/collection/rkey)
+                    const uriParts = event.uri.replace('at://', '').split('/');
+                    if (uriParts.length >= 1) {
+                        const did = uriParts[0];
+                        const smokesignalURL = `https://smokesignal.events/${did}/${event.rKey}`;
+                        smokesignalLink.href = smokesignalURL;
+                        smokesignalLink.style.display = 'inline-flex';
+                    } else {
+                        smokesignalLink.style.display = 'none';
+                    }
+                } else {
+                    smokesignalLink.style.display = 'none';
+                }
+
+                // Status badge
+                const statusDiv = document.getElementById('event-modal-status');
+                if (event.status) {
+                    statusDiv.innerHTML = `<span class="event-status-badge status-${event.status}">${formatStatus(event.status)}</span>`;
+                } else {
+                    statusDiv.innerHTML = '';
+                }
+
+                // Description
+                const descDiv = document.getElementById('event-modal-description');
+                descDiv.textContent = event.description || '';
+                descDiv.style.display = event.description ? 'block' : 'none';
+
+                // Start/End times
+                const startsDiv = document.getElementById('event-modal-starts');
+                const endsDiv = document.getElementById('event-modal-ends');
+                if (event.startsAt) {
+                    startsDiv.innerHTML = `<strong>📅 Starts:</strong> <time class="utc-time" datetime="${event.startsAt}">${event.startsAt}</time>`;
+                    startsDiv.style.display = 'block';
+                } else {
+                    startsDiv.style.display = 'none';
+                }
+                if (event.endsAt) {
+                    endsDiv.innerHTML = `<strong>🏁 Ends:</strong> <time class="utc-time" datetime="${event.endsAt}">${event.endsAt}</time>`;
+                    endsDiv.style.display = 'block';
+                } else {
+                    endsDiv.style.display = 'none';
+                }
+
+                // Mode
+                const modeDiv = document.getElementById('event-modal-mode');
+                if (event.mode) {
+                    let modeIcon = '🔄';
+                    let modeText = event.mode;
+                    if (event.mode === 'virtual') {
+                        modeIcon = '💻';
+                        modeText = 'Virtual';
+                    } else if (event.mode === 'in-person') {
+                        modeIcon = '📍';
+                        modeText = 'In Person';
+                    } else if (event.mode === 'hybrid') {
+                        modeIcon = '🔄';
+                        modeText = 'Hybrid';
+                    }
+                    modeDiv.innerHTML = `<strong>${modeIcon} Mode:</strong> ${modeText}`;
+                    modeDiv.style.display = 'block';
+                } else {
+                    modeDiv.style.display = 'none';
+                }
+
+                // Locations
+                const locationsDiv = document.getElementById('event-modal-locations');
+                if (event.locations && event.locations.length > 0) {
+                    const locationsList = event.locations.map(loc => {
+                        if (loc.name && loc.address) {
+                            return `${loc.name} (${loc.address})`;
+                        }
+                        return loc.name || loc.address || '';
+                    }).filter(l => l).join(', ');
+                    locationsDiv.innerHTML = `<strong>📍 Location${event.locations.length > 1 ? 's' : ''}:</strong> ${locationsList}`;
+                    locationsDiv.style.display = 'block';
+                } else {
+                    locationsDiv.style.display = 'none';
+                }
+
+                // URIs
+                const urisDiv = document.getElementById('event-modal-uris');
+                if (event.uris && event.uris.length > 0) {
+                    const urisList = event.uris.map(uri => `<a href="${uri}" target="_blank" rel="noopener noreferrer">${uri}</a>`).join('<br>');
+                    urisDiv.innerHTML = `<strong>🔗 Links:</strong><br>${urisList}`;
+                    urisDiv.style.display = 'block';
+                } else {
+                    urisDiv.style.display = 'none';
+                }
+
+                // Created date
+                const createdDiv = document.getElementById('event-modal-created');
+                if (event.createdAt) {
+                    createdDiv.innerHTML = `<strong>Created:</strong> <time class="utc-time" datetime="${event.createdAt}">${event.createdAt}</time>`;
+                } else {
+                    createdDiv.innerHTML = '';
+                }
+
+                // Format times after populating
+                setTimeout(formatLocalTime, 0);
+
+                // Show RSVP information with link to Smokesignal
+                loadEventRSVPs(event);
+
+                // Show modal
+                document.getElementById('event-detail-modal').showModal();
+            } catch (error) {
+                console.error('Error loading event:', error);
+                showToast('Failed to load event details', 'error');
+            }
+        }
+
+        async function loadEventRSVPs(event) {
+            const rsvpListDiv = document.getElementById('event-rsvp-list');
+
+            // Build Smokesignal URL for viewing all RSVPs
+            if (event.uri && event.rKey) {
+                const uriParts = event.uri.replace('at://', '').split('/');
+                if (uriParts.length >= 1) {
+                    const did = uriParts[0];
+                    const smokesignalURL = `https://smokesignal.events/${did}/${event.rKey}`;
+
+                    // Try to fetch user's own RSVP status
+                    try {
+                        const rsvpResponse = await fetch(`/app/calendar/events/${event.rKey}/rsvps`);
+                        let userRsvpHtml = '';
+
+                        if (rsvpResponse.ok) {
+                            const rsvps = await rsvpResponse.json();
+                            if (rsvps && rsvps.length > 0) {
+                                const userRsvp = rsvps[0]; // User's own RSVP
+                                const statusEmoji = {
+                                    'going': '✓',
+                                    'interested': 'ⓘ',
+                                    'notgoing': '✗'
+                                };
+                                const statusColor = {
+                                    'going': '#10b981',
+                                    'interested': '#3b82f6',
+                                    'notgoing': '#ef4444'
+                                };
+                                const statusText = {
+                                    'going': 'Going',
+                                    'interested': 'Interested',
+                                    'notgoing': 'Not Going'
+                                };
+
+                                userRsvpHtml = `
+                                    <div style="margin-bottom: 1rem; padding: 0.75rem; background: var(--pico-card-background-color); border-radius: 0.25rem; border-left: 3px solid ${statusColor[userRsvp.status]};">
+                                        <strong>Your RSVP:</strong>
+                                        <span style="color: ${statusColor[userRsvp.status]};">
+                                            ${statusEmoji[userRsvp.status]} ${statusText[userRsvp.status]}
+                                        </span>
+                                    </div>
+                                `;
+                            }
+                        }
+
+                        rsvpListDiv.innerHTML = `
+                            ${userRsvpHtml}
+                            <p style="color: var(--pico-muted-color); margin-bottom: 0.75rem; font-size: 0.875rem;">
+                                All RSVPs are managed on Smokesignal
+                            </p>
+                            <a href="${smokesignalURL}" target="_blank" rel="noopener noreferrer" class="secondary" style="display: inline-block; font-size: 0.875rem;">
+                                View all RSVPs 💨
+                            </a>
+                        `;
+                    } catch (error) {
+                        console.error('Error fetching RSVP:', error);
+                        rsvpListDiv.innerHTML = `
+                            <p style="color: var(--pico-muted-color); margin-bottom: 0.75rem; font-size: 0.875rem;">
+                                All RSVPs are managed on Smokesignal
+                            </p>
+                            <a href="${smokesignalURL}" target="_blank" rel="noopener noreferrer" class="secondary" style="display: inline-block; font-size: 0.875rem;">
+                                View all RSVPs 💨
+                            </a>
+                        `;
+                    }
+                } else {
+                    rsvpListDiv.innerHTML = '<p style="color: var(--pico-muted-color); font-style: italic;">RSVP information not available</p>';
+                }
+            } else {
+                rsvpListDiv.innerHTML = '<p style="color: var(--pico-muted-color); font-style: italic;">RSVP information not available</p>';
+            }
+        }
+
+        function formatStatus(status) {
+            const statusMap = {
+                'planned': 'Planned',
+                'scheduled': 'Scheduled',
+                'rescheduled': 'Rescheduled',
+                'cancelled': 'Cancelled',
+                'postponed': 'Postponed'
+            };
+            return statusMap[status] || status;
+        }
     </script>
 </body>
 </html>

templates/partials/calendar-event-card.html

···
+{{define "calendar-event-card.html"}}
+<article class="event-card" data-event-uri="{{.URI}}">
+    <header>
+        <div style="display: flex; justify-content: space-between; align-items: start; gap: 0.5rem;">
+            <h4 style="margin: 0; flex: 1;">{{.Name}}</h4>
+            <div style="display: flex; align-items: center; gap: 0.5rem;">
+                {{if .HasKnownStatus}}
+                <span class="event-status-badge status-{{.Status}}">{{.FormatStatus}}</span>
+                {{end}}
+                {{if .SmokesignalURL}}
+                <a href="{{.SmokesignalURL}}" target="_blank" rel="noopener noreferrer" title="View on Smokesignal" style="display: inline-flex; align-items: center; text-decoration: none; font-size: 18px;">
+                    💨
+                </a>
+                {{end}}
+            </div>
+        </div>
+    </header>
+
+    {{if .Description}}
+    <p style="margin: 0.5rem 0; color: var(--pico-muted-color);">{{.TruncatedDescription 150}}</p>
+    {{end}}
+
+    <div class="event-meta">
+        {{if .StartsAt}}
+        <div class="event-time">
+            <strong>📅 Starts:</strong>
+            <time class="utc-time" datetime="{{.StartsAt.Format "2006-01-02T15:04:05Z07:00"}}">
+                {{.StartsAt.Format "2006-01-02T15:04:05Z07:00"}}
+            </time>
+        </div>
+        {{end}}
+
+        {{if .EndsAt}}
+        <div class="event-time">
+            <strong>🏁 Ends:</strong>
+            <time class="utc-time" datetime="{{.EndsAt.Format "2006-01-02T15:04:05Z07:00"}}">
+                {{.EndsAt.Format "2006-01-02T15:04:05Z07:00"}}
+            </time>
+        </div>
+        {{end}}
+
+        {{if .Mode}}
+        <div class="event-mode">
+            {{if eq .Mode "virtual"}}
+                <strong>💻 Mode:</strong> Virtual
+            {{else if eq .Mode "in-person"}}
+                <strong>📍 Mode:</strong> In Person
+            {{else if eq .Mode "hybrid"}}
+                <strong>🔄 Mode:</strong> Hybrid
+            {{end}}
+        </div>
+        {{end}}
+
+        {{if .Locations}}
+        <div class="event-locations">
+            <strong>📍 Location{{if gt (len .Locations) 1}}s{{end}}:</strong>
+            {{range $i, $loc := .Locations}}
+                {{if $i}}, {{end}}
+                {{if $loc.Name}}{{$loc.Name}}{{else if $loc.Address}}{{$loc.Address}}{{end}}
+            {{end}}
+        </div>
+        {{end}}
+    </div>
+
+    <div class="event-actions" style="margin-top: 0.75rem;">
+        <button type="button" class="secondary" style="padding: 0.25rem 0.75rem; margin: 0;" onclick="viewEventDetails('{{.RKey}}')">
+            View Details
+        </button>
+    </div>
+</article>
+{{end}}

templates/partials/calendar-event-modal.html

···
+{{define "calendar-event-modal.html"}}
+<!-- Event Detail Modal -->
+<dialog id="event-detail-modal">
+    <article style="width: 90vw; max-width: 600px;">
+        <header>
+            <button aria-label="Close" rel="prev" onclick="document.getElementById('event-detail-modal').close()"></button>
+            <div style="display: flex; justify-content: space-between; align-items: center; gap: 1rem;">
+                <h3 id="event-modal-title" style="margin: 0; flex: 1;"></h3>
+                <a id="event-modal-smokesignal-link" href="#" target="_blank" rel="noopener noreferrer" title="View on Smokesignal" style="display: none; flex-shrink: 0; text-decoration: none; font-size: 24px;">
+                    💨
+                </a>
+            </div>
+        </header>
+
+        <div id="event-modal-content">
+            <!-- Status Badge -->
+            <div id="event-modal-status" style="margin-bottom: 1rem;"></div>
+
+            <!-- Description -->
+            <div id="event-modal-description" style="margin-bottom: 1rem; color: var(--pico-muted-color);"></div>
+
+            <!-- Date/Time Information -->
+            <div id="event-modal-times" style="margin-bottom: 1rem;">
+                <div id="event-modal-starts" class="event-time" style="margin-bottom: 0.5rem;"></div>
+                <div id="event-modal-ends" class="event-time"></div>
+            </div>
+
+            <!-- Mode -->
+            <div id="event-modal-mode" style="margin-bottom: 1rem;"></div>
+
+            <!-- Locations -->
+            <div id="event-modal-locations" style="margin-bottom: 1rem;"></div>
+
+            <!-- URIs/Links -->
+            <div id="event-modal-uris" style="margin-bottom: 1rem;"></div>
+
+            <!-- RSVP Information -->
+            <div id="event-modal-rsvps" style="margin-top: 1.5rem; padding-top: 1rem; border-top: 1px solid var(--pico-muted-border-color);">
+                <h4 style="margin-top: 0;">RSVPs</h4>
+                <div id="event-rsvp-list">
+                    <p style="color: var(--pico-muted-color); font-style: italic;">Loading RSVPs...</p>
+                </div>
+            </div>
+
+            <!-- Created Date -->
+            <div id="event-modal-created" style="margin-top: 1.5rem; font-size: 0.875rem; color: var(--pico-muted-color);"></div>
+        </div>
+
+        <footer>
+            <button class="secondary" onclick="document.getElementById('event-detail-modal').close()">Close</button>
+        </footer>
+    </article>
+</dialog>
+{{end}}