diff --git a/docs/superpowers/plans/2026-04-10-nextcloud-calendar-sync.md b/docs/superpowers/plans/2026-04-10-nextcloud-calendar-sync.md
new file mode 100644
index 0000000..b7eca7c
--- /dev/null
+++ b/docs/superpowers/plans/2026-04-10-nextcloud-calendar-sync.md
@@ -0,0 +1,1614 @@
+# Nextcloud Calendar Sync Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add Nextcloud CalDAV as a second calendar sync target alongside Google Calendar, with shared base logic extracted into a common interface and static helper.
+
+**Architecture:** A new `ICalendarService` interface unifies both providers. A static `CalendarEventBuilder` holds shared pure logic (event content building, transport formatting, retry). `GoogleCalendarService` and `NextcloudCalendarService` each implement a marker interface extending `ICalendarService`. The controller routes to the right service based on a `provider` query/body parameter.
+
+**Tech Stack:** .NET 9, ASP.NET Core, Blazor WASM, Google.Apis.Calendar.v3 (existing), Ical.Net (existing), CalDAV over HttpClient, System.Xml.Linq for CalDAV XML parsing.
+
+**Design spec:** `docs/superpowers/specs/2026-04-10-nextcloud-calendar-sync-design.md`
+
+---
+
+## File Map
+
+| Action | File | Responsibility |
+|--------|------|----------------|
+| Create | `Shared/CalendarInfo.cs` | Shared DTO replacing `GoogleCalendar` |
+| Modify | `Shared/GoogleCalendar.cs` | Empty out (class renamed to `CalendarInfo`) |
+| Create | `Services/ICalendarService.cs` | Shared interface + marker interfaces |
+| Create | `Services/CalendarEventBuilder.cs` | Pure helpers: event content, transport format, retry |
+| Modify | `Services/GoogleCalendarService.cs` | Implement `IGoogleCalendarService`, use `CalendarEventBuilder` |
+| Create | `Services/NextcloudCalendarService.cs` | CalDAV implementation of `INextcloudCalendarService` |
+| Modify | `Server/appsettings.json` | Add `Nextcloud` config section with dummy values |
+| Modify | `Server/Program.cs` | Register `NextcloudCalendarService`, `IHttpClientFactory` already present |
+| Modify | `Server/Controllers/ShiftController.cs` | New provider-agnostic endpoints |
+| Modify | `Client/Pages/Index.razor.cs` | Nextcloud sync flow, rename `GoogleCalendar` → `CalendarInfo` |
+| Modify | `Client/Pages/Index.razor` | Add Nextcloud button, dynamic modal title |
+| Modify | `DOCKER_CONFIG.md` | Document Nextcloud config section |
+| Create | `ShiftScheduler.Services.Tests/CalendarEventBuilderTests.cs` | Unit tests for `CalendarEventBuilder` |
+
+---
+
+## Task 1: Add `CalendarInfo` shared DTO
+
+**Files:**
+- Create: `Shared/CalendarInfo.cs`
+- Modify: `Shared/GoogleCalendar.cs`
+
+- [ ] **Step 1: Create `Shared/CalendarInfo.cs`**
+
+```csharp
+namespace ShiftScheduler.Shared;
+
+public class CalendarInfo
+{
+    public string Id { get; set; } = string.Empty;
+    public string Summary { get; set; } = string.Empty;
+}
+```
+
+- [ ] **Step 2: Empty out `Shared/GoogleCalendar.cs`**
+
+Replace entire file content with:
+
+```csharp
+// Class renamed to CalendarInfo — see Shared/CalendarInfo.cs
+namespace ShiftScheduler.Shared;
+```
+
+- [ ] **Step 3: Verify build**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build
+```
+
+Expected: Build succeeds (no code uses `GoogleCalendar` yet — references are updated in later tasks).
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add Shared/CalendarInfo.cs Shared/GoogleCalendar.cs
+git commit -m "feat: add CalendarInfo shared DTO, retire GoogleCalendar"
+```
+
+---
+
+## Task 2: Create `ICalendarService` interface
+
+**Files:**
+- Create: `Services/ICalendarService.cs`
+
+- [ ] **Step 1: Create `Services/ICalendarService.cs`**
+
+```csharp
+using ShiftScheduler.Shared;
+
+namespace ShiftScheduler.Services;
+
+public interface ICalendarService
+{
+    Task<List<CalendarInfo>> GetCalendarsAsync();
+    Task SyncShiftsToCalendarAsync(string calendarId, List<ShiftWithTransport> shifts);
+}
+
+/// <summary>Marker interface for DI disambiguation.</summary>
+public interface IGoogleCalendarService : ICalendarService { }
+
+/// <summary>Marker interface for DI disambiguation.</summary>
+public interface INextcloudCalendarService : ICalendarService { }
+```
+
+- [ ] **Step 2: Verify build**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build
+```
+
+Expected: Build succeeds.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add Services/ICalendarService.cs
+git commit -m "feat: add ICalendarService interface and marker interfaces"
+```
+
+---
+
+## Task 3: Create `CalendarEventBuilder` with tests
+
+**Files:**
+- Create: `ShiftScheduler.Services.Tests/CalendarEventBuilderTests.cs`
+- Create: `Services/CalendarEventBuilder.cs`
+
+- [ ] **Step 1: Write failing tests**
+
+Create `ShiftScheduler.Services.Tests/CalendarEventBuilderTests.cs`:
+
+```csharp
+using ShiftScheduler.Services;
+using ShiftScheduler.Shared;
+using Shouldly;
+
+namespace ShiftScheduler.Services.Tests;
+
+public class CalendarEventBuilderTests
+{
+    [Fact]
+    public void BuildEventContent_WithTransport_IncludesTransportInDescription()
+    {
+        var shift = new Shift { Name = "Früh" };
+        var transport = new TransportConnection
+        {
+            Platform = "Gleis 3",
+            DepartureTime = DateTimeOffset.Parse("2026-04-01T05:30:00+02:00"),
+            ArrivalTime = DateTimeOffset.Parse("2026-04-01T05:55:00+02:00"),
+            Duration = TimeSpan.FromMinutes(25)
+        };
+
+        var result = CalendarEventBuilder.BuildEventContent(shift, transport);
+
+        result.Summary.ShouldBe("Früh");
+        result.Description.ShouldBe("Transport: Gleis 3: 05:30 → 05:55 (25 Minutes)");
+    }
+
+    [Fact]
+    public void BuildEventContent_WithoutTransport_EmptyDescription()
+    {
+        var shift = new Shift { Name = "Spät" };
+
+        var result = CalendarEventBuilder.BuildEventContent(shift, null);
+
+        result.Summary.ShouldBe("Spät");
+        result.Description.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void FormatTransportInfo_FormatsCorrectly()
+    {
+        var transport = new TransportConnection
+        {
+            Platform = "Gleis 3",
+            DepartureTime = DateTimeOffset.Parse("2026-04-01T05:30:00+02:00"),
+            ArrivalTime = DateTimeOffset.Parse("2026-04-01T05:55:00+02:00"),
+            Duration = TimeSpan.FromMinutes(25)
+        };
+
+        var result = CalendarEventBuilder.FormatTransportInfo(transport);
+
+        result.ShouldBe("Gleis 3: 05:30 → 05:55 (25 Minutes)");
+    }
+
+    [Fact]
+    public void FormatTransportInfo_WithNullPlatform_UsesEmptyString()
+    {
+        var transport = new TransportConnection
+        {
+            Platform = null,
+            DepartureTime = DateTimeOffset.Parse("2026-04-01T05:30:00+02:00"),
+            ArrivalTime = DateTimeOffset.Parse("2026-04-01T05:55:00+02:00"),
+            Duration = TimeSpan.FromMinutes(25)
+        };
+
+        var result = CalendarEventBuilder.FormatTransportInfo(transport);
+
+        result.ShouldBe(": 05:30 → 05:55 (25 Minutes)");
+    }
+}
+```
+
+- [ ] **Step 2: Run tests to confirm they fail**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet test ShiftScheduler.Services.Tests/ --filter "CalendarEventBuilderTests" -v minimal
+```
+
+Expected: Build error — `CalendarEventBuilder` does not exist yet.
+
+- [ ] **Step 3: Create `Services/CalendarEventBuilder.cs`**
+
+```csharp
+using ShiftScheduler.Shared;
+
+namespace ShiftScheduler.Services;
+
+public record CalendarEventData(string Summary, string Description);
+
+public static class CalendarEventBuilder
+{
+    public static CalendarEventData BuildEventContent(Shift shift, TransportConnection? transport)
+    {
+        var description = transport != null
+            ? $"Transport: {FormatTransportInfo(transport)}"
+            : string.Empty;
+        return new CalendarEventData(shift.Name, description);
+    }
+
+    public static string FormatTransportInfo(TransportConnection transport)
+    {
+        var departure = transport.DepartureTime.ToString("HH:mm");
+        var arrival = transport.ArrivalTime.ToString("HH:mm");
+        return $"{transport.Platform}: {departure} → {arrival} ({transport.Duration.TotalMinutes} Minutes)";
+    }
+
+    public static async Task<T> ExecuteWithRetryAsync<T>(Func<Task<T>> operation, int maxRetries = 3)
+    {
+        var delay = TimeSpan.FromSeconds(1);
+
+        for (var attempt = 0; attempt <= maxRetries; attempt++)
+        {
+            try
+            {
+                return await operation();
+            }
+            catch (HttpRequestException ex) when (ex.Message.Contains("429") && attempt < maxRetries)
+            {
+                await Task.Delay(delay);
+                delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2);
+            }
+            catch (Exception ex) when (ex.Message.Contains("Rate Limit") && attempt < maxRetries)
+            {
+                await Task.Delay(delay);
+                delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2);
+            }
+            catch (Exception ex) when (ex.Message.Contains("Forbidden") && ex.Message.Contains("quota") && attempt < maxRetries)
+            {
+                await Task.Delay(delay);
+                delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2);
+            }
+        }
+
+        return await operation();
+    }
+}
+```
+
+- [ ] **Step 4: Run tests to confirm they pass**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet test ShiftScheduler.Services.Tests/ --filter "CalendarEventBuilderTests" -v minimal
+```
+
+Expected: 4 tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add Services/CalendarEventBuilder.cs ShiftScheduler.Services.Tests/CalendarEventBuilderTests.cs
+git commit -m "feat: add CalendarEventBuilder with shared event/transport logic"
+```
+
+---
+
+## Task 4: Refactor `GoogleCalendarService`
+
+**Files:**
+- Modify: `Services/GoogleCalendarService.cs`
+
+The refactoring:
+1. Change implemented interface from `IGoogleCalendarService` (old, deleted) to the new `IGoogleCalendarService : ICalendarService`
+2. Change `GetCalendarsAsync()` return type from `List<CalendarListEntry>` to `List<CalendarInfo>`
+3. Replace `FormatTransportInfo` and the summary/description building with `CalendarEventBuilder`
+4. Replace the private `ExecuteWithRetryAsync` with `CalendarEventBuilder.ExecuteWithRetryAsync`
+
+- [ ] **Step 1: Replace `Services/GoogleCalendarService.cs`**
+
+```csharp
+using Google.Apis.Auth.OAuth2;
+using Google.Apis.Calendar.v3;
+using Google.Apis.Calendar.v3.Data;
+using Google.Apis.Services;
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Http;
+using ShiftScheduler.Shared;
+
+namespace ShiftScheduler.Services;
+
+public class GoogleCalendarService(IHttpContextAccessor httpContextAccessor, IConfigurationService configurationService)
+    : IGoogleCalendarService
+{
+    public async Task<List<CalendarInfo>> GetCalendarsAsync()
+    {
+        var service = await CreateCalendarServiceAsync();
+        var request = service.CalendarList.List();
+        var response = await CalendarEventBuilder.ExecuteWithRetryAsync(async () => await request.ExecuteAsync());
+
+        return response.Items?
+            .Where(c => c.AccessRole == "owner" || c.AccessRole == "writer")
+            .Select(c => new CalendarInfo { Id = c.Id, Summary = c.Summary })
+            .ToList() ?? [];
+    }
+
+    public async Task SyncShiftsToCalendarAsync(string calendarId, List<ShiftWithTransport> shifts)
+    {
+        var service = await CreateCalendarServiceAsync();
+
+        if (shifts.Count == 0) return;
+
+        var minDate = shifts.Min(s => s.Date).Date;
+        var maxDate = shifts.Max(s => s.Date).Date.AddDays(1);
+
+        await DeleteExistingShiftEventsAsync(service, calendarId, minDate, maxDate);
+        await Task.Delay(500);
+        await CreateShiftEventsWithRateLimitingAsync(service, calendarId, shifts);
+    }
+
+    private async Task DeleteExistingShiftEventsAsync(CalendarService service, string calendarId, DateTime startDate, DateTime endDate)
+    {
+        var request = service.Events.List(calendarId);
+        request.TimeMinDateTimeOffset = startDate;
+        request.TimeMaxDateTimeOffset = endDate;
+        request.SingleEvents = true;
+        request.OrderBy = EventsResource.ListRequest.OrderByEnum.StartTime;
+
+        var response = await CalendarEventBuilder.ExecuteWithRetryAsync(async () => await request.ExecuteAsync());
+
+        if (response.Items != null)
+        {
+            var shiftsToDelete = response.Items
+                .Where(e => e.ExtendedProperties?.Private__?.ContainsKey("shiftSchedulerEvent") == true)
+                .ToList();
+
+            foreach (var eventToDelete in shiftsToDelete)
+            {
+                await CalendarEventBuilder.ExecuteWithRetryAsync(async () =>
+                {
+                    await service.Events.Delete(calendarId, eventToDelete.Id).ExecuteAsync();
+                    return true;
+                });
+
+                if (shiftsToDelete.Count > 1)
+                    await Task.Delay(200);
+            }
+        }
+    }
+
+    private async Task CreateShiftEventsWithRateLimitingAsync(CalendarService service, string calendarId, List<ShiftWithTransport> shifts)
+    {
+        foreach (var shiftWithTransport in shifts)
+        {
+            await CreateShiftEventsAsync(service, calendarId, shiftWithTransport);
+
+            if (shifts.Count > 1)
+                await Task.Delay(300);
+        }
+    }
+
+    private async Task CreateShiftEventsAsync(CalendarService service, string calendarId, ShiftWithTransport shiftWithTransport)
+    {
+        var shift = shiftWithTransport.Shift;
+        var date = shiftWithTransport.Date;
+
+        if (string.IsNullOrEmpty(shift.MorningTime) && string.IsNullOrEmpty(shift.AfternoonTime))
+            return;
+
+        if (!string.IsNullOrEmpty(shift.MorningTime))
+        {
+            var (startTime, endTime) = configurationService.GetZurichTime(DateOnly.FromDateTime(date), shift.MorningTime);
+            var eventData = CalendarEventBuilder.BuildEventContent(shift, shiftWithTransport.MorningTransport);
+            var googleEvent = CreateGoogleEvent(eventData, startTime, endTime);
+            await CalendarEventBuilder.ExecuteWithRetryAsync(async () => await service.Events.Insert(googleEvent, calendarId).ExecuteAsync());
+        }
+
+        if (!string.IsNullOrEmpty(shift.AfternoonTime))
+        {
+            var (startTime, endTime) = configurationService.GetZurichTime(DateOnly.FromDateTime(date), shift.AfternoonTime);
+            var eventData = CalendarEventBuilder.BuildEventContent(shift, shiftWithTransport.AfternoonTransport);
+            var googleEvent = CreateGoogleEvent(eventData, startTime, endTime);
+            await CalendarEventBuilder.ExecuteWithRetryAsync(async () => await service.Events.Insert(googleEvent, calendarId).ExecuteAsync());
+        }
+    }
+
+    private static Event CreateGoogleEvent(CalendarEventData eventData, DateTimeOffset startTime, DateTimeOffset endTime)
+    {
+        return new Event
+        {
+            Summary = eventData.Summary,
+            Description = eventData.Description,
+            Start = new EventDateTime { DateTimeDateTimeOffset = startTime },
+            End = new EventDateTime { DateTimeDateTimeOffset = endTime },
+            ExtendedProperties = new Event.ExtendedPropertiesData
+            {
+                Private__ = new Dictionary<string, string>
+                {
+                    ["shiftSchedulerEvent"] = "true",
+                    ["shiftName"] = eventData.Summary
+                }
+            }
+        };
+    }
+
+    private async Task<CalendarService> CreateCalendarServiceAsync()
+    {
+        var httpContext = httpContextAccessor.HttpContext ?? throw new InvalidOperationException("No HTTP context available");
+
+        var accessToken = await httpContext.GetTokenAsync("access_token");
+        if (string.IsNullOrEmpty(accessToken))
+            throw new UnauthorizedAccessException("No access token available");
+
+        var credential = GoogleCredential.FromAccessToken(accessToken);
+
+        return new CalendarService(new BaseClientService.Initializer
+        {
+            HttpClientInitializer = credential,
+            ApplicationName = "ShiftScheduler"
+        });
+    }
+}
+```
+
+- [ ] **Step 2: Build and run all tests**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build && dotnet test ShiftScheduler.Services.Tests/ -v minimal
+```
+
+Expected: Build succeeds, all tests pass.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add Services/GoogleCalendarService.cs
+git commit -m "refactor: GoogleCalendarService implements ICalendarService, uses CalendarEventBuilder"
+```
+
+---
+
+## Task 5: Add Nextcloud configuration
+
+**Files:**
+- Modify: `Server/appsettings.json`
+- Modify: `DOCKER_CONFIG.md`
+
+- [ ] **Step 1: Add Nextcloud section to `Server/appsettings.json`**
+
+Add after the `"Authentication"` block:
+
+```json
+"Nextcloud": {
+  "BaseUrl": "https://your-nextcloud-instance.example.com",
+  "Username": "YOUR_NEXTCLOUD_USERNAME",
+  "AppPassword": "YOUR_NEXTCLOUD_APP_PASSWORD"
+},
+```
+
+The full `Authentication` + `Nextcloud` section in `appsettings.json` should look like:
+
+```json
+"Authentication": {
+  "Google": {
+    "ClientId": "YOUR_GOOGLE_CLIENT_ID",
+    "ClientSecret": "YOUR_GOOGLE_CLIENT_SECRET"
+  },
+  "AuthorizedEmails": [
+    "example1@gmail.com",
+    "example2@gmail.com"
+  ]
+},
+
+"Nextcloud": {
+  "BaseUrl": "https://your-nextcloud-instance.example.com",
+  "Username": "YOUR_NEXTCLOUD_USERNAME",
+  "AppPassword": "YOUR_NEXTCLOUD_APP_PASSWORD"
+},
+```
+
+- [ ] **Step 2: Update `DOCKER_CONFIG.md`**
+
+Add a new section at the end of the file:
+
+```markdown
+## Nextcloud Calendar Sync
+
+To enable Nextcloud CalDAV sync, populate the `Nextcloud` section in the production `appsettings.json` (not committed to git):
+
+```json
+"Nextcloud": {
+  "BaseUrl": "https://your-nextcloud-instance.example.com",
+  "Username": "your-nextcloud-username",
+  "AppPassword": "your-nextcloud-app-password"
+}
+```
+
+Generate an app password in Nextcloud: **Settings → Security → Devices & sessions → Create new app password**.
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add Server/appsettings.json DOCKER_CONFIG.md
+git commit -m "feat: add Nextcloud config placeholder and Docker docs"
+```
+
+---
+
+## Task 6: Implement `NextcloudCalendarService`
+
+**Files:**
+- Create: `Services/NextcloudCalendarService.cs`
+
+- [ ] **Step 1: Create `Services/NextcloudCalendarService.cs`**
+
+```csharp
+using Ical.Net;
+using Ical.Net.CalendarComponents;
+using Ical.Net.DataTypes;
+using Ical.Net.Serialization;
+using Microsoft.Extensions.Configuration;
+using ShiftScheduler.Shared;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Xml.Linq;
+
+namespace ShiftScheduler.Services;
+
+public class NextcloudCalendarService(
+    IConfiguration configuration,
+    IHttpClientFactory httpClientFactory,
+    IConfigurationService configurationService) : INextcloudCalendarService
+{
+    private readonly string _baseUrl = configuration["Nextcloud:BaseUrl"]
+        ?? throw new InvalidOperationException("Nextcloud:BaseUrl not configured");
+    private readonly string _username = configuration["Nextcloud:Username"]
+        ?? throw new InvalidOperationException("Nextcloud:Username not configured");
+    private readonly string _appPassword = configuration["Nextcloud:AppPassword"]
+        ?? throw new InvalidOperationException("Nextcloud:AppPassword not configured");
+
+    private static readonly XNamespace DavNs = "DAV:";
+    private static readonly XNamespace CalDavNs = "urn:ietf:params:xml:ns:caldav";
+
+    public async Task<List<CalendarInfo>> GetCalendarsAsync()
+    {
+        var path = $"/remote.php/dav/calendars/{_username}/";
+        var body = """
+            <?xml version="1.0" encoding="utf-8" ?>
+            <D:propfind xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
+              <D:prop>
+                <D:displayname/>
+                <D:resourcetype/>
+              </D:prop>
+            </D:propfind>
+            """;
+
+        var request = CreateRequest(HttpMethod.Parse("PROPFIND"), path);
+        request.Headers.Add("Depth", "1");
+        request.Content = new StringContent(body, Encoding.UTF8, "application/xml");
+
+        var client = httpClientFactory.CreateClient();
+        var response = await client.SendAsync(request);
+        response.EnsureSuccessStatusCode();
+
+        var xml = await response.Content.ReadAsStringAsync();
+        return ParseCalendarsFromPropfind(xml);
+    }
+
+    public async Task SyncShiftsToCalendarAsync(string calendarId, List<ShiftWithTransport> shifts)
+    {
+        if (shifts.Count == 0) return;
+
+        var minDate = shifts.Min(s => s.Date).Date;
+        var maxDate = shifts.Max(s => s.Date).Date.AddDays(1);
+
+        await DeleteExistingShiftEventsAsync(calendarId, minDate, maxDate);
+        await Task.Delay(500);
+        await CreateShiftEventsAsync(calendarId, shifts);
+    }
+
+    private List<CalendarInfo> ParseCalendarsFromPropfind(string xml)
+    {
+        var doc = XDocument.Parse(xml);
+        var calendars = new List<CalendarInfo>();
+
+        foreach (var responseElement in doc.Descendants(DavNs + "response"))
+        {
+            var resourceType = responseElement.Descendants(DavNs + "resourcetype").FirstOrDefault();
+            if (resourceType?.Element(CalDavNs + "calendar") == null)
+                continue;
+
+            var href = responseElement.Element(DavNs + "href")?.Value ?? string.Empty;
+            if (string.IsNullOrEmpty(href)) continue;
+
+            var displayName = responseElement.Descendants(DavNs + "displayname").FirstOrDefault()?.Value ?? href;
+
+            calendars.Add(new CalendarInfo { Id = href, Summary = displayName });
+        }
+
+        return calendars;
+    }
+
+    private async Task DeleteExistingShiftEventsAsync(string calendarId, DateTime startDate, DateTime endDate)
+    {
+        var startUtc = startDate.ToUniversalTime().ToString("yyyyMMddTHHmmssZ");
+        var endUtc = endDate.ToUniversalTime().ToString("yyyyMMddTHHmmssZ");
+
+        var body = $"""
+            <?xml version="1.0" encoding="utf-8" ?>
+            <C:calendar-query xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav">
+              <D:prop>
+                <D:getetag/>
+                <C:calendar-data/>
+              </D:prop>
+              <C:filter>
+                <C:comp-filter name="VCALENDAR">
+                  <C:comp-filter name="VEVENT">
+                    <C:time-range start="{startUtc}" end="{endUtc}"/>
+                  </C:comp-filter>
+                </C:comp-filter>
+              </C:filter>
+            </C:calendar-query>
+            """;
+
+        var reportRequest = CreateRequest(HttpMethod.Parse("REPORT"), calendarId);
+        reportRequest.Headers.Add("Depth", "1");
+        reportRequest.Content = new StringContent(body, Encoding.UTF8, "application/xml");
+
+        var client = httpClientFactory.CreateClient();
+        var reportResponse = await client.SendAsync(reportRequest);
+        reportResponse.EnsureSuccessStatusCode();
+
+        var xml = await reportResponse.Content.ReadAsStringAsync();
+        var eventUrls = ParseShiftEventUrls(xml);
+
+        foreach (var url in eventUrls)
+        {
+            var deleteRequest = CreateRequest(HttpMethod.Delete, url);
+            var deleteResponse = await client.SendAsync(deleteRequest);
+
+            if (!deleteResponse.IsSuccessStatusCode &&
+                deleteResponse.StatusCode != System.Net.HttpStatusCode.NotFound)
+                deleteResponse.EnsureSuccessStatusCode();
+
+            if (eventUrls.Count > 1)
+                await Task.Delay(200);
+        }
+    }
+
+    private List<string> ParseShiftEventUrls(string xml)
+    {
+        var doc = XDocument.Parse(xml);
+        var urls = new List<string>();
+
+        foreach (var responseElement in doc.Descendants(DavNs + "response"))
+        {
+            var calendarData = responseElement
+                .Descendants(CalDavNs + "calendar-data")
+                .FirstOrDefault()?.Value;
+
+            if (calendarData == null || !calendarData.Contains("X-SHIFT-SCHEDULER:TRUE"))
+                continue;
+
+            var href = responseElement.Element(DavNs + "href")?.Value;
+            if (!string.IsNullOrEmpty(href))
+                urls.Add(href);
+        }
+
+        return urls;
+    }
+
+    private async Task CreateShiftEventsAsync(string calendarId, List<ShiftWithTransport> shifts)
+    {
+        var client = httpClientFactory.CreateClient();
+
+        foreach (var shiftWithTransport in shifts)
+        {
+            var shift = shiftWithTransport.Shift;
+            var date = shiftWithTransport.Date;
+
+            if (string.IsNullOrEmpty(shift.MorningTime) && string.IsNullOrEmpty(shift.AfternoonTime))
+                continue;
+
+            if (!string.IsNullOrEmpty(shift.MorningTime))
+            {
+                var (startTime, endTime) = configurationService.GetZurichTime(
+                    DateOnly.FromDateTime(date), shift.MorningTime);
+                var uid = $"shift-{SanitizeForUid(shift.Name)}-{date:yyyyMMdd}-morning";
+                var eventData = CalendarEventBuilder.BuildEventContent(shift, shiftWithTransport.MorningTransport);
+                var icsContent = BuildIcsContent(uid, eventData, startTime, endTime);
+
+                var putRequest = CreateRequest(HttpMethod.Put, $"{calendarId}{Uri.EscapeDataString(uid)}.ics");
+                putRequest.Content = new StringContent(icsContent, Encoding.UTF8, "text/calendar");
+                (await client.SendAsync(putRequest)).EnsureSuccessStatusCode();
+            }
+
+            if (!string.IsNullOrEmpty(shift.AfternoonTime))
+            {
+                var (startTime, endTime) = configurationService.GetZurichTime(
+                    DateOnly.FromDateTime(date), shift.AfternoonTime);
+                var uid = $"shift-{SanitizeForUid(shift.Name)}-{date:yyyyMMdd}-afternoon";
+                var eventData = CalendarEventBuilder.BuildEventContent(shift, shiftWithTransport.AfternoonTransport);
+                var icsContent = BuildIcsContent(uid, eventData, startTime, endTime);
+
+                var putRequest = CreateRequest(HttpMethod.Put, $"{calendarId}{Uri.EscapeDataString(uid)}.ics");
+                putRequest.Content = new StringContent(icsContent, Encoding.UTF8, "text/calendar");
+                (await client.SendAsync(putRequest)).EnsureSuccessStatusCode();
+            }
+
+            if (shifts.Count > 1)
+                await Task.Delay(300);
+        }
+    }
+
+    private static string BuildIcsContent(string uid, CalendarEventData eventData, DateTimeOffset startTime, DateTimeOffset endTime)
+    {
+        var calendar = new Calendar();
+        var vevent = new CalendarEvent
+        {
+            Uid = uid,
+            Summary = eventData.Summary,
+            Description = eventData.Description,
+            DtStart = new CalDateTime(startTime.UtcDateTime) { IsUniversalTime = true },
+            DtEnd = new CalDateTime(endTime.UtcDateTime) { IsUniversalTime = true }
+        };
+        vevent.Properties.Add(new Ical.Net.CalendarProperty("X-SHIFT-SCHEDULER", "TRUE"));
+        calendar.Events.Add(vevent);
+        return new CalendarSerializer().SerializeToString(calendar);
+    }
+
+    private static string SanitizeForUid(string name)
+    {
+        return new string(name.Select(c => char.IsLetterOrDigit(c) ? c : '-').ToArray());
+    }
+
+    private HttpRequestMessage CreateRequest(HttpMethod method, string path)
+    {
+        // path may be a URL-path from a CalDAV href ("/remote.php/...") or a full URL
+        var uri = path.StartsWith("http", StringComparison.OrdinalIgnoreCase)
+            ? new Uri(path)
+            : new Uri($"{_baseUrl.TrimEnd('/')}{path}");
+
+        var request = new HttpRequestMessage(method, uri);
+        var credentials = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{_username}:{_appPassword}"));
+        request.Headers.Authorization = new AuthenticationHeaderValue("Basic", credentials);
+        return request;
+    }
+}
+```
+
+- [ ] **Step 2: Build**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build
+```
+
+Expected: Build succeeds.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add Services/NextcloudCalendarService.cs
+git commit -m "feat: implement NextcloudCalendarService with CalDAV"
+```
+
+---
+
+## Task 7: Update `Program.cs` and `ShiftController`
+
+**Files:**
+- Modify: `Server/Program.cs`
+- Modify: `Server/Controllers/ShiftController.cs`
+
+- [ ] **Step 1: Update DI registration in `Server/Program.cs`**
+
+Replace the line:
+```csharp
+builder.Services.AddScoped<IGoogleCalendarService, GoogleCalendarService>();
+```
+
+With:
+```csharp
+builder.Services.AddScoped<IGoogleCalendarService, GoogleCalendarService>();
+builder.Services.AddScoped<INextcloudCalendarService, NextcloudCalendarService>();
+```
+
+Note: `IHttpClientFactory` is already registered by the existing `builder.Services.AddHttpClient<TransportApiService>();` call — no additional registration needed.
+
+- [ ] **Step 2: Update `Server/Controllers/ShiftController.cs`**
+
+Replace the full file with:
+
+```csharp
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using ShiftScheduler.Services;
+using ShiftScheduler.Shared;
+
+namespace ShiftScheduler.Server.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    [Authorize(Policy = "AllowedEmails")]
+    public class ShiftController : ControllerBase
+    {
+        private readonly IcsExportService _icsService;
+        private readonly PdfExportService _pdfExportService;
+        private readonly ITransportService _transportService;
+        private readonly IConfigurationService _configurationService;
+        private readonly IGoogleCalendarService _googleCalendarService;
+        private readonly INextcloudCalendarService _nextcloudCalendarService;
+
+        public ShiftController(
+            IcsExportService icsService,
+            PdfExportService pdfExportService,
+            ITransportService transportService,
+            IConfigurationService configurationService,
+            IGoogleCalendarService googleCalendarService,
+            INextcloudCalendarService nextcloudCalendarService)
+        {
+            _icsService = icsService;
+            _pdfExportService = pdfExportService;
+            _transportService = transportService;
+            _configurationService = configurationService;
+            _googleCalendarService = googleCalendarService;
+            _nextcloudCalendarService = nextcloudCalendarService;
+        }
+
+        [HttpGet("shifts")]
+        public IActionResult GetShifts()
+        {
+            return Ok(_configurationService.GetShifts());
+        }
+
+        [HttpPost("shift_transport")]
+        public async Task<IActionResult> GetShiftTransport([FromBody] ShiftTransportRequest request)
+        {
+            var shift = _configurationService.GetShifts().FirstOrDefault(s => s.Name == request.ShiftName);
+            if (shift == null)
+                return NotFound($"Shift '{request.ShiftName}' not found");
+
+            var transportConfig = _configurationService.GetTransportConfiguration();
+            TransportConnection? morningTransport = null;
+            TransportConnection? afternoonTransport = null;
+
+            var shifTimes = _configurationService.ParseShiftTimes(request.Date, shift);
+
+            if (!string.IsNullOrEmpty(shift.MorningTime) && shifTimes.MorningStart.HasValue)
+                morningTransport = await _transportService.GetConnectionAsync(shifTimes.MorningStart.Value);
+
+            if (!string.IsNullOrEmpty(shift.AfternoonTime))
+            {
+                var shouldLoad = true;
+
+                if (!string.IsNullOrEmpty(shift.MorningTime) && shifTimes.MorningEnd.HasValue && shifTimes.AfternoonStart.HasValue)
+                {
+                    var breakMinutes = (shifTimes.AfternoonStart.Value - shifTimes.MorningEnd.Value).TotalMinutes;
+                    shouldLoad = breakMinutes >= transportConfig.MinBreakMinutes;
+                }
+
+                if (shouldLoad && shifTimes.AfternoonStart.HasValue)
+                    afternoonTransport = await _transportService.GetConnectionAsync(shifTimes.AfternoonStart.Value);
+            }
+
+            return Ok(new ShiftWithTransport
+            {
+                Date = request.Date,
+                Shift = shift,
+                MorningTransport = morningTransport,
+                AfternoonTransport = afternoonTransport
+            });
+        }
+
+        [HttpPost("export_ics")]
+        public async Task<IActionResult> ExportIcs([FromBody] ExportRequest request)
+        {
+            var shiftsWithTransport = await BuildShiftsWithTransportAsync(request.Year, request.Month);
+            var ics = _icsService.GenerateIcs(shiftsWithTransport);
+            return File(System.Text.Encoding.UTF8.GetBytes(ics), "text/calendar", "schedule.ics");
+        }
+
+        [HttpPost("export_pdf")]
+        public async Task<IActionResult> ExportPdf([FromBody] ExportRequest request)
+        {
+            var shiftsWithTransport = await BuildShiftsWithTransportAsync(request.Year, request.Month);
+            var pdf = _pdfExportService.GenerateMonthlySchedulePdf(shiftsWithTransport);
+            return File(pdf, "application/pdf", "schedule.pdf");
+        }
+
+        [HttpPost("save_schedule")]
+        public async Task<IActionResult> SaveSchedule([FromBody] SaveScheduleRequest request)
+        {
+            try
+            {
+                await _configurationService.SaveScheduleAsync(request.Year, request.Month, request.Schedule);
+                return Ok();
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, $"Error saving schedule: {ex.Message}");
+            }
+        }
+
+        [HttpGet("load_schedule/{year}/{month}")]
+        public async Task<IActionResult> LoadSchedule(int year, int month)
+        {
+            try
+            {
+                var schedule = await _configurationService.LoadScheduleAsync(year, month);
+                return Ok(schedule);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, $"Error loading schedule: {ex.Message}");
+            }
+        }
+
+        [HttpDelete("delete_schedule/{year}/{month}")]
+        public async Task<IActionResult> DeleteSchedule(int year, int month)
+        {
+            try
+            {
+                await _configurationService.DeleteScheduleAsync(year, month);
+                return Ok();
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, $"Error deleting schedule: {ex.Message}");
+            }
+        }
+
+        [HttpGet("calendars")]
+        public async Task<IActionResult> GetCalendars([FromQuery] string provider)
+        {
+            try
+            {
+                ICalendarService service = provider == "nextcloud"
+                    ? _nextcloudCalendarService
+                    : _googleCalendarService;
+
+                var calendars = await service.GetCalendarsAsync();
+                return Ok(calendars);
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, $"Error retrieving calendars: {ex.Message}");
+            }
+        }
+
+        [HttpPost("sync_to_calendar")]
+        public async Task<IActionResult> SyncToCalendar([FromBody] SyncToCalendarRequest request)
+        {
+            try
+            {
+                var shiftsWithTransport = await BuildShiftsWithTransportAsync(request.Year, request.Month);
+
+                ICalendarService service = request.Provider == "nextcloud"
+                    ? _nextcloudCalendarService
+                    : _googleCalendarService;
+
+                await service.SyncShiftsToCalendarAsync(request.CalendarId, shiftsWithTransport);
+                return Ok(new { message = "Shifts synced successfully!" });
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, $"Error syncing to calendar: {ex.Message}");
+            }
+        }
+
+        private async Task<List<ShiftWithTransport>> BuildShiftsWithTransportAsync(int year, int month)
+        {
+            var schedule = await _configurationService.LoadScheduleAsync(year, month);
+            var shiftsWithTransport = new List<ShiftWithTransport>();
+            var transportConfig = _configurationService.GetTransportConfiguration();
+
+            foreach (var kvp in schedule)
+            {
+                var date = kvp.Key;
+                var shiftName = kvp.Value;
+
+                var shift = _configurationService.GetShifts().FirstOrDefault(s => s.Name == shiftName);
+                if (shift == null) continue;
+
+                var shiftTimes = _configurationService.ParseShiftTimes(date, shift);
+                TransportConnection? morningTransport = null;
+                TransportConnection? afternoonTransport = null;
+
+                if (!string.IsNullOrEmpty(shift.MorningTime) && shiftTimes.MorningStart.HasValue)
+                    morningTransport = await _transportService.GetConnectionAsync(shiftTimes.MorningStart.Value);
+
+                if (!string.IsNullOrEmpty(shift.AfternoonTime))
+                {
+                    var shouldLoad = true;
+
+                    if (!string.IsNullOrEmpty(shift.MorningTime) && shiftTimes.MorningEnd.HasValue && shiftTimes.AfternoonStart.HasValue)
+                    {
+                        var breakMinutes = (shiftTimes.AfternoonStart.Value - shiftTimes.MorningEnd.Value).TotalMinutes;
+                        shouldLoad = breakMinutes >= transportConfig.MinBreakMinutes;
+                    }
+
+                    if (shouldLoad && shiftTimes.AfternoonStart.HasValue)
+                        afternoonTransport = await _transportService.GetConnectionAsync(shiftTimes.AfternoonStart.Value);
+                }
+
+                shiftsWithTransport.Add(new ShiftWithTransport
+                {
+                    Date = date,
+                    Shift = shift,
+                    MorningTransport = morningTransport,
+                    AfternoonTransport = afternoonTransport
+                });
+            }
+
+            return shiftsWithTransport;
+        }
+    }
+
+    public class ShiftTransportRequest
+    {
+        public string ShiftName { get; set; } = string.Empty;
+        public DateTime Date { get; set; }
+    }
+
+    public class SaveScheduleRequest
+    {
+        public int Year { get; set; }
+        public int Month { get; set; }
+        public Dictionary<DateTime, string> Schedule { get; set; } = new();
+    }
+
+    public class ExportRequest
+    {
+        public int Year { get; set; }
+        public int Month { get; set; }
+    }
+
+    public class SyncToCalendarRequest
+    {
+        public string Provider { get; set; } = string.Empty;
+        public string CalendarId { get; set; } = string.Empty;
+        public int Year { get; set; }
+        public int Month { get; set; }
+    }
+}
+```
+
+- [ ] **Step 3: Build**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build
+```
+
+Expected: Build succeeds.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add Server/Program.cs Server/Controllers/ShiftController.cs
+git commit -m "feat: add provider-agnostic calendar endpoints, register NextcloudCalendarService"
+```
+
+---
+
+## Task 8: Update Blazor client
+
+**Files:**
+- Modify: `Client/Pages/Index.razor.cs`
+- Modify: `Client/Pages/Index.razor`
+
+- [ ] **Step 1: Replace `Client/Pages/Index.razor.cs`**
+
+Replace the full file:
+
+```csharp
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+using System.Net.Http.Json;
+using ShiftScheduler.Shared;
+
+namespace ShiftScheduler.Client.Pages
+{
+    public partial class Index : ComponentBase
+    {
+        [Inject] private HttpClient HttpClient { get; set; } = default!;
+        [Inject] private IJSRuntime JSRuntime { get; set; } = default!;
+        [Inject] private NavigationManager NavigationManager { get; set; } = default!;
+
+        private List<Shift> Shifts { get; set; } = new();
+        private Dictionary<DateTime, string> SelectedSchedule { get; set; } = new();
+        private Dictionary<DateTime, ShiftWithTransport> SelectedShiftsWithTransport { get; set; } = new();
+        private Dictionary<DateTime, bool> _isLoadingTransportPerDay { get; set; } = new();
+
+        private bool _isCurrentMonth = true;
+        private bool _isLoadingInitial = false;
+        private bool _showConfigDialog = false;
+        private bool _isSyncing = false;
+        private bool _showCalendarSelector = false;
+        private string _syncProvider = string.Empty;
+        private string _errorMessage = string.Empty;
+        private string _successMessage = string.Empty;
+        private List<CalendarInfo> _availableCalendars = new();
+
+        private MonthAndYear SelectedDate => _isCurrentMonth ? MonthAndYear.Current() : MonthAndYear.Next();
+
+        protected override async Task OnInitializedAsync()
+        {
+            _isLoadingInitial = true;
+
+            Shifts = await HttpClient.GetFromJsonAsync<List<Shift>>("api/shift/shifts") ?? new();
+
+            _isLoadingInitial = false;
+            StateHasChanged();
+
+            _ = Task.Run(async () =>
+            {
+                await LoadScheduleFromStorage();
+                await InvokeAsync(StateHasChanged);
+            });
+        }
+
+        private async Task SelectCurrentMonth()
+        {
+            _isCurrentMonth = true;
+            await LoadScheduleFromStorage();
+            StateHasChanged();
+        }
+
+        private async Task SelectNextMonth()
+        {
+            _isCurrentMonth = false;
+            await LoadScheduleFromStorage();
+            StateHasChanged();
+        }
+
+        private async Task SelectShift(DateTime day, string shiftName)
+        {
+            SelectedSchedule[day] = shiftName;
+
+            _isLoadingTransportPerDay[day] = true;
+            StateHasChanged();
+
+            try
+            {
+                var request = new { ShiftName = shiftName, Date = day };
+                var response = await HttpClient.PostAsJsonAsync("api/shift/shift_transport", request);
+
+                if (response.IsSuccessStatusCode)
+                {
+                    var shiftWithTransport = await response.Content.ReadFromJsonAsync<ShiftWithTransport>();
+                    if (shiftWithTransport != null)
+                        SelectedShiftsWithTransport[day] = shiftWithTransport;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error fetching transport data: {ex.Message}");
+                var shift = Shifts.FirstOrDefault(s => s.Name == shiftName);
+                if (shift != null)
+                {
+                    SelectedShiftsWithTransport[day] = new ShiftWithTransport
+                    {
+                        Date = day,
+                        Shift = shift,
+                        MorningTransport = null,
+                        AfternoonTransport = null
+                    };
+                }
+            }
+            finally
+            {
+                _isLoadingTransportPerDay[day] = false;
+                StateHasChanged();
+            }
+
+            await SaveScheduleToStorage();
+        }
+
+        private async Task ExportToIcs()
+        {
+            try
+            {
+                _errorMessage = string.Empty;
+                _successMessage = string.Empty;
+                StateHasChanged();
+
+                var request = new { Year = SelectedDate.Year, Month = SelectedDate.Month };
+                var response = await HttpClient.PostAsJsonAsync("api/shift/export_ics", request);
+
+                if (response.IsSuccessStatusCode)
+                {
+                    var bytes = await response.Content.ReadAsByteArrayAsync();
+                    var base64 = Convert.ToBase64String(bytes);
+                    var fileUrl = $"data:text/calendar;base64,{base64}";
+                    NavigationManager.NavigateTo(fileUrl, true);
+                    _successMessage = "ICS file exported successfully!";
+                }
+                else
+                {
+                    var errorContent = await response.Content.ReadAsStringAsync();
+                    _errorMessage = $"Failed to export ICS file: {response.StatusCode}. {errorContent}";
+                }
+            }
+            catch (Exception ex)
+            {
+                _errorMessage = $"Error exporting ICS file: {ex.Message}";
+            }
+
+            StateHasChanged();
+        }
+
+        private async Task ExportToPdf()
+        {
+            try
+            {
+                _errorMessage = string.Empty;
+                _successMessage = string.Empty;
+                StateHasChanged();
+
+                var request = new { Year = SelectedDate.Year, Month = SelectedDate.Month };
+                var response = await HttpClient.PostAsJsonAsync("api/shift/export_pdf", request);
+
+                if (response.IsSuccessStatusCode)
+                {
+                    var bytes = await response.Content.ReadAsByteArrayAsync();
+                    var base64 = Convert.ToBase64String(bytes);
+                    await JSRuntime.InvokeVoidAsync("downloadFile", $"Schedule {SelectedDate.Year}-{SelectedDate.Month:D2}.pdf", "application/pdf", base64);
+                    _successMessage = "PDF file exported successfully!";
+                }
+                else
+                {
+                    var errorContent = await response.Content.ReadAsStringAsync();
+                    _errorMessage = $"Failed to export PDF file: {response.StatusCode}. {errorContent}";
+                }
+            }
+            catch (Exception ex)
+            {
+                _errorMessage = $"Error exporting PDF file: {ex.Message}";
+            }
+
+            StateHasChanged();
+        }
+
+        private Task SyncToGoogleCalendar() => StartCalendarSync("google");
+        private Task SyncToNextcloud() => StartCalendarSync("nextcloud");
+
+        private async Task StartCalendarSync(string provider)
+        {
+            try
+            {
+                _errorMessage = string.Empty;
+                _successMessage = string.Empty;
+                _syncProvider = provider;
+                _isSyncing = true;
+                StateHasChanged();
+
+                var response = await HttpClient.GetAsync($"api/shift/calendars?provider={provider}");
+                if (response.IsSuccessStatusCode)
+                {
+                    _availableCalendars = await response.Content.ReadFromJsonAsync<List<CalendarInfo>>() ?? new();
+
+                    if (_availableCalendars.Count == 1)
+                    {
+                        await PerformCalendarSync(_availableCalendars[0].Id);
+                    }
+                    else if (_availableCalendars.Count > 1)
+                    {
+                        _showCalendarSelector = true;
+                    }
+                    else
+                    {
+                        _errorMessage = "No writable calendars found.";
+                    }
+                }
+                else
+                {
+                    var errorContent = await response.Content.ReadAsStringAsync();
+                    _errorMessage = $"Failed to retrieve calendars: {response.StatusCode}. {errorContent}";
+                }
+            }
+            catch (Exception ex)
+            {
+                _errorMessage = $"Error accessing calendar: {ex.Message}";
+            }
+            finally
+            {
+                _isSyncing = false;
+                StateHasChanged();
+            }
+        }
+
+        private async Task SelectCalendarAndSync(string calendarId)
+        {
+            _showCalendarSelector = false;
+            await PerformCalendarSync(calendarId);
+        }
+
+        private async Task PerformCalendarSync(string calendarId)
+        {
+            try
+            {
+                _isSyncing = true;
+                StateHasChanged();
+
+                var request = new
+                {
+                    Provider = _syncProvider,
+                    CalendarId = calendarId,
+                    Year = SelectedDate.Year,
+                    Month = SelectedDate.Month
+                };
+
+                var response = await HttpClient.PostAsJsonAsync("api/shift/sync_to_calendar", request);
+
+                if (response.IsSuccessStatusCode)
+                {
+                    _successMessage = "Shifts synced successfully!";
+                }
+                else
+                {
+                    var errorContent = await response.Content.ReadAsStringAsync();
+                    _errorMessage = $"Failed to sync: {response.StatusCode}. {errorContent}";
+                }
+            }
+            catch (Exception ex)
+            {
+                _errorMessage = $"Error syncing: {ex.Message}";
+            }
+            finally
+            {
+                _isSyncing = false;
+                StateHasChanged();
+            }
+        }
+
+        private void CloseCalendarSelector()
+        {
+            _showCalendarSelector = false;
+            _availableCalendars.Clear();
+            StateHasChanged();
+        }
+
+        private async Task SaveScheduleToStorage()
+        {
+            try
+            {
+                var request = new
+                {
+                    Year = SelectedDate.Year,
+                    Month = SelectedDate.Month,
+                    Schedule = SelectedSchedule
+                };
+
+                await HttpClient.PostAsJsonAsync("api/shift/save_schedule", request);
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+        }
+
+        private async Task LoadScheduleFromStorage()
+        {
+            try
+            {
+                var response = await HttpClient.GetAsync($"api/shift/load_schedule/{SelectedDate.Year}/{SelectedDate.Month}");
+
+                if (response.IsSuccessStatusCode)
+                {
+                    SelectedSchedule = await response.Content.ReadFromJsonAsync<Dictionary<DateTime, string>>() ?? new();
+                    await ReloadTransportDataForSchedule();
+                }
+                else
+                {
+                    SelectedSchedule = new Dictionary<DateTime, string>();
+                    SelectedShiftsWithTransport = new Dictionary<DateTime, ShiftWithTransport>();
+                }
+            }
+            catch (Exception)
+            {
+                SelectedSchedule = new Dictionary<DateTime, string>();
+                SelectedShiftsWithTransport = new Dictionary<DateTime, ShiftWithTransport>();
+            }
+        }
+
+        private async Task ReloadTransportDataForSchedule()
+        {
+            SelectedShiftsWithTransport.Clear();
+            _isLoadingTransportPerDay.Clear();
+
+            foreach (var kvp in SelectedSchedule)
+                _isLoadingTransportPerDay[kvp.Key] = true;
+
+            StateHasChanged();
+
+            var transportTasks = SelectedSchedule.Select(async kvp =>
+            {
+                var day = kvp.Key;
+                var shiftName = kvp.Value;
+
+                try
+                {
+                    var request = new { ShiftName = shiftName, Date = day };
+                    var response = await HttpClient.PostAsJsonAsync("api/shift/shift_transport", request);
+
+                    if (response.IsSuccessStatusCode)
+                    {
+                        var shiftWithTransport = await response.Content.ReadFromJsonAsync<ShiftWithTransport>();
+                        if (shiftWithTransport != null)
+                            SelectedShiftsWithTransport[day] = shiftWithTransport;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"Error reloading transport data for {day}: {ex.Message}");
+                    var shift = Shifts.FirstOrDefault(s => s.Name == shiftName);
+                    if (shift != null)
+                    {
+                        SelectedShiftsWithTransport[day] = new ShiftWithTransport
+                        {
+                            Date = day,
+                            Shift = shift,
+                            MorningTransport = null,
+                            AfternoonTransport = null
+                        };
+                    }
+                }
+                finally
+                {
+                    _isLoadingTransportPerDay[day] = false;
+                    await InvokeAsync(StateHasChanged);
+                }
+            }).ToArray();
+
+            await Task.WhenAll(transportTasks);
+        }
+
+        private async Task ResetSchedule()
+        {
+            SelectedSchedule.Clear();
+            SelectedShiftsWithTransport.Clear();
+
+            try
+            {
+                await HttpClient.DeleteAsync($"api/shift/delete_schedule/{SelectedDate.Year}/{SelectedDate.Month}");
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+        }
+
+        private string GetTransportSummary(DateTime date)
+        {
+            if (!SelectedShiftsWithTransport.TryGetValue(date, out var shiftWithTransport))
+                return string.Empty;
+
+            var summaries = new List<string>();
+
+            var morningTransport = shiftWithTransport.GetMorningTransportSummary();
+            if (!string.IsNullOrEmpty(morningTransport))
+                summaries.Add(morningTransport);
+
+            var afternoonTransport = shiftWithTransport.GetAfternoonTransportSummary();
+            if (!string.IsNullOrEmpty(afternoonTransport))
+                summaries.Add(afternoonTransport);
+
+            if (summaries.Count == 0) return string.Empty;
+
+            return "🚂 " + string.Join(" | ", summaries);
+        }
+
+        private string GetShiftTimes(DateTime date)
+        {
+            if (!SelectedSchedule.TryGetValue(date, out var shiftName))
+                return string.Empty;
+
+            var shift = Shifts.FirstOrDefault(s => s.Name == shiftName);
+            if (shift == null) return string.Empty;
+
+            var times = new List<string>();
+
+            if (!string.IsNullOrEmpty(shift.MorningTime))
+                times.Add($"🌅 {shift.MorningTime}");
+
+            if (!string.IsNullOrEmpty(shift.AfternoonTime))
+                times.Add($"🌆 {shift.AfternoonTime}");
+
+            return string.Join(" | ", times);
+        }
+
+        private void ShowConfiguration()
+        {
+            _showConfigDialog = true;
+            StateHasChanged();
+        }
+
+        private void HideConfiguration()
+        {
+            _showConfigDialog = false;
+            StateHasChanged();
+        }
+
+        private async Task OnConfigurationChanged()
+        {
+            Shifts = await HttpClient.GetFromJsonAsync<List<Shift>>("api/shift/shifts") ?? new();
+            StateHasChanged();
+        }
+
+        private bool IsLoadingTransportForDay(DateTime day) =>
+            _isLoadingTransportPerDay.GetValueOrDefault(day, false);
+    }
+}
+```
+
+- [ ] **Step 2: Update `Client/Pages/Index.razor`**
+
+Make the following targeted changes to `Index.razor`:
+
+**2a. Add Nextcloud button** — in the `action-buttons` div, after the Google Calendar button, add:
+
+```html
+<button class="btn export-btn" @onclick="SyncToNextcloud" disabled="@(_isLoadingInitial || _isSyncing)"><span class="oi oi-cloud-upload" aria-hidden="true"></span> Sync to Nextcloud</button>
+```
+
+**2b. Update the calendar selector modal title** — change:
+
+```html
+<h5 class="modal-title">Select Google Calendar</h5>
+```
+
+To:
+
+```html
+<h5 class="modal-title">Select @(_syncProvider == "nextcloud" ? "Nextcloud" : "Google") Calendar</h5>
+```
+
+**2d. Remove the `@code` block at the bottom of `Index.razor`** — the `IsLoadingTransportForDay` helper method was moved into `Index.razor.cs`. Delete this block from `Index.razor`:
+
+```razor
+@code {
+    // Helper method to check if a specific day is loading transport data
+    private bool IsLoadingTransportForDay(DateTime day)
+    {
+        return _isLoadingTransportPerDay.GetValueOrDefault(day, false);
+    }
+}
+```
+
+**2e. Update the syncing loading overlay text** — change:
+
+```html
+<p>Syncing with google calendar...</p>
+```
+
+To:
+
+```html
+<p>Syncing with @(_syncProvider == "nextcloud" ? "Nextcloud" : "Google Calendar")...</p>
+```
+
+- [ ] **Step 3: Build**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet build
+```
+
+Expected: Build succeeds.
+
+- [ ] **Step 4: Run all tests**
+
+```bash
+cd /home/schaad/Documents/ShiftScheduler && dotnet test ShiftScheduler.Services.Tests/ -v minimal
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add Client/Pages/Index.razor.cs Client/Pages/Index.razor
+git commit -m "feat: add Nextcloud sync button and update UI for provider-agnostic calendar flow"
+```
+
+---
+
+## Verification Checklist
+
+After all tasks are complete, verify end-to-end:
+
+- [ ] `dotnet build` succeeds with no warnings on `GoogleCalendar` references
+- [ ] `dotnet test ShiftScheduler.Services.Tests/` — all tests pass
+- [ ] Both "Sync to Google Calendar" and "Sync to Nextcloud" buttons appear in the UI
+- [ ] Modal title changes based on which button was pressed
+- [ ] `GET /api/shift/calendars?provider=google` and `?provider=nextcloud` both return `CalendarInfo[]`
+- [ ] `POST /api/shift/sync_to_calendar` with `Provider: "google"` still works as before