# Calendar Window 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:** A top-level calendar window over the user's vdirsyncer vdir: Month and Agenda views, a side pane that shows and edits the selected event, atomic stale-checked writes with a debounced sync, and undo.

**Architecture:** Everything runs on the UI thread (the whole vdir parses and expands in about 5 ms). libical is confined to `calendarstore.cpp` behind unique_ptr RAII aliases; every other unit sees plain value structs. `RepeatRule`, `CalendarWriter` and `MonthLayout` are pure and libical-free, so the parts with a right answer are tested without a widget.

**Tech Stack:** C++17, Qt 6.11 Widgets, libical 3.0.20 (via pkg-config), Qt Test.

**Spec:** `docs/superpowers/specs/2026-09-24-calendar-design.md`. Read it first; this plan does not repeat its reasoning.

---

## Before starting

- Work on a branch: `git switch -c calendar`. Merge to master only after the user's hand test (AGENTS.md: substantial UI work is branched so master stays shippable).
- Build and test per AGENTS.md: `cmake --build build && ctest --test-dir build --output-on-failure`. A single binary is ALWAYS run as `QT_QPA_PLATFORM=offscreen ./build/tests/test_<name>`. Never launch `./build/src/qtmaildir`.
- Commits are GPG-signed (`git commit -S`, which `commit.gpgsign=true` already does). Every new source file carries the GPLv2 header used by `src/contactstore.h` lines 1-17.
- **Every code block here is a draft.** AGENTS.md records many defects found in plan code written confidently. Verify each libical call against `/usr/include/libical/*.h` before relying on it, and prefer a failing test to a belief.
- Pre-existing failures, not yours: `test_mainwindow::undoMovesTheMessageBack` fails deterministically on this machine; `aSuccessfulCronSyncDrainsTheEditedAccounts` and `undoingAMarkReadRestoresOnlyWhatWasUnread` are order-dependent flakes that pass alone.

## Rulings against the spec

Taken while planning; the spec is amended in Task 16.

1. **`calendars_dir` absent means OFF**, not a default path. `contacts_dir` (`config.cpp`) set that precedent: an unset key is an ordinary machine, not a misconfiguration. The README documents the usual value.
2. **"Byte for byte" becomes "value for value".** libical re-serialises the whole component on write, so line folding and property order may change. Tests assert that `VALARM`, `ATTENDEE` and `X-*` properties survive with the same VALUES, which is the property that matters, rather than identical bytes.
3. **Views read `CalendarItem`**, an `Occurrence` plus the title and colour to draw. Still no libical and no `CalEvent` in a view.
4. **Expansion does not use `icalrecur_iterator_set_start`.** It is unsupported with `COUNT` rules, and the whole vdir expands from `DTSTART` in milliseconds. A cap of 10 000 iterations per series guards a pathological rule.

## File structure

| File | Responsibility |
|---|---|
| `src/icalraii.h` | unique_ptr aliases for libical handles. Included only by `calendarstore.cpp`. |
| `src/caltypes.h` | Plain value structs: `CalCollection`, `CalPerson`, `CalOverride`, `CalEvent`, `Occurrence`, `CalendarItem`, `EventEdit`, `LoadResult`. |
| `src/repeatrule.h/.cpp` | `RepeatRule`: the repeat control's model, `RRULE` value text in and out, and a sentence describing it. No libical. |
| `src/calendarstore.h/.cpp` | The only libical user: load a vdir, parse one file, expand occurrences, apply an edit, build a new event, add an `EXDATE`, compare two texts by meaning, decide editability. |
| `src/calendarwriter.h/.cpp` | One function: replace a file's content (create, edit, delete) atomically, refusing when the file is not what the caller expects. |
| `src/calendarsync.h/.cpp` | QObject owning the debounced `QProcess` for `calendar_sync_command`. |
| `src/monthlayout.h/.cpp` | Pure geometry of the month grid. |
| `src/monthview.h/.cpp` | Paints a `MonthLayout` with `CalendarItem`s; emits clicks. |
| `src/agendaview.h/.cpp` | A `QListWidget` grouped by day. |
| `src/eventpane.h/.cpp` | The side pane: read-only details page and the edit form, including the repeat control. |
| `src/calendarwindow.h/.cpp` | The top-level window: toolbar, views, pane, reload, undo, sync, the edit lock. |
| `src/config.h/.cpp` | Four `[general]` keys. |
| `src/keymap.cpp`, `src/mainwindow.h/.cpp` | The `calendar` action in the five places AGENTS.md lists; single instance. |
| `tests/test_repeatrule.cpp`, `test_calendarstore.cpp`, `test_calendarwriter.cpp`, `test_calendarsync.cpp`, `test_monthlayout.cpp`, `test_calendarwindow.cpp` | One suite per unit. Fixtures are inline strings with example.org addresses. |

---

### Task 1: Build wiring, RAII aliases, value structs, and parsing one event

**Files:**
- Modify: `CMakeLists.txt` (after the GMime `pkg_check_modules` line)
- Modify: `src/CMakeLists.txt`
- Modify: `tests/CMakeLists.txt`
- Create: `src/icalraii.h`, `src/caltypes.h`, `src/repeatrule.h`, `src/repeatrule.cpp` (stub for now), `src/calendarstore.h`, `src/calendarstore.cpp`
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Wire libical into CMake**

In `CMakeLists.txt`, directly under `pkg_check_modules(GMIME REQUIRED IMPORTED_TARGET gmime-3.0)`:

```cmake
# libical parses and writes the calendar's iCalendar files (item 206). Unlike
# notmuch it ships a .pc, so pkg-config finds it; unlike GMime it pulls in no
# glib, so its headers may sit anywhere in an include list.
pkg_check_modules(LIBICAL REQUIRED IMPORTED_TARGET libical)
```

In `src/CMakeLists.txt`, add to the `qtmaildir_lib` source list after `signatures.cpp`:

```cmake
    repeatrule.cpp
    calendarstore.cpp
```

and add `PkgConfig::LIBICAL` to `target_link_libraries(qtmaildir_lib PUBLIC ...)` after `PkgConfig::GMIME`.

In `tests/CMakeLists.txt`, after the `contactstore` block:

```cmake
add_qtmaildir_test(repeatrule)
add_qtmaildir_test(calendarstore)
```

- [ ] **Step 2: Write `src/icalraii.h`**

```cpp
/* GPLv2 header, as src/contactstore.h lines 1-17 */

#pragma once

#include <libical/ical.h>

#include <cstdlib>
#include <memory>

/// Owners for libical handles, the calendar's counterpart to nmraii.h.
///
/// The same rule as notmuch's: no libical pointer leaves calendarstore.cpp,
/// the one file that includes this header. unique_ptr rather than NmHandle's
/// template because every libical handle here has exactly one destroy
/// function and no aliasing, which is what unique_ptr already expresses.
struct IcalComponentFree {
    void operator()(icalcomponent *c) const { icalcomponent_free(c); }
};
using IcalComponent = std::unique_ptr<icalcomponent, IcalComponentFree>;

struct IcalRecurFree {
    void operator()(icalrecur_iterator *i) const { icalrecur_iterator_free(i); }
};
using IcalRecurIterator = std::unique_ptr<icalrecur_iterator, IcalRecurFree>;

/// For strings returned by the `*_r` functions, which the caller must free().
/// The plain variants return a ring buffer libical reuses, so a pointer kept
/// from one is overwritten by a later call.
struct IcalStringFree {
    void operator()(char *s) const { std::free(s); }
};
using IcalString = std::unique_ptr<char, IcalStringFree>;
```

- [ ] **Step 3: Write `src/repeatrule.h` and a stub `src/repeatrule.cpp`**

The full implementation is Task 3; the type must exist now because `CalEvent` holds one.

```cpp
/* GPLv2 header */

#pragma once

#include <QDate>
#include <QList>
#include <QString>

/// The repeat control's model, and its RRULE value text in both directions.
///
/// No libical: an RRULE value is `KEY=VALUE;KEY=VALUE`, which is simpler to
/// read and write as text than through icalrecurrencetype, and keeping it pure
/// is what lets every row of the spec's repeat table be tested as a string.
struct RepeatRule
{
    enum class Freq { None, Daily, Weekly, Monthly, Yearly };
    /// Monthly and Yearly only: on a day of the month, or on the Nth weekday.
    enum class By { MonthDay, Weekday };
    enum class End { Never, Until, Count };

    Freq freq = Freq::None;
    int interval = 1;
    /// Weekly: Qt::DayOfWeek values, 1 (Monday) to 7 (Sunday), sorted.
    QList<int> weekdays;
    By by = By::MonthDay;
    int monthDay = 0;   ///< Monthly, By::MonthDay: 1 to 31.
    int ordinal = 0;    ///< By::Weekday: 1 to 4, or -1 for "last".
    int weekday = 0;    ///< By::Weekday: Qt::DayOfWeek.
    int month = 0;      ///< Yearly, By::Weekday: 1 to 12.
    End end = End::Never;
    QDate until;        ///< End::Until: the last day an occurrence may fall on.
    int count = 0;      ///< End::Count.
    /// Carried through a rewrite untouched, per the spec: several existing
    /// rules carry it and it changes nothing for the modes above.
    QString wkst;

    /// A rule outside the control's table. `customText` is the value exactly
    /// as read, and an edit never rewrites it.
    bool custom = false;
    QString customText;

    /// Parses an RRULE value (no "RRULE:" prefix). `start` is the event's
    /// first day, which fills in what an RRULE leaves implicit (a weekly rule
    /// with no BYDAY repeats on the start's weekday).
    static RepeatRule fromRRule(const QString &value, const QDate &start);

    /// The RRULE value, or an empty string for Freq::None. `untilValue` is
    /// the whole UNTIL value, `20261231` for an all-day event or
    /// `20261231T225959Z` for a timed one, computed by the caller because
    /// only it knows the event's zone. Ignored unless end is End::Until.
    QString toRRule(const QString &untilValue = QString()) const;

    /// "Monthly, on the last Friday", translated. Custom rules say so.
    QString describe() const;

    bool operator==(const RepeatRule &other) const;
};
```

`src/repeatrule.cpp`, stub:

```cpp
/* GPLv2 header */

#include "repeatrule.h"

RepeatRule RepeatRule::fromRRule(const QString &, const QDate &) { return {}; }
QString RepeatRule::toRRule(const QString &) const { return {}; }
QString RepeatRule::describe() const { return {}; }
bool RepeatRule::operator==(const RepeatRule &) const { return false; }
```

Also create an empty `tests/test_repeatrule.cpp` so CMake configures (Task 3 fills it):

```cpp
/* GPLv2 header */

#include <QtTest>

#include "repeatrule.h"

class TestRepeatRule : public QObject
{
    Q_OBJECT
};

QTEST_MAIN(TestRepeatRule)
#include "test_repeatrule.moc"
```

- [ ] **Step 4: Write `src/caltypes.h`**

```cpp
/* GPLv2 header */

#pragma once

#include "repeatrule.h"

#include <QByteArray>
#include <QColor>
#include <QDateTime>
#include <QList>
#include <QString>

/// One vdir collection: a subdirectory of calendars_dir.
struct CalCollection
{
    QString dir;          ///< The directory's own name, e.g. "52".
    QString path;         ///< Absolute path.
    /// From the vdir's `displayname` file, which vdirsyncer's metasync fills
    /// from the server; the directory name when absent.
    QString displayName;
    /// From the vdir's `color` file (`#RRGGBB`); a colour hashed from the
    /// directory name when absent, so no collection is ever invisible.
    QColor color;
    bool readOnly = false;  ///< The directory is not writable.
};

struct CalPerson
{
    QString name;      ///< CN, possibly empty.
    QString address;   ///< The address with "mailto:" removed.
    QString partstat;  ///< PARTSTAT as written, e.g. "ACCEPTED"; empty if absent.
};

/// A RECURRENCE-ID override: one occurrence of a series moved or changed.
struct CalOverride
{
    QDateTime recurrenceId;  ///< The original slot it replaces.
    QDateTime start;
    QDateTime end;
    bool allDay = false;
    QString summary;
    QString location;
    QString description;
    bool cancelled = false;  ///< STATUS:CANCELLED: the slot is removed.
};

/// One .ics file's event, as the rest of the application sees it.
struct CalEvent
{
    QString filePath;
    QString collectionDir;
    QString uid;
    QString summary;
    QString location;
    QString description;
    QDateTime start;
    QDateTime end;   ///< Exclusive. For an all-day event, midnight after the last day.
    bool allDay = false;
    RepeatRule repeat;  ///< Freq::None when the event does not repeat.
    QList<QDateTime> exdates;
    QList<CalOverride> overrides;
    bool hasAlarm = false;
    CalPerson organizer;  ///< Empty address: no ORGANIZER.
    QList<CalPerson> attendees;
    int sequence = 0;
    QByteArray rawText;  ///< The file exactly as read: stale checks and undo.
};

/// One expanded occurrence. What a view is built from.
struct Occurrence
{
    int eventIndex = -1;       ///< Into LoadResult::events.
    QDateTime start;
    QDateTime end;
    bool allDay = false;
    /// The slot this occurrence fills in its series, which is what a
    /// RECURRENCE-ID or an EXDATE names. Invalid for a non-repeating event.
    QDateTime recurrenceId;
    bool isOverride = false;
    int overrideIndex = -1;    ///< Into CalEvent::overrides when isOverride.
};

/// An occurrence plus what a view draws. Views see nothing else.
struct CalendarItem
{
    Occurrence occurrence;
    QString title;
    QColor color;
};

/// What the edit form produces.
struct EventEdit
{
    QString summary;
    QString location;
    QString description;
    QDateTime start;
    QDateTime end;
    bool allDay = false;
    RepeatRule repeat;
    QString collectionDir;
};

struct LoadResult
{
    QList<CalCollection> collections;
    QList<CalEvent> events;
    int unparsable = 0;     ///< Files skipped because they did not parse.
    int unknownZones = 0;   ///< Events whose TZID resolved to nothing, shown in local time.
};
```

- [ ] **Step 5: Write the failing test**

`tests/test_calendarstore.cpp`:

```cpp
/* GPLv2 header */

#include <QtTest>
#include <QDir>
#include <QFile>
#include <QTemporaryDir>
#include <QTimeZone>

#include "calendarstore.h"

namespace {

/// Wraps VEVENT lines (and optional extra components) into a VCALENDAR.
QByteArray ics(const QString &body)
{
    return QStringLiteral("BEGIN:VCALENDAR\r\nVERSION:2.0\r\n"
                          "PRODID:-//example//test//EN\r\n%1END:VCALENDAR\r\n")
        .arg(body).toUtf8();
}

QString vevent(const QString &lines)
{
    return QStringLiteral("BEGIN:VEVENT\r\n%1END:VEVENT\r\n").arg(lines);
}

} // namespace

class TestCalendarStore : public QObject
{
    Q_OBJECT

private slots:
    void parsesAUtcEvent();
};

void TestCalendarStore::parsesAUtcEvent()
{
    bool unknownZone = true;
    const CalEvent event = CalendarStore::parseEvent(
        ics(vevent(QStringLiteral(
            "UID:utc-1@example.org\r\nDTSTAMP:20260901T000000Z\r\n"
            "SUMMARY:Standup\r\nLOCATION:Room 2\r\n"
            "DTSTART:20260922T080000Z\r\nDTEND:20260922T081500Z\r\n"
            "SEQUENCE:3\r\n"))),
        QStringLiteral("/tmp/x/utc-1.ics"), QStringLiteral("x"), &unknownZone);

    QCOMPARE(event.uid, QStringLiteral("utc-1@example.org"));
    QCOMPARE(event.summary, QStringLiteral("Standup"));
    QCOMPARE(event.location, QStringLiteral("Room 2"));
    QCOMPARE(event.start, QDateTime(QDate(2026, 9, 22), QTime(8, 0), QTimeZone::utc()));
    QCOMPARE(event.end, QDateTime(QDate(2026, 9, 22), QTime(8, 15), QTimeZone::utc()));
    QVERIFY(!event.allDay);
    QCOMPARE(event.sequence, 3);
    QCOMPARE(event.filePath, QStringLiteral("/tmp/x/utc-1.ics"));
    QVERIFY(!unknownZone);
    QVERIFY(!event.rawText.isEmpty());
}

QTEST_MAIN(TestCalendarStore)
#include "test_calendarstore.moc"
```

- [ ] **Step 6: Write `src/calendarstore.h`**

```cpp
/* GPLv2 header */

#pragma once

#include "caltypes.h"

#include <QByteArray>
#include <QDateTime>
#include <QList>
#include <QString>
#include <QStringList>

/// The calendar's iCalendar work, and the only code that includes libical.
///
/// A namespace of free functions over values, like ContactStore and
/// MimeParser, so every rule with a right answer is testable without a
/// widget. See the spec, docs/superpowers/specs/2026-09-24-calendar-design.md.
namespace CalendarStore {

enum class Scope { All, ThisOccurrence };

/// Parses one file's text. An empty uid in the result means the text held no
/// usable VEVENT. `unknownZone` is set when a TZID resolved to nothing and the
/// times were read as local.
CalEvent parseEvent(const QByteArray &text, const QString &filePath,
                    const QString &collectionDir, bool *unknownZone);

/// Reads every collection under `dir` and every *.ics in each.
LoadResult load(const QString &dir);

/// Every occurrence of every event overlapping [from, to), sorted by start.
QList<Occurrence> occurrences(const QList<CalEvent> &events,
                              const QDateTime &from, const QDateTime &to);

/// Whether the user may edit or delete `event`: its collection is writable,
/// and it has no ORGANIZER or the organiser is one of `ownAddresses`.
bool isEditable(const CalEvent &event, const CalCollection &collection,
                const QStringList &ownAddresses);

/// Applies `edit` to the file text and returns the new text; empty when the
/// text does not parse. Scope::ThisOccurrence writes or replaces the override
/// for `recurrenceId`. Properties the form does not own survive.
QByteArray applyEdit(const QByteArray &text, const EventEdit &edit,
                     Scope scope, const QDateTime &recurrenceId);

/// A complete new file for `edit`, timed events in the IANA zone `zoneId`.
QByteArray newEvent(const EventEdit &edit, const QByteArray &zoneId);

/// Removes one occurrence: adds an EXDATE to the master and drops any override
/// for that slot. Empty on a parse failure.
QByteArray deleteOccurrence(const QByteArray &text, const QDateTime &recurrenceId);

/// Whether two texts describe the same event: summary, times, repeat rule,
/// exceptions. Formatting is ignored, since the server may normalise it.
bool sameMeaning(const QByteArray &a, const QByteArray &b);

}  // namespace CalendarStore
```

- [ ] **Step 7: Run the test to verify it fails**

Run: `cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug && cmake --build build 2>&1 | tail -5`
Expected: link failure, undefined reference to `CalendarStore::parseEvent`.

- [ ] **Step 8: Write the parsing half of `src/calendarstore.cpp`**

Only `parseEvent` and the time helper for now, with the remaining functions as stubs so the library links. Later tasks replace each stub.

```cpp
/* GPLv2 header */

#include "calendarstore.h"
#include "icalraii.h"

#include <QTimeZone>

namespace {

QString str(const char *s) { return s ? QString::fromUtf8(s) : QString(); }

QByteArray tzidOf(icalproperty *prop)
{
    if (!prop)
        return {};
    icalparameter *param = icalproperty_get_first_parameter(prop, ICAL_TZID_PARAMETER);
    return param ? QByteArray(icalparameter_get_tzid(param)) : QByteArray();
}

/// One icaltimetype to a QDateTime, in this order (spec, "Time and
/// recurrence"): a date is local midnight; UTC is UTC; a zone libical resolved
/// (an embedded VTIMEZONE) converts through libical; a TZID libical could not
/// resolve is tried as an IANA name through QTimeZone; anything else is local
/// wall-clock time, and an unresolvable TZID sets *unknownZone.
QDateTime toDateTime(icaltimetype t, const QByteArray &tzid, bool *unknownZone)
{
    if (icaltime_is_null_time(t))
        return {};
    const QDate date(t.year, t.month, t.day);
    if (t.is_date)
        return QDateTime(date, QTime(0, 0));
    const QTime time(t.hour, t.minute, t.second);
    if (icaltime_is_utc(t))
        return QDateTime(date, time, QTimeZone::utc());
    if (t.zone) {
        const icaltimetype utc =
            icaltime_convert_to_zone(t, icaltimezone_get_utc_timezone());
        return QDateTime(QDate(utc.year, utc.month, utc.day),
                         QTime(utc.hour, utc.minute, utc.second), QTimeZone::utc());
    }
    if (!tzid.isEmpty()) {
        const QTimeZone zone(tzid);
        if (zone.isValid())
            return QDateTime(date, time, zone);
        if (unknownZone)
            *unknownZone = true;
    }
    return QDateTime(date, time);
}

CalPerson personOf(icalproperty *prop)
{
    CalPerson person;
    QString value = str(icalproperty_get_value_as_string(prop));
    if (value.startsWith(QLatin1String("mailto:"), Qt::CaseInsensitive))
        value = value.mid(7);
    person.address = value;
    person.name = str(icalproperty_get_parameter_as_string(prop, "CN"));
    person.partstat = str(icalproperty_get_parameter_as_string(prop, "PARTSTAT"));
    return person;
}

/// The VEVENT without a RECURRENCE-ID, or the first VEVENT if every one has.
icalcomponent *masterOf(icalcomponent *root)
{
    icalcomponent *first = nullptr;
    for (icalcomponent *c = icalcomponent_get_first_component(root, ICAL_VEVENT_COMPONENT);
         c; c = icalcomponent_get_next_component(root, ICAL_VEVENT_COMPONENT)) {
        if (!first)
            first = c;
        if (!icalcomponent_get_first_property(c, ICAL_RECURRENCEID_PROPERTY))
            return c;
    }
    return first;
}

IcalComponent parseRoot(const QByteArray &text)
{
    IcalComponent root(icalparser_parse_string(text.constData()));
    if (root && icalcomponent_isa(root.get()) == ICAL_VEVENT_COMPONENT) {
        // A bare VEVENT with no VCALENDAR around it: wrap it, so every
        // caller walks the same shape.
        IcalComponent cal(icalcomponent_new(ICAL_VCALENDAR_COMPONENT));
        icalcomponent_add_component(cal.get(), root.release());
        return cal;
    }
    return root;
}

/// The end of a component: DTEND, else DTSTART + DURATION (libical computes
/// both through get_dtend), else one day for a date and the start otherwise.
QDateTime endOf(icalcomponent *c, const QDateTime &start, bool allDay, bool *unknownZone)
{
    icalproperty *endProp = icalcomponent_get_first_property(c, ICAL_DTEND_PROPERTY);
    const icaltimetype end = icalcomponent_get_dtend(c);
    if (!icaltime_is_null_time(end))
        return toDateTime(end, tzidOf(endProp ? endProp
                                  : icalcomponent_get_first_property(c, ICAL_DTSTART_PROPERTY)),
                          unknownZone);
    return allDay ? start.addDays(1) : start;
}

} // namespace

namespace CalendarStore {

CalEvent parseEvent(const QByteArray &text, const QString &filePath,
                    const QString &collectionDir, bool *unknownZone)
{
    CalEvent event;
    event.filePath = filePath;
    event.collectionDir = collectionDir;
    event.rawText = text;
    if (unknownZone)
        *unknownZone = false;

    IcalComponent root = parseRoot(text);
    if (!root)
        return event;
    icalcomponent *master = masterOf(root.get());
    if (!master)
        return event;

    event.uid = str(icalcomponent_get_uid(master));
    event.summary = str(icalcomponent_get_summary(master));
    event.location = str(icalcomponent_get_location(master));
    event.description = str(icalcomponent_get_description(master));
    event.sequence = icalcomponent_get_sequence(master);

    icalproperty *startProp = icalcomponent_get_first_property(master, ICAL_DTSTART_PROPERTY);
    const icaltimetype start = icalcomponent_get_dtstart(master);
    event.allDay = start.is_date;
    event.start = toDateTime(start, tzidOf(startProp), unknownZone);
    event.end = endOf(master, event.start, event.allDay, unknownZone);

    event.hasAlarm = icalcomponent_get_first_component(master, ICAL_VALARM_COMPONENT);
    if (icalproperty *org = icalcomponent_get_first_property(master, ICAL_ORGANIZER_PROPERTY))
        event.organizer = personOf(org);
    for (icalproperty *a = icalcomponent_get_first_property(master, ICAL_ATTENDEE_PROPERTY);
         a; a = icalcomponent_get_next_property(master, ICAL_ATTENDEE_PROPERTY))
        event.attendees.append(personOf(a));

    // Recurrence, exceptions and overrides: Task 4.
    return event;
}

LoadResult load(const QString &) { return {}; }
QList<Occurrence> occurrences(const QList<CalEvent> &, const QDateTime &, const QDateTime &) { return {}; }
bool isEditable(const CalEvent &, const CalCollection &, const QStringList &) { return false; }
QByteArray applyEdit(const QByteArray &, const EventEdit &, Scope, const QDateTime &) { return {}; }
QByteArray newEvent(const EventEdit &, const QByteArray &) { return {}; }
QByteArray deleteOccurrence(const QByteArray &, const QDateTime &) { return {}; }
bool sameMeaning(const QByteArray &, const QByteArray &) { return false; }

}  // namespace CalendarStore
```

- [ ] **Step 9: Run the test to verify it passes**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: `Totals: 3 passed, 0 failed` (initTestCase, parsesAUtcEvent, cleanupTestCase).

- [ ] **Step 10: Commit**

```bash
git add CMakeLists.txt src/CMakeLists.txt tests/CMakeLists.txt src/icalraii.h src/caltypes.h \
        src/repeatrule.h src/repeatrule.cpp src/calendarstore.h src/calendarstore.cpp \
        tests/test_calendarstore.cpp tests/test_repeatrule.cpp
git commit -m "feat: parse one calendar event with libical (item 206)"
```

---

### Task 2: Every time form, and loading a vdir

**Files:**
- Modify: `src/calendarstore.cpp` (`load`)
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Write the failing tests**

Add to the `private slots:` list and the file:

```cpp
    void readsATzidWithItsVtimezone();
    void readsATzidWithoutAVtimezoneAsIana();
    void readsAnUnknownTzidAsLocalAndSaysSo();
    void readsFloatingTimeAsLocal();
    void readsAnAllDayEventWithAnExclusiveEnd();
    void loadReadsCollectionsAndFallsBack();
    void loadSkipsAndCountsABrokenFile();
```

```cpp
namespace {

const char *kRomeVtimezone =
    "BEGIN:VTIMEZONE\r\nTZID:Europe/Rome\r\n"
    "BEGIN:DAYLIGHT\r\nTZOFFSETFROM:+0100\r\nTZOFFSETTO:+0200\r\nTZNAME:CEST\r\n"
    "DTSTART:19700329T020000\r\nRRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU\r\nEND:DAYLIGHT\r\n"
    "BEGIN:STANDARD\r\nTZOFFSETFROM:+0200\r\nTZOFFSETTO:+0100\r\nTZNAME:CET\r\n"
    "DTSTART:19701025T030000\r\nRRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU\r\nEND:STANDARD\r\n"
    "END:VTIMEZONE\r\n";

CalEvent parse(const QString &body, bool *unknown = nullptr)
{
    bool ignored = false;
    return CalendarStore::parseEvent(ics(body), QStringLiteral("/x/e.ics"),
                                     QStringLiteral("x"), unknown ? unknown : &ignored);
}

void writeFile(const QString &path, const QByteArray &content)
{
    QDir().mkpath(QFileInfo(path).absolutePath());
    QFile file(path);
    QVERIFY2(file.open(QIODevice::WriteOnly | QIODevice::Truncate),
             qPrintable(file.errorString()));
    file.write(content);
}

} // namespace

void TestCalendarStore::readsATzidWithItsVtimezone()
{
    const CalEvent e = parse(QString::fromLatin1(kRomeVtimezone) + vevent(QStringLiteral(
        "UID:a@example.org\r\nDTSTART;TZID=Europe/Rome:20260922T100000\r\n"
        "DTEND;TZID=Europe/Rome:20260922T110000\r\n")));
    // 10:00 in Rome in September is 08:00 UTC (CEST, +2).
    QCOMPARE(e.start.toUTC(), QDateTime(QDate(2026, 9, 22), QTime(8, 0), QTimeZone::utc()));
    QCOMPARE(e.end.toUTC(), QDateTime(QDate(2026, 9, 22), QTime(9, 0), QTimeZone::utc()));
}

void TestCalendarStore::readsATzidWithoutAVtimezoneAsIana()
{
    // 120 of the user's 312 files are shaped like this: RFC 5545 requires the
    // VTIMEZONE, and real servers omit it.
    bool unknown = true;
    const CalEvent e = parse(vevent(QStringLiteral(
        "UID:b@example.org\r\nDTSTART;TZID=Europe/Rome:20260922T100000\r\n"
        "DTEND;TZID=Europe/Rome:20260922T110000\r\n")), &unknown);
    QCOMPARE(e.start.toUTC(), QDateTime(QDate(2026, 9, 22), QTime(8, 0), QTimeZone::utc()));
    QVERIFY(!unknown);
}

void TestCalendarStore::readsAnUnknownTzidAsLocalAndSaysSo()
{
    bool unknown = false;
    const CalEvent e = parse(vevent(QStringLiteral(
        "UID:c@example.org\r\nDTSTART;TZID=Not A Zone:20260922T100000\r\n"
        "DTEND;TZID=Not A Zone:20260922T110000\r\n")), &unknown);
    QVERIFY(unknown);
    QCOMPARE(e.start, QDateTime(QDate(2026, 9, 22), QTime(10, 0)));
}

void TestCalendarStore::readsFloatingTimeAsLocal()
{
    const CalEvent e = parse(vevent(QStringLiteral(
        "UID:d@example.org\r\nDTSTART:20260922T100000\r\nDTEND:20260922T110000\r\n")));
    QCOMPARE(e.start, QDateTime(QDate(2026, 9, 22), QTime(10, 0)));
    QCOMPARE(e.start.timeSpec(), Qt::LocalTime);
}

void TestCalendarStore::readsAnAllDayEventWithAnExclusiveEnd()
{
    const CalEvent e = parse(vevent(QStringLiteral(
        "UID:e@example.org\r\nDTSTART;VALUE=DATE:20260924\r\nDTEND;VALUE=DATE:20260925\r\n")));
    QVERIFY(e.allDay);
    QCOMPARE(e.start.date(), QDate(2026, 9, 24));
    // Exclusive: a one-day event on the 24th ends at the START of the 25th.
    QCOMPARE(e.end.date(), QDate(2026, 9, 25));
    QCOMPARE(e.end.time(), QTime(0, 0));
}

void TestCalendarStore::loadReadsCollectionsAndFallsBack()
{
    QTemporaryDir dir;
    const QString root = dir.path();
    writeFile(root + QStringLiteral("/52/displayname"), "Work");
    writeFile(root + QStringLiteral("/52/color"), "#60a5fa\n");
    writeFile(root + QStringLiteral("/52/one.ics"), ics(vevent(QStringLiteral(
        "UID:one@example.org\r\nDTSTART:20260922T080000Z\r\n"))));
    writeFile(root + QStringLiteral("/31/two.ics"), ics(vevent(QStringLiteral(
        "UID:two@example.org\r\nDTSTART:20260923T080000Z\r\n"))));
    writeFile(root + QStringLiteral("/31/notes.txt"), "not a calendar file");

    const LoadResult r = CalendarStore::load(root);
    QCOMPARE(r.collections.size(), 2);
    QCOMPARE(r.events.size(), 2);
    QCOMPARE(r.unparsable, 0);

    // Sorted by display name, so "31" (no displayname) sorts before "Work".
    QCOMPARE(r.collections[0].dir, QStringLiteral("31"));
    QCOMPARE(r.collections[0].displayName, QStringLiteral("31"));
    QVERIFY(r.collections[0].color.isValid());
    QCOMPARE(r.collections[1].displayName, QStringLiteral("Work"));
    QCOMPARE(r.collections[1].color, QColor(QStringLiteral("#60a5fa")));
    QVERIFY(!r.collections[1].readOnly);

    // The hashed fallback is stable across loads, or colours would shuffle.
    QCOMPARE(CalendarStore::load(root).collections[0].color, r.collections[0].color);
}

void TestCalendarStore::loadSkipsAndCountsABrokenFile()
{
    QTemporaryDir dir;
    writeFile(dir.path() + QStringLiteral("/c/good.ics"), ics(vevent(QStringLiteral(
        "UID:good@example.org\r\nDTSTART:20260922T080000Z\r\n"))));
    writeFile(dir.path() + QStringLiteral("/c/bad.ics"), "this is not iCalendar");
    const LoadResult r = CalendarStore::load(dir.path());
    QCOMPARE(r.events.size(), 1);
    QCOMPARE(r.unparsable, 1);
}
```

Add `#include <QFileInfo>` to the test's includes.

- [ ] **Step 2: Run them to verify they fail**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: the five parse tests PASS already (Task 1's `toDateTime` covers them; that is fine, they pin the behaviour), and the two `load*` tests FAIL (`load` is a stub returning nothing). If any parse test fails, fix `toDateTime` before going on.

- [ ] **Step 3: Implement `load`**

Replace the `load` stub. Add includes `<QCryptographicHash>`, `<QDir>`, `<QFile>`, `<QFileInfo>` and `<algorithm>` at the top of `calendarstore.cpp`.

```cpp
namespace {

QString readTrimmed(const QString &path)
{
    QFile file(path);
    if (!file.open(QIODevice::ReadOnly))
        return {};
    return QString::fromUtf8(file.readAll()).trimmed();
}

/// A colour for a collection with no `color` file, derived from its directory
/// name so it is the same on every load and on every machine.
QColor hashedColour(const QString &dir)
{
    const QByteArray hash = QCryptographicHash::hash(dir.toUtf8(), QCryptographicHash::Md5);
    const int hue = (static_cast<unsigned char>(hash[0]) * 256
                     + static_cast<unsigned char>(hash[1])) % 360;
    return QColor::fromHsl(hue, 150, 140);
}

} // namespace
```

```cpp
LoadResult load(const QString &dir)
{
    LoadResult result;
    const QFileInfoList subdirs =
        QDir(dir).entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
    for (const QFileInfo &sub : subdirs) {
        CalCollection collection;
        collection.dir = sub.fileName();
        collection.path = sub.absoluteFilePath();
        collection.displayName = readTrimmed(collection.path + QStringLiteral("/displayname"));
        if (collection.displayName.isEmpty())
            collection.displayName = collection.dir;
        collection.color = QColor(readTrimmed(collection.path + QStringLiteral("/color")));
        if (!collection.color.isValid())
            collection.color = hashedColour(collection.dir);
        collection.readOnly = !sub.isWritable();
        result.collections.append(collection);

        const QFileInfoList files =
            QDir(collection.path).entryInfoList({ QStringLiteral("*.ics") }, QDir::Files, QDir::Name);
        for (const QFileInfo &file : files) {
            QFile f(file.absoluteFilePath());
            if (!f.open(QIODevice::ReadOnly)) {
                ++result.unparsable;
                continue;
            }
            bool unknown = false;
            CalEvent event = parseEvent(f.readAll(), file.absoluteFilePath(),
                                        collection.dir, &unknown);
            if (event.uid.isEmpty() || !event.start.isValid()) {
                ++result.unparsable;
                continue;
            }
            if (unknown)
                ++result.unknownZones;
            result.events.append(event);
        }
    }
    std::sort(result.collections.begin(), result.collections.end(),
              [](const CalCollection &a, const CalCollection &b) {
                  return a.displayName.localeAwareCompare(b.displayName) < 0;
              });
    return result;
}
```

- [ ] **Step 4: Run the tests to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add src/calendarstore.cpp tests/test_calendarstore.cpp
git commit -m "feat: read every time form and load a calendar vdir"
```

---

### Task 3: `RepeatRule`

**Files:**
- Modify: `src/repeatrule.cpp`
- Test: `tests/test_repeatrule.cpp`

- [ ] **Step 1: Write the failing tests**

Replace `tests/test_repeatrule.cpp`:

```cpp
/* GPLv2 header */

#include <QtTest>

#include "repeatrule.h"

class TestRepeatRule : public QObject
{
    Q_OBJECT

private slots:
    void roundTripsEveryRowOfTheTable_data();
    void roundTripsEveryRowOfTheTable();
    void fillsWhatAnRruleLeavesImplicit();
    void recognisesACustomRule_data();
    void recognisesACustomRule();
    void keepsWkst();
    void readsUntilInEveryForm();
    void describesInWords();
};

void TestRepeatRule::roundTripsEveryRowOfTheTable_data()
{
    QTest::addColumn<QString>("rrule");
    // Each row of the spec's repeat table, written the way toRRule writes it.
    QTest::newRow("daily") << QStringLiteral("FREQ=DAILY");
    QTest::newRow("every 3 days") << QStringLiteral("FREQ=DAILY;INTERVAL=3");
    QTest::newRow("weekly on days") << QStringLiteral("FREQ=WEEKLY;BYDAY=MO,WE,FR");
    QTest::newRow("monthly on day") << QStringLiteral("FREQ=MONTHLY;BYMONTHDAY=18");
    QTest::newRow("monthly last friday") << QStringLiteral("FREQ=MONTHLY;BYDAY=-1FR");
    QTest::newRow("monthly 2nd tuesday") << QStringLiteral("FREQ=MONTHLY;INTERVAL=2;BYDAY=2TU");
    QTest::newRow("yearly") << QStringLiteral("FREQ=YEARLY");
    QTest::newRow("yearly last fri of sep") << QStringLiteral("FREQ=YEARLY;BYMONTH=9;BYDAY=-1FR");
    QTest::newRow("count") << QStringLiteral("FREQ=MONTHLY;BYMONTHDAY=18;COUNT=12");
    QTest::newRow("until date") << QStringLiteral("FREQ=YEARLY;UNTIL=20301231");
}

void TestRepeatRule::roundTripsEveryRowOfTheTable()
{
    QFETCH(QString, rrule);
    const QDate start(2026, 9, 18);
    const RepeatRule rule = RepeatRule::fromRRule(rrule, start);
    QVERIFY2(!rule.custom, qPrintable(rrule));
    // UNTIL in the "until date" row is a DATE, so the all-day form (no suffix).
    QCOMPARE(rule.toRRule(rule.end == RepeatRule::End::Until
                              ? rule.until.toString(QStringLiteral("yyyyMMdd"))
                              : QString()),
             rrule);
    QCOMPARE(RepeatRule::fromRRule(rule.toRRule(rule.until.toString(QStringLiteral("yyyyMMdd"))),
                                   start), rule);
}

void TestRepeatRule::fillsWhatAnRruleLeavesImplicit()
{
    // 2026-09-18 is a Friday.
    const RepeatRule weekly = RepeatRule::fromRRule(QStringLiteral("FREQ=WEEKLY"), QDate(2026, 9, 18));
    QCOMPARE(weekly.weekdays, QList<int>{ Qt::Friday });
    const RepeatRule monthly = RepeatRule::fromRRule(QStringLiteral("FREQ=MONTHLY"), QDate(2026, 9, 18));
    QCOMPARE(monthly.by, RepeatRule::By::MonthDay);
    QCOMPARE(monthly.monthDay, 18);
}

void TestRepeatRule::recognisesACustomRule_data()
{
    QTest::addColumn<QString>("rrule");
    QTest::newRow("bysetpos") << QStringLiteral("FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1");
    QTest::newRow("byweekno") << QStringLiteral("FREQ=YEARLY;BYWEEKNO=20");
    QTest::newRow("hourly") << QStringLiteral("FREQ=HOURLY");
    QTest::newRow("two months") << QStringLiteral("FREQ=YEARLY;BYMONTH=3,9;BYDAY=-1FR");
    QTest::newRow("two monthdays") << QStringLiteral("FREQ=MONTHLY;BYMONTHDAY=1,15");
    QTest::newRow("weekly ordinal") << QStringLiteral("FREQ=WEEKLY;BYDAY=1MO");
    QTest::newRow("fifth monday") << QStringLiteral("FREQ=MONTHLY;BYDAY=5MO");
}

void TestRepeatRule::recognisesACustomRule()
{
    QFETCH(QString, rrule);
    const RepeatRule rule = RepeatRule::fromRRule(rrule, QDate(2026, 9, 18));
    QVERIFY(rule.custom);
    // An edit never rewrites a custom rule: it comes back exactly.
    QCOMPARE(rule.toRRule(), rrule);
}

void TestRepeatRule::keepsWkst()
{
    const RepeatRule rule = RepeatRule::fromRRule(QStringLiteral("FREQ=YEARLY;WKST=TU"), QDate(2026, 9, 18));
    QVERIFY(!rule.custom);
    QCOMPARE(rule.toRRule(), QStringLiteral("FREQ=YEARLY;WKST=TU"));
}

void TestRepeatRule::readsUntilInEveryForm()
{
    const QDate start(2026, 9, 18);
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=DAILY;UNTIL=20261231"), start).until,
             QDate(2026, 12, 31));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=DAILY;UNTIL=20261231T120000"), start).until,
             QDate(2026, 12, 31));
    // A UTC UNTIL keeps its UTC date: the caller writes 23:59:59 local as UTC,
    // which in a zone east of UTC is still the same date.
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=DAILY;UNTIL=20261231T215959Z"), start).until,
             QDate(2026, 12, 31));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=DAILY;UNTIL=20261231"), start).end,
             RepeatRule::End::Until);
}

void TestRepeatRule::describesInWords()
{
    const QDate start(2026, 9, 18);
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=DAILY"), start).describe(),
             QStringLiteral("Daily"));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=MONTHLY;BYDAY=-1FR"), start).describe(),
             QStringLiteral("Monthly, on the last Friday"));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=MONTHLY;BYMONTHDAY=18;COUNT=12"), start).describe(),
             QStringLiteral("Monthly, on day 18, 12 times"));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=YEARLY;BYMONTH=9;BYDAY=-1FR"), start).describe(),
             QStringLiteral("Yearly, on the last Friday of September"));
    QCOMPARE(RepeatRule::fromRRule(QStringLiteral("FREQ=YEARLY;BYWEEKNO=20"), start).describe(),
             QStringLiteral("Custom rule"));
}

QTEST_MAIN(TestRepeatRule)
#include "test_repeatrule.moc"
```

`describesInWords` compares English: the test process installs no translator, and QLocale day and month names come from the C locale under `QTEST_MAIN`'s default. If the machine locale leaks through (`LANG=it_IT` gives "venerdì"), add `QLocale::setDefault(QLocale::c());` at the top of that test; check before assuming.

- [ ] **Step 2: Run to verify they fail**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_repeatrule`
Expected: FAIL (the stubs return empty rules).

- [ ] **Step 3: Implement `src/repeatrule.cpp`**

```cpp
/* GPLv2 header */

#include "repeatrule.h"

#include <QCoreApplication>
#include <QLocale>
#include <QMap>

#include <algorithm>

namespace {

// iCalendar weekday codes, indexed by Qt::DayOfWeek - 1.
const char *const kDays[] = { "MO", "TU", "WE", "TH", "FR", "SA", "SU" };

int dayFromCode(const QString &code)
{
    for (int i = 0; i < 7; ++i)
        if (code == QLatin1String(kDays[i]))
            return i + 1;
    return 0;
}

/// Splits "-1FR" into ordinal -1 and Friday. A plain "FR" gives ordinal 0.
bool splitByDay(const QString &token, int *ordinal, int *day)
{
    if (token.size() < 2)
        return false;
    *day = dayFromCode(token.right(2));
    const QString head = token.left(token.size() - 2);
    bool ok = true;
    *ordinal = head.isEmpty() ? 0 : head.toInt(&ok);
    return *day != 0 && ok;
}

// Array literals have no enclosing class, so the context must be named on each
// literal (AGENTS.md: QT_TR_NOOP here compiles and extracts nothing).
const char *const kOrdinals[] = {
    QT_TRANSLATE_NOOP("RepeatRule", "first"),
    QT_TRANSLATE_NOOP("RepeatRule", "second"),
    QT_TRANSLATE_NOOP("RepeatRule", "third"),
    QT_TRANSLATE_NOOP("RepeatRule", "fourth"),
};

QString tr(const char *text) { return QCoreApplication::translate("RepeatRule", text); }

QString ordinalWord(int ordinal)
{
    if (ordinal == -1)
        return tr("last");
    return (ordinal >= 1 && ordinal <= 4) ? tr(kOrdinals[ordinal - 1]) : QString();
}

} // namespace

RepeatRule RepeatRule::fromRRule(const QString &value, const QDate &start)
{
    RepeatRule rule;
    auto markCustom = [&]() {
        RepeatRule custom;
        custom.custom = true;
        custom.customText = value;
        return custom;
    };

    QMap<QString, QString> parts;
    for (const QString &pair : value.split(QLatin1Char(';'), Qt::SkipEmptyParts)) {
        const int eq = pair.indexOf(QLatin1Char('='));
        if (eq <= 0)
            return markCustom();
        parts.insert(pair.left(eq).toUpper(), pair.mid(eq + 1).toUpper());
    }

    const QString freq = parts.take(QStringLiteral("FREQ"));
    if (freq == QLatin1String("DAILY")) rule.freq = Freq::Daily;
    else if (freq == QLatin1String("WEEKLY")) rule.freq = Freq::Weekly;
    else if (freq == QLatin1String("MONTHLY")) rule.freq = Freq::Monthly;
    else if (freq == QLatin1String("YEARLY")) rule.freq = Freq::Yearly;
    else return markCustom();

    if (parts.contains(QStringLiteral("INTERVAL"))) {
        rule.interval = parts.take(QStringLiteral("INTERVAL")).toInt();
        if (rule.interval < 1)
            return markCustom();
    }
    if (parts.contains(QStringLiteral("COUNT"))) {
        rule.end = End::Count;
        rule.count = parts.take(QStringLiteral("COUNT")).toInt();
        if (rule.count < 1)
            return markCustom();
    }
    if (parts.contains(QStringLiteral("UNTIL"))) {
        const QString until = parts.take(QStringLiteral("UNTIL"));
        rule.end = End::Until;
        rule.until = QDate::fromString(until.left(8), QStringLiteral("yyyyMMdd"));
        if (!rule.until.isValid())
            return markCustom();
    }
    rule.wkst = parts.take(QStringLiteral("WKST"));

    const QStringList byDay = parts.contains(QStringLiteral("BYDAY"))
        ? parts.take(QStringLiteral("BYDAY")).split(QLatin1Char(',')) : QStringList();
    const QStringList byMonthDay = parts.contains(QStringLiteral("BYMONTHDAY"))
        ? parts.take(QStringLiteral("BYMONTHDAY")).split(QLatin1Char(',')) : QStringList();
    const QStringList byMonth = parts.contains(QStringLiteral("BYMONTH"))
        ? parts.take(QStringLiteral("BYMONTH")).split(QLatin1Char(',')) : QStringList();

    if (!parts.isEmpty())  // BYSETPOS, BYWEEKNO, BYHOUR, ... : outside the table.
        return markCustom();

    switch (rule.freq) {
    case Freq::Daily:
        if (!byDay.isEmpty() || !byMonthDay.isEmpty() || !byMonth.isEmpty())
            return markCustom();
        break;
    case Freq::Weekly:
        if (!byMonthDay.isEmpty() || !byMonth.isEmpty())
            return markCustom();
        for (const QString &token : byDay) {
            int ordinal = 0, day = 0;
            if (!splitByDay(token, &ordinal, &day) || ordinal != 0)
                return markCustom();
            rule.weekdays.append(day);
        }
        if (rule.weekdays.isEmpty())
            rule.weekdays.append(start.dayOfWeek());
        std::sort(rule.weekdays.begin(), rule.weekdays.end());
        break;
    case Freq::Monthly:
    case Freq::Yearly: {
        const bool yearly = rule.freq == Freq::Yearly;
        if (!byMonthDay.isEmpty() && !byDay.isEmpty())
            return markCustom();
        if (!byDay.isEmpty()) {
            int ordinal = 0, day = 0;
            if (byDay.size() != 1 || !splitByDay(byDay.first(), &ordinal, &day)
                || !(ordinal == -1 || (ordinal >= 1 && ordinal <= 4)))
                return markCustom();
            if (yearly && byMonth.size() != 1)
                return markCustom();
            rule.by = By::Weekday;
            rule.ordinal = ordinal;
            rule.weekday = day;
            if (yearly)
                rule.month = byMonth.first().toInt();
        } else if (yearly) {
            if (!byMonth.isEmpty() || !byMonthDay.isEmpty())
                return markCustom();  // "on the start date" writes neither
        } else {
            if (!byMonth.isEmpty() || byMonthDay.size() > 1)
                return markCustom();
            rule.monthDay = byMonthDay.isEmpty() ? start.day() : byMonthDay.first().toInt();
            if (rule.monthDay < 1 || rule.monthDay > 31)
                return markCustom();
        }
        break;
    }
    case Freq::None:
        break;
    }
    return rule;
}

QString RepeatRule::toRRule(const QString &untilValue) const
{
    if (custom)
        return customText;
    if (freq == Freq::None)
        return {};

    QStringList parts;
    static const char *const kFreq[] = { "", "DAILY", "WEEKLY", "MONTHLY", "YEARLY" };
    parts << QStringLiteral("FREQ=%1").arg(QLatin1String(kFreq[static_cast<int>(freq)]));
    if (interval > 1)
        parts << QStringLiteral("INTERVAL=%1").arg(interval);

    auto byDayToken = [](int ordinal, int day) {
        return (ordinal ? QString::number(ordinal) : QString()) + QLatin1String(kDays[day - 1]);
    };
    if (freq == Freq::Weekly && !weekdays.isEmpty()) {
        QStringList days;
        for (int d : weekdays)
            days << QLatin1String(kDays[d - 1]);
        parts << QStringLiteral("BYDAY=%1").arg(days.join(QLatin1Char(',')));
    } else if (freq == Freq::Monthly) {
        if (by == By::Weekday)
            parts << QStringLiteral("BYDAY=%1").arg(byDayToken(ordinal, weekday));
        else
            parts << QStringLiteral("BYMONTHDAY=%1").arg(monthDay);
    } else if (freq == Freq::Yearly && by == By::Weekday) {
        parts << QStringLiteral("BYMONTH=%1").arg(month)
              << QStringLiteral("BYDAY=%1").arg(byDayToken(ordinal, weekday));
    }

    if (end == End::Count)
        parts << QStringLiteral("COUNT=%1").arg(count);
    else if (end == End::Until)
        parts << QStringLiteral("UNTIL=%1").arg(untilValue);
    if (!wkst.isEmpty())
        parts << QStringLiteral("WKST=%1").arg(wkst);
    return parts.join(QLatin1Char(';'));
}

QString RepeatRule::describe() const
{
    if (custom)
        return tr("Custom rule");
    if (freq == Freq::None)
        return tr("Does not repeat");

    const QLocale locale;
    QString text;
    switch (freq) {
    case Freq::Daily:
        text = interval == 1 ? tr("Daily") : tr("Every %1 days").arg(interval);
        break;
    case Freq::Weekly: {
        QStringList days;
        for (int d : weekdays)
            days << locale.dayName(d, QLocale::ShortFormat);
        text = (interval == 1 ? tr("Weekly") : tr("Every %1 weeks").arg(interval))
               + tr(", on %1").arg(days.join(QStringLiteral(", ")));
        break;
    }
    case Freq::Monthly:
        text = interval == 1 ? tr("Monthly") : tr("Every %1 months").arg(interval);
        text += by == By::Weekday
            ? tr(", on the %1 %2").arg(ordinalWord(ordinal), locale.dayName(weekday))
            : tr(", on day %1").arg(monthDay);
        break;
    case Freq::Yearly:
        text = interval == 1 ? tr("Yearly") : tr("Every %1 years").arg(interval);
        if (by == By::Weekday)
            text += tr(", on the %1 %2 of %3")
                        .arg(ordinalWord(ordinal), locale.dayName(weekday),
                             locale.monthName(month));
        break;
    case Freq::None:
        break;
    }
    if (end == End::Count)
        text += tr(", %1 times").arg(count);
    else if (end == End::Until)
        text += tr(", until %1").arg(locale.toString(until, QLocale::ShortFormat));
    return text;
}

bool RepeatRule::operator==(const RepeatRule &o) const
{
    return freq == o.freq && interval == o.interval && weekdays == o.weekdays
        && by == o.by && monthDay == o.monthDay && ordinal == o.ordinal
        && weekday == o.weekday && month == o.month && end == o.end
        && until == o.until && count == o.count && wkst == o.wkst
        && custom == o.custom && customText == o.customText;
}
```

A trap to check while implementing: in `roundTripsEveryRowOfTheTable`, the "monthly on day" row is `FREQ=MONTHLY;BYMONTHDAY=18`, and `toRRule` writes `BYMONTHDAY` always for `By::MonthDay`, so the round trip holds. A rule read as `FREQ=MONTHLY` with no `BYMONTHDAY` round-trips to `FREQ=MONTHLY;BYMONTHDAY=18`: the text changes, the meaning does not. That is acceptable and is why that row is not in the table test.

- [ ] **Step 4: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_repeatrule`
Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add src/repeatrule.cpp tests/test_repeatrule.cpp
git commit -m "feat: model the calendar's repeat control as RRULE text"
```

---

### Task 4: Expanding occurrences

**Files:**
- Modify: `src/calendarstore.cpp` (`parseEvent`'s recurrence half, `occurrences`)
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
    void expandsAWeeklyEventAcrossDstInItsOwnZone();
    void expandsAnAllDayEventOntoOneDay();
    void removesAnExdate();
    void anOverrideReplacesItsSlotAndMovesFreely();
    void anInfiniteSeriesYieldsOnlyTheWindow();
    void honoursCountAndUntil();
    void expandsMonthlyLastFridayAndYearlyByMonth();
    void readsTheRepeatRuleExdatesAndOverrides();
```

```cpp
namespace {

QList<Occurrence> expand(const QString &body, const QDateTime &from, const QDateTime &to,
                         CalEvent *out = nullptr)
{
    const CalEvent event = parse(body);
    if (out)
        *out = event;
    return CalendarStore::occurrences({ event }, from, to);
}

QDateTime utc(int y, int m, int d, int h = 0, int min = 0)
{
    return QDateTime(QDate(y, m, d), QTime(h, min), QTimeZone::utc());
}

} // namespace

void TestCalendarStore::expandsAWeeklyEventAcrossDstInItsOwnZone()
{
    // 2026-10-25 is the last Sunday of October: Rome leaves CEST (+2) for CET
    // (+1). A weekly 10:00 meeting must stay at 10:00 in Rome on both sides,
    // which means its UTC time MOVES. Expanding in UTC would keep 08:00Z and
    // draw the second one at 09:00 local.
    const QTimeZone rome("Europe/Rome");
    const QList<Occurrence> occ = expand(vevent(QStringLiteral(
        "UID:w@example.org\r\nDTSTART;TZID=Europe/Rome:20261019T100000\r\n"
        "DTEND;TZID=Europe/Rome:20261019T110000\r\nRRULE:FREQ=WEEKLY\r\n")),
        utc(2026, 10, 18), utc(2026, 11, 1));
    QCOMPARE(occ.size(), 2);
    QCOMPARE(occ[0].start.toTimeZone(rome).time(), QTime(10, 0));
    QCOMPARE(occ[1].start.toTimeZone(rome).time(), QTime(10, 0));
    QCOMPARE(occ[0].start.toUTC().time(), QTime(8, 0));
    QCOMPARE(occ[1].start.toUTC().time(), QTime(9, 0));
    QCOMPARE(occ[1].end.toTimeZone(rome).time(), QTime(11, 0));
}

void TestCalendarStore::expandsAnAllDayEventOntoOneDay()
{
    const QList<Occurrence> occ = expand(vevent(QStringLiteral(
        "UID:ad@example.org\r\nDTSTART;VALUE=DATE:20260924\r\nDTEND;VALUE=DATE:20260925\r\n")),
        QDateTime(QDate(2026, 9, 25), QTime(0, 0)), QDateTime(QDate(2026, 9, 26), QTime(0, 0)));
    // The window starts on the 25th, where the event has already ENDED: an
    // inclusive end would draw it on the 25th too.
    QCOMPARE(occ.size(), 0);
}

void TestCalendarStore::removesAnExdate()
{
    const QList<Occurrence> occ = expand(vevent(QStringLiteral(
        "UID:x@example.org\r\nDTSTART:20260921T080000Z\r\nDTEND:20260921T090000Z\r\n"
        "RRULE:FREQ=DAILY\r\nEXDATE:20260922T080000Z\r\n")),
        utc(2026, 9, 21), utc(2026, 9, 24));
    QCOMPARE(occ.size(), 2);
    QCOMPARE(occ[0].start, utc(2026, 9, 21, 8));
    QCOMPARE(occ[1].start, utc(2026, 9, 23, 8));
}

void TestCalendarStore::anOverrideReplacesItsSlotAndMovesFreely()
{
    // A five-day series (21st-25th) whose 22nd is moved to the 30th. A window
    // over the 21st-23rd must NOT show the 22nd, since its slot is taken; a
    // window over the 30th, where the series has no slot at all, MUST show
    // the override, since an override is placed by its own start.
    const QString body = vevent(QStringLiteral(
        "UID:o@example.org\r\nDTSTART:20260921T080000Z\r\nDTEND:20260921T090000Z\r\n"
        "RRULE:FREQ=DAILY;COUNT=5\r\nSUMMARY:Series\r\n"))
        + vevent(QStringLiteral(
        "UID:o@example.org\r\nRECURRENCE-ID:20260922T080000Z\r\n"
        "DTSTART:20260930T150000Z\r\nDTEND:20260930T160000Z\r\nSUMMARY:Moved\r\n"));
    CalEvent event;
    QList<Occurrence> occ = expand(body, utc(2026, 9, 21), utc(2026, 9, 24), &event);
    QCOMPARE(occ.size(), 2);  // the 21st and 23rd
    QCOMPARE(event.overrides.size(), 1);
    QCOMPARE(event.overrides[0].summary, QStringLiteral("Moved"));

    occ = expand(body, utc(2026, 9, 30), utc(2026, 10, 1));
    QCOMPARE(occ.size(), 1);  // COUNT=5 ends on the 25th; only the override is here
    QVERIFY(occ[0].isOverride);
    QCOMPARE(occ[0].start, utc(2026, 9, 30, 15));
    QCOMPARE(occ[0].recurrenceId, utc(2026, 9, 22, 8));
}

void TestCalendarStore::anInfiniteSeriesYieldsOnlyTheWindow()
{
    const QList<Occurrence> occ = expand(vevent(QStringLiteral(
        "UID:inf@example.org\r\nDTSTART:20000101T080000Z\r\nRRULE:FREQ=DAILY\r\n")),
        utc(2026, 9, 1), utc(2026, 9, 8));
    QCOMPARE(occ.size(), 7);
    QCOMPARE(occ.first().start, utc(2026, 9, 1, 8));
}

void TestCalendarStore::honoursCountAndUntil()
{
    QCOMPARE(expand(vevent(QStringLiteral(
        "UID:c@example.org\r\nDTSTART:20260901T080000Z\r\nRRULE:FREQ=DAILY;COUNT=3\r\n")),
        utc(2026, 9, 1), utc(2026, 10, 1)).size(), 3);
    QCOMPARE(expand(vevent(QStringLiteral(
        "UID:u@example.org\r\nDTSTART:20260901T080000Z\r\n"
        "RRULE:FREQ=DAILY;UNTIL=20260905T080000Z\r\n")),
        utc(2026, 9, 1), utc(2026, 10, 1)).size(), 5);
}

void TestCalendarStore::expandsMonthlyLastFridayAndYearlyByMonth()
{
    // Last Fridays: 2026-09-25, 2026-10-30.
    QList<Occurrence> occ = expand(vevent(QStringLiteral(
        "UID:lf@example.org\r\nDTSTART:20260925T080000Z\r\nRRULE:FREQ=MONTHLY;BYDAY=-1FR\r\n")),
        utc(2026, 9, 1), utc(2026, 11, 1));
    QCOMPARE(occ.size(), 2);
    QCOMPARE(occ[1].start.date(), QDate(2026, 10, 30));

    // Last Friday of September: 2026-09-25, 2027-09-24.
    occ = expand(vevent(QStringLiteral(
        "UID:ly@example.org\r\nDTSTART:20260925T080000Z\r\n"
        "RRULE:FREQ=YEARLY;BYMONTH=9;BYDAY=-1FR\r\n")),
        utc(2026, 1, 1), utc(2028, 1, 1));
    QCOMPARE(occ.size(), 2);
    QCOMPARE(occ[1].start.date(), QDate(2027, 9, 24));
}

void TestCalendarStore::readsTheRepeatRuleExdatesAndOverrides()
{
    CalEvent e;
    expand(vevent(QStringLiteral(
        "UID:r@example.org\r\nDTSTART:20260921T080000Z\r\n"
        "RRULE:FREQ=MONTHLY;BYDAY=-1FR\r\nEXDATE:20261030T080000Z\r\n")),
        utc(2026, 9, 1), utc(2026, 9, 2), &e);
    QCOMPARE(e.repeat.freq, RepeatRule::Freq::Monthly);
    QCOMPARE(e.repeat.ordinal, -1);
    QCOMPARE(e.exdates, QList<QDateTime>{ utc(2026, 10, 30, 8) });
}
```

- [ ] **Step 2: Run to verify they fail**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: the eight new tests FAIL (no recurrence read, `occurrences` is a stub).

- [ ] **Step 3: Read recurrence, exceptions and overrides in `parseEvent`**

Replace the `// Recurrence, exceptions and overrides: Task 4.` line:

```cpp
    if (icalproperty *rrule = icalcomponent_get_first_property(master, ICAL_RRULE_PROPERTY)) {
        // The value text rather than icalproperty_get_rrule(): RepeatRule is
        // pure text, and libical re-serialising the struct would reorder parts.
        IcalString value(icalproperty_get_value_as_string_r(rrule));
        event.repeat = RepeatRule::fromRRule(str(value.get()), event.start.date());
    }
    for (icalproperty *ex = icalcomponent_get_first_property(master, ICAL_EXDATE_PROPERTY);
         ex; ex = icalcomponent_get_next_property(master, ICAL_EXDATE_PROPERTY))
        event.exdates.append(toDateTime(icalproperty_get_exdate(ex), tzidOf(ex), unknownZone));

    for (icalcomponent *c = icalcomponent_get_first_component(root.get(), ICAL_VEVENT_COMPONENT);
         c; c = icalcomponent_get_next_component(root.get(), ICAL_VEVENT_COMPONENT)) {
        icalproperty *rid = icalcomponent_get_first_property(c, ICAL_RECURRENCEID_PROPERTY);
        if (c == master || !rid)
            continue;
        CalOverride ov;
        ov.recurrenceId = toDateTime(icalcomponent_get_recurrenceid(c), tzidOf(rid), unknownZone);
        icalproperty *sp = icalcomponent_get_first_property(c, ICAL_DTSTART_PROPERTY);
        const icaltimetype s = icalcomponent_get_dtstart(c);
        ov.allDay = s.is_date;
        ov.start = toDateTime(s, tzidOf(sp), unknownZone);
        ov.end = endOf(c, ov.start, ov.allDay, unknownZone);
        ov.summary = str(icalcomponent_get_summary(c));
        ov.location = str(icalcomponent_get_location(c));
        ov.description = str(icalcomponent_get_description(c));
        ov.cancelled = icalcomponent_get_status(c) == ICAL_STATUS_CANCELLED;
        event.overrides.append(ov);
    }
```

- [ ] **Step 4: Implement `occurrences`**

Expansion re-parses each repeating event's `rawText` so the iterator gets libical's own `icaltimetype` with its zone; the parse costs microseconds and keeps `CalEvent` free of libical. Add to the anonymous namespace:

```cpp
/// ponytail: iterates from DTSTART rather than icalrecur_iterator_set_start,
/// which is unsupported with COUNT. Capped per series; raise the cap only if
/// a real rule is measured hitting it.
constexpr int kMaxIterations = 10000;

bool overlaps(const QDateTime &start, const QDateTime &end,
              const QDateTime &from, const QDateTime &to)
{
    // A zero-length event (no DTEND) still shows on its instant.
    return start < to && (end > from || (end == start && start >= from));
}

/// The occurrence start times of the master in `text`, up to `to`, in the
/// event's own zone and converted after: a weekly 10:00 Rome meeting stays
/// 10:00 in Rome across DST (spec, "Time and recurrence").
QList<QDateTime> seriesStarts(const QByteArray &text, const QDateTime &to)
{
    QList<QDateTime> starts;
    IcalComponent root = parseRoot(text);
    icalcomponent *master = root ? masterOf(root.get()) : nullptr;
    icalproperty *rrule = master ? icalcomponent_get_first_property(master, ICAL_RRULE_PROPERTY) : nullptr;
    if (!rrule)
        return starts;
    icalproperty *startProp = icalcomponent_get_first_property(master, ICAL_DTSTART_PROPERTY);
    const QByteArray tzid = tzidOf(startProp);
    const icaltimetype dtstart = icalcomponent_get_dtstart(master);

    IcalRecurIterator it(icalrecur_iterator_new(icalproperty_get_rrule(rrule), dtstart));
    if (!it)
        return starts;
    for (int i = 0; i < kMaxIterations; ++i) {
        icaltimetype t = icalrecur_iterator_next(it.get());
        if (icaltime_is_null_time(t))
            break;
        t.zone = dtstart.zone;
        t.is_date = dtstart.is_date;
        const QDateTime start = toDateTime(t, tzid, nullptr);
        if (start >= to)
            break;
        starts.append(start);
    }
    return starts;
}

} // namespace (reopen below if the helpers above were added mid-namespace)
```

```cpp
QList<Occurrence> occurrences(const QList<CalEvent> &events,
                              const QDateTime &from, const QDateTime &to)
{
    QList<Occurrence> result;
    for (int i = 0; i < events.size(); ++i) {
        const CalEvent &e = events[i];
        const qint64 length = e.start.msecsTo(e.end);

        if (e.repeat.freq == RepeatRule::Freq::None) {
            if (overlaps(e.start, e.end, from, to))
                result.append({ i, e.start, e.end, e.allDay, {}, false, -1 });
            continue;
        }

        for (const QDateTime &slot : seriesStarts(e.rawText, to)) {
            // An EXDATE or an override takes this slot. Compared as instants:
            // an EXDATE may be written in UTC while DTSTART carries a TZID.
            const auto sameInstant = [&](const QDateTime &d) { return d == slot; };
            if (std::any_of(e.exdates.cbegin(), e.exdates.cend(), sameInstant))
                continue;
            if (std::any_of(e.overrides.cbegin(), e.overrides.cend(),
                            [&](const CalOverride &o) { return o.recurrenceId == slot; }))
                continue;
            const QDateTime end = e.allDay ? slot.addDays(e.start.daysTo(e.end))
                                           : slot.addMSecs(length);
            if (overlaps(slot, end, from, to))
                result.append({ i, slot, end, e.allDay, slot, false, -1 });
        }
        // Placed by their OWN start: an override may move into a window its
        // slot is outside of, or out of the window its slot is in.
        for (int o = 0; o < e.overrides.size(); ++o) {
            const CalOverride &ov = e.overrides[o];
            if (!ov.cancelled && overlaps(ov.start, ov.end, from, to))
                result.append({ i, ov.start, ov.end, ov.allDay, ov.recurrenceId, true, o });
        }
    }
    std::sort(result.begin(), result.end(),
              [](const Occurrence &a, const Occurrence &b) { return a.start < b.start; });
    return result;
}
```

Two things to check against the tests rather than trust: all-day slots add whole DAYS (`addDays`), never milliseconds, because a day across a DST change is 23 or 25 hours; and `QDateTime::operator==` compares instants across zones, which is what the EXDATE and override matching needs.

- [ ] **Step 5: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: all PASS. If the DST test fails with both at 08:00Z, the iterator lost the zone: check `t.zone = dtstart.zone` and that `toDateTime` receives the TZID.

- [ ] **Step 6: Commit**

```bash
git add src/calendarstore.cpp tests/test_calendarstore.cpp
git commit -m "feat: expand calendar occurrences in each event's own zone"
```

---

### Task 5: Who may edit an event

**Files:**
- Modify: `src/calendarstore.cpp` (`isEditable`)
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Write the failing test**

```cpp
    void editableOnlyWhenTheUserOrganisesIt();
```

```cpp
void TestCalendarStore::editableOnlyWhenTheUserOrganisesIt()
{
    const QStringList own = { QStringLiteral("me@example.org"), QStringLiteral("alt@example.org") };
    CalCollection writable;
    writable.dir = QStringLiteral("x");
    CalCollection readOnly = writable;
    readOnly.readOnly = true;

    const CalEvent mine = parse(vevent(QStringLiteral(
        "UID:1@example.org\r\nDTSTART:20260922T080000Z\r\n"
        "ORGANIZER;CN=Me:mailto:ME@Example.org\r\n"
        "ATTENDEE;CN=Other;PARTSTAT=ACCEPTED:mailto:other@example.org\r\n")));
    const CalEvent theirs = parse(vevent(QStringLiteral(
        "UID:2@example.org\r\nDTSTART:20260922T080000Z\r\n"
        "ORGANIZER;CN=Other:mailto:other@example.org\r\n"
        "ATTENDEE:mailto:me@example.org\r\n")));
    const CalEvent nobodys = parse(vevent(QStringLiteral(
        "UID:3@example.org\r\nDTSTART:20260922T080000Z\r\n")));

    // Case-insensitive, and "mailto:" is not part of the address.
    QVERIFY(CalendarStore::isEditable(mine, writable, own));
    QVERIFY(!CalendarStore::isEditable(theirs, writable, own));
    QVERIFY(CalendarStore::isEditable(nobodys, writable, own));
    QVERIFY(!CalendarStore::isEditable(nobodys, readOnly, own));

    QCOMPARE(mine.organizer.name, QStringLiteral("Me"));
    QCOMPARE(mine.attendees.size(), 1);
    QCOMPARE(mine.attendees[0].partstat, QStringLiteral("ACCEPTED"));
    QCOMPARE(mine.attendees[0].address, QStringLiteral("other@example.org"));
}
```

- [ ] **Step 2: Run to verify it fails**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: FAIL on the first `QVERIFY` (the stub returns false).

- [ ] **Step 3: Implement**

```cpp
bool isEditable(const CalEvent &event, const CalCollection &collection,
                const QStringList &ownAddresses)
{
    if (collection.readOnly)
        return false;
    if (event.organizer.address.isEmpty())
        return true;
    return ownAddresses.contains(event.organizer.address, Qt::CaseInsensitive);
}
```

- [ ] **Step 4: Run to verify it passes**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add src/calendarstore.cpp tests/test_calendarstore.cpp
git commit -m "feat: an event is editable only when the user organises it"
```

---

### Task 6: Editing a whole event, and writing a new one

**Files:**
- Modify: `src/calendarstore.cpp` (`applyEdit` for `Scope::All`, `newEvent`, `sameMeaning`)
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
    void anEditKeepsWhatTheFormDoesNotOwn();
    void anEditKeepsTheEventsZone();
    void anEditRewritesTheRepeatRuleButNeverACustomOne();
    void anEditCanTurnAnEventAllDayAndBack();
    void aNewEventIsCompleteAndEmbedsItsZone();
    void sameMeaningIgnoresFormatting();
```

```cpp
namespace {

EventEdit editOf(const CalEvent &e)
{
    EventEdit edit;
    edit.summary = e.summary;
    edit.location = e.location;
    edit.description = e.description;
    edit.start = e.start;
    edit.end = e.end;
    edit.allDay = e.allDay;
    edit.repeat = e.repeat;
    edit.collectionDir = e.collectionDir;
    return edit;
}

CalEvent reparse(const QByteArray &text)
{
    bool unknown = false;
    return CalendarStore::parseEvent(text, QStringLiteral("/x/e.ics"), QStringLiteral("x"), &unknown);
}

const QString kRichEvent = QStringLiteral(
    "UID:rich@example.org\r\nDTSTAMP:20260901T000000Z\r\nSEQUENCE:2\r\n"
    "DTSTART;TZID=Europe/Rome:20260922T100000\r\nDTEND;TZID=Europe/Rome:20260922T110000\r\n"
    "SUMMARY:Review\r\nORGANIZER;CN=Me:mailto:me@example.org\r\n"
    "ATTENDEE;CN=Other;PARTSTAT=ACCEPTED:mailto:other@example.org\r\n"
    "X-EXAMPLE-FLAG:keep me\r\n"
    "BEGIN:VALARM\r\nACTION:DISPLAY\r\nDESCRIPTION:Reminder\r\nTRIGGER:-PT15M\r\nEND:VALARM\r\n");

} // namespace

void TestCalendarStore::anEditKeepsWhatTheFormDoesNotOwn()
{
    const CalEvent before = parse(vevent(kRichEvent));
    EventEdit edit = editOf(before);
    edit.summary = QStringLiteral("Review, moved");
    const QByteArray after = CalendarStore::applyEdit(
        before.rawText, edit, CalendarStore::Scope::All, {});
    QVERIFY(!after.isEmpty());

    const CalEvent e = reparse(after);
    QCOMPARE(e.summary, QStringLiteral("Review, moved"));
    QCOMPARE(e.uid, before.uid);
    QCOMPARE(e.sequence, 3);  // bumped
    // Value for value, not byte for byte: libical re-serialises (plan ruling 2).
    QVERIFY(e.hasAlarm);
    QVERIFY(after.contains("TRIGGER:-PT15M"));
    QVERIFY(after.contains("X-EXAMPLE-FLAG:keep me"));
    QCOMPARE(e.attendees.size(), 1);
    QCOMPARE(e.attendees[0].partstat, QStringLiteral("ACCEPTED"));
    QVERIFY(after.contains("LAST-MODIFIED:"));
}

void TestCalendarStore::anEditKeepsTheEventsZone()
{
    // The source has NO VTIMEZONE, as 120 of the user's files do: the TZID
    // must still be written back, not converted to UTC or floating.
    const CalEvent before = parse(vevent(kRichEvent));
    EventEdit edit = editOf(before);
    edit.start = before.start.addSecs(3600);
    edit.end = before.end.addSecs(3600);
    const QByteArray after = CalendarStore::applyEdit(before.rawText, edit, CalendarStore::Scope::All, {});
    QVERIFY2(after.contains("DTSTART;TZID=Europe/Rome:20260922T110000"), after.constData());
    QCOMPARE(reparse(after).start, edit.start);
}

void TestCalendarStore::anEditRewritesTheRepeatRuleButNeverACustomOne()
{
    const CalEvent weekly = parse(vevent(QStringLiteral(
        "UID:r@example.org\r\nDTSTART:20260921T080000Z\r\nRRULE:FREQ=WEEKLY;WKST=MO\r\n")));
    EventEdit edit = editOf(weekly);
    edit.repeat = RepeatRule::fromRRule(QStringLiteral("FREQ=MONTHLY;BYDAY=-1FR"), weekly.start.date());
    QByteArray after = CalendarStore::applyEdit(weekly.rawText, edit, CalendarStore::Scope::All, {});
    QCOMPARE(reparse(after).repeat.toRRule(), QStringLiteral("FREQ=MONTHLY;BYDAY=-1FR"));
    QCOMPARE(after.count("RRULE"), 1);

    const CalEvent custom = parse(vevent(QStringLiteral(
        "UID:c@example.org\r\nDTSTART:20260921T080000Z\r\n"
        "RRULE:FREQ=MONTHLY;BYDAY=MO,TU,WE,TH,FR;BYSETPOS=-1\r\n")));
    edit = editOf(custom);
    edit.summary = QStringLiteral("Renamed");
    after = CalendarStore::applyEdit(custom.rawText, edit, CalendarStore::Scope::All, {});
    QVERIFY(after.contains("BYSETPOS=-1"));

    edit.repeat = RepeatRule();  // Does not repeat
    after = CalendarStore::applyEdit(custom.rawText, edit, CalendarStore::Scope::All, {});
    QVERIFY(!after.contains("RRULE"));
}

void TestCalendarStore::anEditCanTurnAnEventAllDayAndBack()
{
    const CalEvent timed = parse(vevent(kRichEvent));
    EventEdit edit = editOf(timed);
    edit.allDay = true;
    edit.start = QDateTime(QDate(2026, 9, 22), QTime(0, 0));
    edit.end = QDateTime(QDate(2026, 9, 23), QTime(0, 0));
    const QByteArray allDay = CalendarStore::applyEdit(timed.rawText, edit, CalendarStore::Scope::All, {});
    QVERIFY(allDay.contains("DTSTART;VALUE=DATE:20260922"));
    QVERIFY(allDay.contains("DTEND;VALUE=DATE:20260923"));

    const CalEvent back = reparse(allDay);
    edit = editOf(back);
    edit.allDay = false;
    edit.start = QDateTime(QDate(2026, 9, 22), QTime(9, 0), QTimeZone("Europe/Rome"));
    edit.end = edit.start.addSecs(3600);
    const QByteArray timedAgain = CalendarStore::applyEdit(allDay, edit, CalendarStore::Scope::All, {});
    const CalEvent e = reparse(timedAgain);
    QVERIFY(!e.allDay);
    QCOMPARE(e.start, edit.start);
}

void TestCalendarStore::aNewEventIsCompleteAndEmbedsItsZone()
{
    EventEdit edit;
    edit.summary = QStringLiteral("Dentist");
    edit.start = QDateTime(QDate(2026, 9, 24), QTime(15, 0), QTimeZone("Europe/Rome"));
    edit.end = edit.start.addSecs(1800);
    const QByteArray text = CalendarStore::newEvent(edit, "Europe/Rome");
    QVERIFY(text.contains("BEGIN:VCALENDAR"));
    QVERIFY(text.contains("PRODID:-//qtmaildir//EN"));
    QVERIFY(text.contains("BEGIN:VTIMEZONE"));
    QVERIFY(text.contains("TZID:Europe/Rome"));
    QVERIFY(text.contains("SEQUENCE:0"));
    QVERIFY(text.contains("DTSTAMP:"));
    const CalEvent e = reparse(text);
    QVERIFY(!e.uid.isEmpty());
    QCOMPARE(e.summary, QStringLiteral("Dentist"));
    QCOMPARE(e.start, edit.start);
    QCOMPARE(e.end, edit.end);

    // Two new events never share a UID.
    QVERIFY(reparse(CalendarStore::newEvent(edit, "Europe/Rome")).uid != e.uid);
}

void TestCalendarStore::sameMeaningIgnoresFormatting()
{
    const QByteArray a = ics(vevent(QStringLiteral(
        "UID:s@example.org\r\nDTSTART:20260922T080000Z\r\nSUMMARY:Standup\r\n")));
    // Folded, properties reordered, DTSTAMP added: what a server may send back.
    const QByteArray b = ics(vevent(QStringLiteral(
        "SUMMARY:Stand\r\n up\r\nDTSTAMP:20260930T000000Z\r\n"
        "DTSTART:20260922T080000Z\r\nUID:s@example.org\r\n")));
    const QByteArray moved = ics(vevent(QStringLiteral(
        "UID:s@example.org\r\nDTSTART:20260922T090000Z\r\nSUMMARY:Standup\r\n")));
    QVERIFY(CalendarStore::sameMeaning(a, b));
    QVERIFY(!CalendarStore::sameMeaning(a, moved));
}
```

- [ ] **Step 2: Run to verify they fail**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: the six new tests FAIL.

- [ ] **Step 3: Implement the write helpers**

Add `#include <QUuid>` and add to the anonymous namespace in `calendarstore.cpp`:

```cpp
/// How a component's times are written, read off its DTSTART and reused for
/// every time written back, so an edit keeps the event's zone.
struct TimeForm
{
    enum Kind { Date, Utc, Zoned, Floating } kind = Floating;
    QByteArray tzid;
    icaltimezone *zone = nullptr;  ///< Embedded or built-in; not owned.
};

TimeForm formOf(icalcomponent *root, icalcomponent *c)
{
    TimeForm form;
    icalproperty *prop = icalcomponent_get_first_property(c, ICAL_DTSTART_PROPERTY);
    const icaltimetype t = icalcomponent_get_dtstart(c);
    if (t.is_date) {
        form.kind = TimeForm::Date;
    } else if (icaltime_is_utc(t)) {
        form.kind = TimeForm::Utc;
    } else if (!tzidOf(prop).isEmpty()) {
        form.kind = TimeForm::Zoned;
        form.tzid = tzidOf(prop);
        form.zone = icalcomponent_get_timezone(root, form.tzid.constData());
        if (!form.zone)
            form.zone = icaltimezone_get_builtin_timezone(form.tzid.constData());
    }
    return form;
}

TimeForm zonedForm(const QByteArray &tzid)
{
    TimeForm form;
    form.kind = TimeForm::Zoned;
    form.tzid = tzid;
    form.zone = icaltimezone_get_builtin_timezone(tzid.constData());
    return form;
}

/// A QDateTime as the wall-clock icaltimetype `form` writes, zone left unset:
/// the TZID travels as a parameter, so the output never depends on whether
/// the file carried a VTIMEZONE.
icaltimetype wallTime(const QDateTime &dt, const TimeForm &form)
{
    if (form.kind == TimeForm::Date) {
        icaltimetype t = icaltime_null_date();
        const QDate d = dt.date();
        t.year = d.year(); t.month = d.month(); t.day = d.day();
        return t;
    }
    QDateTime local;
    if (form.kind == TimeForm::Utc) {
        local = dt.toUTC();
    } else if (form.kind == TimeForm::Zoned && form.zone) {
        icaltimetype t = icaltime_from_timet_with_zone(dt.toSecsSinceEpoch(), 0, form.zone);
        t.zone = nullptr;
        return t;
    } else if (form.kind == TimeForm::Zoned && QTimeZone(form.tzid).isValid()) {
        local = dt.toTimeZone(QTimeZone(form.tzid));
    } else {
        local = dt.toLocalTime();
    }
    icaltimetype t = icaltime_null_time();
    t.is_date = 0;
    t.year = local.date().year(); t.month = local.date().month(); t.day = local.date().day();
    t.hour = local.time().hour(); t.minute = local.time().minute(); t.second = local.time().second();
    if (form.kind == TimeForm::Utc)
        t = icaltime_convert_to_zone(t, icaltimezone_get_utc_timezone());
    return t;
}
```

Check `icaltime_convert_to_zone` on a zone-less time before trusting the UTC branch: if it does not mark the result UTC, set `t.zone = icaltimezone_get_utc_timezone()` directly instead. The test `aNewEventIsCompleteAndEmbedsItsZone` does not cover UTC; `anEditKeepsWhatTheFormDoesNotOwn` edits a zoned event. Add a UTC edit assertion if the branch is changed.

```cpp
/// Replaces every `kind` property on `c` with one holding `dt` in `form`.
/// DTSTART, DTEND and RECURRENCE-ID only: EXDATE is ADDITIVE, and replacing
/// it would drop every exception but the newest (deleteOccurrence adds its
/// own).
void setTime(icalcomponent *c, icalproperty_kind kind, const QDateTime &dt, const TimeForm &form)
{
    while (icalproperty *old = icalcomponent_get_first_property(c, kind)) {
        icalcomponent_remove_property(c, old);
        icalproperty_free(old);
    }
    const icaltimetype t = wallTime(dt, form);
    icalproperty *prop = kind == ICAL_DTSTART_PROPERTY ? icalproperty_new_dtstart(t)
                       : kind == ICAL_DTEND_PROPERTY   ? icalproperty_new_dtend(t)
                                                       : icalproperty_new_recurrenceid(t);
    if (form.kind == TimeForm::Zoned)
        icalproperty_add_parameter(prop, icalparameter_new_tzid(form.tzid.constData()));
    icalcomponent_add_property(c, prop);
}

void removeAll(icalcomponent *c, icalproperty_kind kind)
{
    while (icalproperty *p = icalcomponent_get_first_property(c, kind)) {
        icalcomponent_remove_property(c, p);
        icalproperty_free(p);
    }
}

void setText(icalcomponent *c, icalproperty_kind kind, const QString &value)
{
    removeAll(c, kind);
    if (value.isEmpty())
        return;
    const QByteArray utf8 = value.toUtf8();
    icalproperty *p = kind == ICAL_SUMMARY_PROPERTY ? icalproperty_new_summary(utf8.constData())
                    : kind == ICAL_LOCATION_PROPERTY ? icalproperty_new_location(utf8.constData())
                                                     : icalproperty_new_description(utf8.constData());
    icalcomponent_add_property(c, p);
}

/// Embeds the VTIMEZONE for `tzid` from libical's built-in database unless
/// the calendar already carries one, so what this application writes is
/// RFC-correct even where what it read was not.
void ensureVtimezone(icalcomponent *root, const QByteArray &tzid)
{
    if (tzid.isEmpty() || icalcomponent_get_timezone(root, tzid.constData()))
        return;
    icaltimezone *zone = icaltimezone_get_builtin_timezone(tzid.constData());
    if (!zone)
        return;
    icalcomponent *vtz = icalcomponent_new_clone(icaltimezone_get_component(zone));
    // libical's built-in components carry a "/citadel.org/..." style TZID;
    // rewrite it to the plain IANA name the events reference.
    removeAll(vtz, ICAL_TZID_PROPERTY);
    icalcomponent_add_property(vtz, icalproperty_new_tzid(tzid.constData()));
    icalcomponent_add_component(root, vtz);
}

void stamp(icalcomponent *c, bool bumpSequence)
{
    const icaltimetype now = icaltime_current_time_with_zone(icaltimezone_get_utc_timezone());
    removeAll(c, ICAL_DTSTAMP_PROPERTY);
    icalcomponent_add_property(c, icalproperty_new_dtstamp(now));
    removeAll(c, ICAL_LASTMODIFIED_PROPERTY);
    icalcomponent_add_property(c, icalproperty_new_lastmodified(now));
    if (bumpSequence)
        icalcomponent_set_sequence(c, icalcomponent_get_sequence(c) + 1);
}

/// The form a written time takes after an edit: all-day is a date; a timed
/// event keeps its zone, or takes the system zone when it was all-day.
TimeForm editedForm(icalcomponent *root, icalcomponent *c, bool allDay)
{
    if (allDay) {
        TimeForm date;
        date.kind = TimeForm::Date;
        return date;
    }
    TimeForm form = formOf(root, c);
    if (form.kind == TimeForm::Date) {
        form = zonedForm(QTimeZone::systemTimeZoneId());
        ensureVtimezone(root, form.tzid);
    }
    return form;
}

/// Writes the fields the form owns onto `c`. RRULE only for a master.
void writeFields(icalcomponent *root, icalcomponent *c, const EventEdit &edit, bool master)
{
    setText(c, ICAL_SUMMARY_PROPERTY, edit.summary);
    setText(c, ICAL_LOCATION_PROPERTY, edit.location);
    setText(c, ICAL_DESCRIPTION_PROPERTY, edit.description);
    const TimeForm form = editedForm(root, c, edit.allDay);
    removeAll(c, ICAL_DURATION_PROPERTY);
    setTime(c, ICAL_DTSTART_PROPERTY, edit.start, form);
    setTime(c, ICAL_DTEND_PROPERTY, edit.end, form);

    if (!master || edit.repeat.custom)
        return;  // a custom RRULE is never rewritten (spec, repeat control)
    removeAll(c, ICAL_RRULE_PROPERTY);
    if (edit.repeat.freq == RepeatRule::Freq::None)
        return;
    // UNTIL follows DTSTART's type: a DATE for all-day, else UTC (RFC 5545).
    QString until;
    if (edit.repeat.end == RepeatRule::End::Until) {
        until = edit.allDay
            ? edit.repeat.until.toString(QStringLiteral("yyyyMMdd"))
            : QDateTime(edit.repeat.until, QTime(23, 59, 59),
                        form.kind == TimeForm::Zoned && QTimeZone(form.tzid).isValid()
                            ? QTimeZone(form.tzid) : QTimeZone::systemTimeZone())
                  .toUTC().toString(QStringLiteral("yyyyMMdd'T'HHmmss'Z'"));
    }
    const QByteArray rule = "RRULE:" + edit.repeat.toRRule(until).toUtf8();
    icalcomponent_add_property(c, icalproperty_new_from_string(rule.constData()));
}

QByteArray serialise(icalcomponent *root)
{
    IcalString text(icalcomponent_as_ical_string_r(root));
    return text ? QByteArray(text.get()) : QByteArray();
}
```

- [ ] **Step 4: Implement `applyEdit` (All only for now), `newEvent`, `sameMeaning`**

```cpp
QByteArray applyEdit(const QByteArray &text, const EventEdit &edit,
                     Scope scope, const QDateTime &recurrenceId)
{
    IcalComponent root = parseRoot(text);
    icalcomponent *master = root ? masterOf(root.get()) : nullptr;
    if (!master)
        return {};
    icalcomponent *target = master;
    if (scope == Scope::ThisOccurrence)
        target = overrideFor(root.get(), master, recurrenceId);  // Task 7
    writeFields(root.get(), target, edit, target == master);
    stamp(target, true);
    return serialise(root.get());
}

QByteArray newEvent(const EventEdit &edit, const QByteArray &zoneId)
{
    IcalComponent root(icalcomponent_new(ICAL_VCALENDAR_COMPONENT));
    icalcomponent_add_property(root.get(), icalproperty_new_version("2.0"));
    icalcomponent_add_property(root.get(), icalproperty_new_prodid("-//qtmaildir//EN"));
    icalcomponent *event = icalcomponent_new(ICAL_VEVENT_COMPONENT);
    icalcomponent_add_component(root.get(), event);
    icalcomponent_set_uid(event, QUuid::createUuid()
                                     .toString(QUuid::WithoutBraces).toUtf8().constData());
    // A DTSTART must exist before editedForm() reads it; a date one makes the
    // form fall through to the system zone for a timed event, which is
    // exactly the rule for new events, so pass the requested zone instead.
    if (!edit.allDay) {
        ensureVtimezone(root.get(), zoneId);
        setTime(event, ICAL_DTSTART_PROPERTY, edit.start, zonedForm(zoneId));
    } else {
        TimeForm date;
        date.kind = TimeForm::Date;
        setTime(event, ICAL_DTSTART_PROPERTY, edit.start, date);
    }
    writeFields(root.get(), event, edit, true);
    icalcomponent_set_sequence(event, 0);
    stamp(event, false);
    return serialise(root.get());
}

bool sameMeaning(const QByteArray &a, const QByteArray &b)
{
    bool ignored = false;
    const CalEvent x = parseEvent(a, {}, {}, &ignored);
    const CalEvent y = parseEvent(b, {}, {}, &ignored);
    if (x.uid.isEmpty() || y.uid.isEmpty())
        return x.uid.isEmpty() && y.uid.isEmpty();
    if (x.overrides.size() != y.overrides.size())
        return false;
    for (int i = 0; i < x.overrides.size(); ++i) {
        const CalOverride &p = x.overrides[i], &q = y.overrides[i];
        if (p.recurrenceId != q.recurrenceId || p.start != q.start
            || p.end != q.end || p.summary != q.summary || p.cancelled != q.cancelled)
            return false;
    }
    return x.summary == y.summary && x.start == y.start && x.end == y.end
        && x.allDay == y.allDay && x.repeat == y.repeat && x.exdates == y.exdates;
}
```

`applyEdit` references `overrideFor`, which Task 7 writes. For this task add a placeholder in the anonymous namespace that returns the master, so the library links:

```cpp
icalcomponent *overrideFor(icalcomponent *, icalcomponent *master, const QDateTime &)
{
    return master;  // replaced in Task 7
}
```

- [ ] **Step 5: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: all PASS. Likely snags, each a libical API detail to check in `/usr/include/libical/`: the built-in zone's own TZID (the `ensureVtimezone` rewrite); `icalproperty_new_from_string` needing the `RRULE:` prefix; and `icaltime_from_timet_with_zone` producing a date when its second argument is non-zero.

- [ ] **Step 6: Commit**

```bash
git add src/calendarstore.cpp tests/test_calendarstore.cpp
git commit -m "feat: edit a calendar event in place and write new ones"
```

---

### Task 7: One occurrence: override and delete

**Files:**
- Modify: `src/calendarstore.cpp` (`overrideFor`, `deleteOccurrence`)
- Test: `tests/test_calendarstore.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
    void editingOneOccurrenceWritesAnOverride();
    void editingTheSameOccurrenceAgainReplacesItsOverride();
    void deletingOneOccurrenceAddsAnExdateAndDropsItsOverride();
```

```cpp
namespace {

const QString kDailySeries = QStringLiteral(
    "UID:d@example.org\r\nDTSTAMP:20260901T000000Z\r\n"
    "DTSTART;TZID=Europe/Rome:20260921T100000\r\nDTEND;TZID=Europe/Rome:20260921T110000\r\n"
    "RRULE:FREQ=DAILY;COUNT=5\r\nSUMMARY:Daily\r\n");

QDateTime rome(int d, int h)
{
    return QDateTime(QDate(2026, 9, d), QTime(h, 0), QTimeZone("Europe/Rome"));
}

} // namespace

void TestCalendarStore::editingOneOccurrenceWritesAnOverride()
{
    const CalEvent series = parse(vevent(kDailySeries));
    EventEdit edit = editOf(series);
    edit.summary = QStringLiteral("Just this one");
    edit.start = rome(22, 15);
    edit.end = rome(22, 16);
    const QByteArray after = CalendarStore::applyEdit(
        series.rawText, edit, CalendarStore::Scope::ThisOccurrence, rome(22, 10));

    const CalEvent e = reparse(after);
    QCOMPARE(e.summary, QStringLiteral("Daily"));          // master untouched
    QCOMPARE(e.repeat.count, 5);
    QCOMPARE(e.overrides.size(), 1);
    QCOMPARE(e.overrides[0].recurrenceId, rome(22, 10));
    QCOMPARE(e.overrides[0].summary, QStringLiteral("Just this one"));
    QCOMPARE(after.count("RRULE"), 1);                     // the override carries none

    const QList<Occurrence> occ = CalendarStore::occurrences(
        { e }, rome(21, 0), rome(26, 0));
    QCOMPARE(occ.size(), 5);                               // still five, one moved
    QVERIFY(std::any_of(occ.cbegin(), occ.cend(),
                        [](const Occurrence &o) { return o.isOverride && o.start == rome(22, 15); }));
}

void TestCalendarStore::editingTheSameOccurrenceAgainReplacesItsOverride()
{
    const CalEvent series = parse(vevent(kDailySeries));
    EventEdit edit = editOf(series);
    edit.start = rome(22, 15);
    edit.end = rome(22, 16);
    QByteArray text = CalendarStore::applyEdit(
        series.rawText, edit, CalendarStore::Scope::ThisOccurrence, rome(22, 10));
    edit.start = rome(22, 17);
    edit.end = rome(22, 18);
    text = CalendarStore::applyEdit(text, edit, CalendarStore::Scope::ThisOccurrence, rome(22, 10));
    const CalEvent e = reparse(text);
    QCOMPARE(e.overrides.size(), 1);
    QCOMPARE(e.overrides[0].start, rome(22, 17));
}

void TestCalendarStore::deletingOneOccurrenceAddsAnExdateAndDropsItsOverride()
{
    const CalEvent series = parse(vevent(kDailySeries));
    EventEdit edit = editOf(series);
    edit.start = rome(23, 15);
    edit.end = rome(23, 16);
    const QByteArray withOverride = CalendarStore::applyEdit(
        series.rawText, edit, CalendarStore::Scope::ThisOccurrence, rome(23, 10));

    const QByteArray after = CalendarStore::deleteOccurrence(withOverride, rome(23, 10));
    const CalEvent e = reparse(after);
    QCOMPARE(e.overrides.size(), 0);
    QCOMPARE(e.exdates, QList<QDateTime>{ rome(23, 10) });
    QVERIFY2(after.contains("EXDATE;TZID=Europe/Rome:20260923T100000"), after.constData());
    QCOMPARE(CalendarStore::occurrences({ e }, rome(21, 0), rome(26, 0)).size(), 4);
}
```

Add `#include <algorithm>` to the test's includes.

- [ ] **Step 2: Run to verify they fail**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: the three new tests FAIL (the placeholder edits the master).

- [ ] **Step 3: Implement `overrideFor` and `deleteOccurrence`**

Replace the Task 6 placeholder:

```cpp
/// The override component for `recurrenceId`, created when absent: a copy of
/// the master without RRULE, RDATE or EXDATE, carrying a RECURRENCE-ID in the
/// master's own time form.
icalcomponent *overrideFor(icalcomponent *root, icalcomponent *master,
                           const QDateTime &recurrenceId)
{
    for (icalcomponent *c = icalcomponent_get_first_component(root, ICAL_VEVENT_COMPONENT);
         c; c = icalcomponent_get_next_component(root, ICAL_VEVENT_COMPONENT)) {
        icalproperty *rid = icalcomponent_get_first_property(c, ICAL_RECURRENCEID_PROPERTY);
        if (c != master && rid
            && toDateTime(icalcomponent_get_recurrenceid(c), tzidOf(rid), nullptr) == recurrenceId)
            return c;
    }
    icalcomponent *copy = icalcomponent_new_clone(master);
    removeAll(copy, ICAL_RRULE_PROPERTY);
    removeAll(copy, ICAL_RDATE_PROPERTY);
    removeAll(copy, ICAL_EXDATE_PROPERTY);
    setTime(copy, ICAL_RECURRENCEID_PROPERTY, recurrenceId, formOf(root, master));
    icalcomponent_add_component(root, copy);
    return copy;
}
```

In `deleteOccurrence`, remove the matching override component and add the EXDATE:

```cpp
QByteArray deleteOccurrence(const QByteArray &text, const QDateTime &recurrenceId)
{
    IcalComponent root = parseRoot(text);
    icalcomponent *master = root ? masterOf(root.get()) : nullptr;
    if (!master)
        return {};
    // Collect first: removing a component mid-walk invalidates the iterator.
    QList<icalcomponent *> doomed;
    for (icalcomponent *c = icalcomponent_get_first_component(root.get(), ICAL_VEVENT_COMPONENT);
         c; c = icalcomponent_get_next_component(root.get(), ICAL_VEVENT_COMPONENT)) {
        icalproperty *rid = icalcomponent_get_first_property(c, ICAL_RECURRENCEID_PROPERTY);
        if (c != master && rid
            && toDateTime(icalcomponent_get_recurrenceid(c), tzidOf(rid), nullptr) == recurrenceId)
            doomed.append(c);
    }
    for (icalcomponent *c : doomed) {
        icalcomponent_remove_component(root.get(), c);
        icalcomponent_free(c);
    }
    // setTime replaces every property of its kind, which for EXDATE would
    // drop the existing ones: add this one alongside instead.
    const TimeForm form = formOf(root.get(), master);
    icalproperty *ex = icalproperty_new_exdate(wallTime(recurrenceId, form));
    if (form.kind == TimeForm::Zoned)
        icalproperty_add_parameter(ex, icalparameter_new_tzid(form.tzid.constData()));
    icalcomponent_add_property(master, ex);
    stamp(master, true);
    return serialise(root.get());
}
```

- [ ] **Step 4: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore`
Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add src/calendarstore.cpp tests/test_calendarstore.cpp
git commit -m "feat: edit or delete one occurrence of a repeating event"
```

---

### Task 8: `CalendarWriter`

**Files:**
- Create: `src/calendarwriter.h`, `src/calendarwriter.cpp`
- Modify: `src/CMakeLists.txt` (add `calendarwriter.cpp`), `tests/CMakeLists.txt` (`add_qtmaildir_test(calendarwriter)`)
- Test: `tests/test_calendarwriter.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
/* GPLv2 header */

#include <QtTest>
#include <QDir>
#include <QFile>
#include <QTemporaryDir>

#include "calendarwriter.h"

namespace {

QByteArray read(const QString &path)
{
    QFile f(path);
    return f.open(QIODevice::ReadOnly) ? f.readAll() : QByteArray();
}

} // namespace

class TestCalendarWriter : public QObject
{
    Q_OBJECT

private slots:
    void createsAFileThatDidNotExist();
    void refusesToCreateOverAnExistingFile();
    void replacesWhenTheFileIsWhatWasExpected();
    void refusesWhenTheFileChangedUnderneath();
    void deletes();
    void leavesNoTemporaryFileBehind();
};

void TestCalendarWriter::createsAFileThatDidNotExist()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QString error;
    QCOMPARE(CalendarWriter::replace(path, std::nullopt, QByteArray("new"), &error),
             CalendarWriter::Result::Ok);
    QCOMPARE(read(path), QByteArray("new"));
}

void TestCalendarWriter::refusesToCreateOverAnExistingFile()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QFile f(path);
    QVERIFY(f.open(QIODevice::WriteOnly));
    f.write("synced in meanwhile");
    f.close();
    QString error;
    QCOMPARE(CalendarWriter::replace(path, std::nullopt, QByteArray("new"), &error),
             CalendarWriter::Result::Stale);
    QCOMPARE(read(path), QByteArray("synced in meanwhile"));
}

void TestCalendarWriter::replacesWhenTheFileIsWhatWasExpected()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QString error;
    CalendarWriter::replace(path, std::nullopt, QByteArray("one"), &error);
    QCOMPARE(CalendarWriter::replace(path, QByteArray("one"), QByteArray("two"), &error),
             CalendarWriter::Result::Ok);
    QCOMPARE(read(path), QByteArray("two"));
}

void TestCalendarWriter::refusesWhenTheFileChangedUnderneath()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QString error;
    CalendarWriter::replace(path, std::nullopt, QByteArray("synced"), &error);
    // The caller loaded "one"; a sync wrote "synced" since. Nothing is clobbered.
    QCOMPARE(CalendarWriter::replace(path, QByteArray("one"), QByteArray("two"), &error),
             CalendarWriter::Result::Stale);
    QCOMPARE(read(path), QByteArray("synced"));
    // Also stale: expecting a file that a sync has removed.
    QFile::remove(path);
    QCOMPARE(CalendarWriter::replace(path, QByteArray("synced"), QByteArray("two"), &error),
             CalendarWriter::Result::Stale);
    QVERIFY(!QFile::exists(path));
}

void TestCalendarWriter::deletes()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QString error;
    CalendarWriter::replace(path, std::nullopt, QByteArray("one"), &error);
    QCOMPARE(CalendarWriter::replace(path, QByteArray("one"), std::nullopt, &error),
             CalendarWriter::Result::Ok);
    QVERIFY(!QFile::exists(path));
}

void TestCalendarWriter::leavesNoTemporaryFileBehind()
{
    QTemporaryDir dir;
    const QString path = dir.filePath(QStringLiteral("a.ics"));
    QString error;
    CalendarWriter::replace(path, std::nullopt, QByteArray("one"), &error);
    CalendarWriter::replace(path, QByteArray("one"), QByteArray("two"), &error);
    QCOMPARE(QDir(dir.path()).entryList(QDir::Files | QDir::Hidden),
             QStringList{ QStringLiteral("a.ics") });
}

QTEST_MAIN(TestCalendarWriter)
#include "test_calendarwriter.moc"
```

- [ ] **Step 2: Write the header**

`src/calendarwriter.h`:

```cpp
/* GPLv2 header */

#pragma once

#include <QByteArray>
#include <QString>

#include <optional>

/// Every write to the calendar vdir goes through here.
///
/// One function covers create, edit, delete and every undo of those, because
/// each is the same act: the file must currently be X, and must become Y,
/// where either may be "absent". vdirsyncer writes the same files from cron,
/// so "must currently be X" is the stale check that stops a save from
/// silently discarding what a sync just pulled.
namespace CalendarWriter {

enum class Result { Ok, Stale, IoError };

/// `expected` nullopt: the file must not exist. `newText` nullopt: delete it.
/// A write goes to a hidden temporary in the same directory and is renamed
/// into place, so vdirsyncer, which lists only *.ics, never reads half a file.
Result replace(const QString &path, const std::optional<QByteArray> &expected,
               const std::optional<QByteArray> &newText, QString *error);

}  // namespace CalendarWriter
```

- [ ] **Step 3: Run to verify they fail**

Run: `cmake --build build 2>&1 | tail -3`
Expected: link failure, undefined `CalendarWriter::replace`.

- [ ] **Step 4: Implement**

`src/calendarwriter.cpp`:

```cpp
/* GPLv2 header */

#include "calendarwriter.h"

#include <QFile>
#include <QFileInfo>
#include <QSaveFile>

namespace CalendarWriter {

Result replace(const QString &path, const std::optional<QByteArray> &expected,
               const std::optional<QByteArray> &newText, QString *error)
{
    QFile current(path);
    const bool exists = current.exists();
    if (expected.has_value() != exists)
        return Result::Stale;
    if (exists) {
        if (!current.open(QIODevice::ReadOnly)) {
            *error = current.errorString();
            return Result::IoError;
        }
        if (current.readAll() != *expected)
            return Result::Stale;
        current.close();
    }

    if (!newText) {
        if (!QFile::remove(path)) {
            *error = QFile(path).errorString();
            return Result::IoError;
        }
        return Result::Ok;
    }

    // QSaveFile is the platform's atomic write: a temporary in the same
    // directory, renamed on commit(). Its temporary is named "<name>.XXXXXX",
    // which does not end in .ics, so vdirsyncer never lists it.
    QSaveFile file(path);
    if (!file.open(QIODevice::WriteOnly) || file.write(*newText) != newText->size()
        || !file.commit()) {
        *error = file.errorString();
        return Result::IoError;
    }
    return Result::Ok;
}

}  // namespace CalendarWriter
```

`QSaveFile` replaces the hand-rolled `.<name>.tmp` + `rename()` the spec describes: same guarantee, stdlib-of-Qt, fewer lines (ponytail ladder, rung 2). Record that in Task 16's spec amendment.

- [ ] **Step 5: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarwriter`
Expected: all PASS.

- [ ] **Step 6: Commit**

```bash
git add src/calendarwriter.h src/calendarwriter.cpp src/CMakeLists.txt tests/CMakeLists.txt \
        tests/test_calendarwriter.cpp
git commit -m "feat: write calendar files atomically, refusing stale ones"
```

---

### Task 9: Config keys

**Files:**
- Modify: `src/config.h` (accessors beside `contactsDir()`, members beside `m_contactsDir`)
- Modify: `src/config.cpp` (read beside `contacts_dir`)
- Test: `tests/test_config.cpp`

- [ ] **Step 1: Write the failing tests**

Add beside the `contactsDir*` slots, following their `writeIni` helper:

```cpp
    void calendarKeysAreOffWithoutThem();
    void calendarKeysAreRead();
    void calendarSyncCommandSurvivesACommaAndDefaults();
```

```cpp
void TestConfig::calendarKeysAreOffWithoutThem()
{
    // Plan ruling 1: absent is OFF, silently, as contacts_dir is.
    QTemporaryDir dir;
    Config config;
    config.load(writeIni(dir, QStringLiteral("[general]\n")));
    QVERIFY(config.calendarsDir().isEmpty());
    QVERIFY(config.problems().isEmpty());
}

void TestConfig::calendarKeysAreRead()
{
    QTemporaryDir dir;
    const QString cal = dir.filePath(QStringLiteral("calendars"));
    QDir().mkpath(cal);
    Config config;
    config.load(writeIni(dir, QStringLiteral("[general]\n"
                                             "calendars_dir = %1\n"
                                             "default_calendar = 52\n"
                                             "calendar_sync_delay_ms = 500\n").arg(cal)));
    QCOMPARE(config.calendarsDir(), cal);
    QCOMPARE(config.defaultCalendar(), QStringLiteral("52"));
    QCOMPARE(config.calendarSyncDelayMs(), 500);
    QVERIFY(config.problems().isEmpty());
}

void TestConfig::calendarSyncCommandSurvivesACommaAndDefaults()
{
    QTemporaryDir dir;
    Config config;
    config.load(writeIni(dir, QStringLiteral("[general]\n")));
    QCOMPARE(config.calendarSyncCommand(),
             QStringLiteral("flock -w 60 /tmp/vdirsyncer.lock vdirsyncer sync calendars"));
    QCOMPARE(config.calendarSyncDelayMs(), 2000);

    // QSettings splits an unquoted value on commas into a QStringList, and
    // toString() on a list is EMPTY: a command holding a comma would silently
    // turn syncing off. The reader joins the list back.
    Config commas;
    commas.load(writeIni(dir, QStringLiteral("[general]\n"
                                             "calendar_sync_command = mysync --only a,b\n")));
    QCOMPARE(commas.calendarSyncCommand(), QStringLiteral("mysync --only a,b"));

    // Written but empty disables, which is different from absent.
    Config off;
    off.load(writeIni(dir, QStringLiteral("[general]\ncalendar_sync_command = \n")));
    QVERIFY(off.calendarSyncCommand().isEmpty());
}
```

Check that `writeIni` overwrites the same file on a second call in one test; if it creates `qtmaildir.conf` once and refuses, use a fresh `QTemporaryDir` per `Config`.

- [ ] **Step 2: Run to verify they fail**

Run: `cmake --build build 2>&1 | tail -3`
Expected: compile error, `calendarsDir` is not a member of `Config`.

- [ ] **Step 3: Implement**

`src/config.h`, beside `contactsDir()`:

```cpp
    /// The vdirsyncer calendar root (item 206). Empty: the calendar is off.
    QString calendarsDir() const { return m_calendarsDir; }
    /// Directory name of the collection new events go to; empty means the
    /// first collection by display name.
    QString defaultCalendar() const { return m_defaultCalendar; }
    /// Run after calendar writes. Empty: no sync.
    QString calendarSyncCommand() const { return m_calendarSyncCommand; }
    int calendarSyncDelayMs() const { return m_calendarSyncDelayMs; }
```

Members beside `m_contactsDir`:

```cpp
    QString m_calendarsDir;
    QString m_defaultCalendar;
    QString m_calendarSyncCommand =
        QStringLiteral("flock -w 60 /tmp/vdirsyncer.lock vdirsyncer sync calendars");
    int m_calendarSyncDelayMs = 2000;
```

`src/config.cpp`, directly after the `contacts_dir` block:

```cpp
    // Item 206. The same shape as contacts_dir: absent or blank is the feature
    // off, silently; set and missing is reported and kept, since a vdirsyncer
    // target may not exist before its first run.
    const QString calendarsDir =
        settings.value(QStringLiteral("calendars_dir")).toString().trimmed();
    if (!calendarsDir.isEmpty()) {
        m_calendarsDir = expandTilde(calendarsDir);
        if (!QFileInfo::exists(m_calendarsDir)) {
            addProblem(tr("Calendars directory '%1' does not exist; the "
                          "calendar will be empty.").arg(m_calendarsDir));
        }
    }
    m_defaultCalendar =
        settings.value(QStringLiteral("default_calendar")).toString().trimmed();

    // An unquoted value holding a comma reaches here as a QStringList, whose
    // toString() is empty; join it back rather than silently losing the
    // command. Absent keeps the default; present and blank disables.
    const QVariant calSync = settings.value(QStringLiteral("calendar_sync_command"));
    if (calSync.isValid()) {
        m_calendarSyncCommand = calSync.typeId() == QMetaType::QStringList
            ? calSync.toStringList().join(QLatin1Char(','))
            : calSync.toString();
        m_calendarSyncCommand = m_calendarSyncCommand.trimmed();
    }
    const QVariant calDelay = settings.value(QStringLiteral("calendar_sync_delay_ms"));
    if (calDelay.isValid()) {
        bool ok = false;
        const int value = calDelay.toString().toInt(&ok);
        if (ok && value >= 0)
            m_calendarSyncDelayMs = value;
        else
            addProblem(tr("Calendar sync delay '%1' is not a number; using the default.")
                           .arg(calDelay.toString()));
    }
```

`QStringList::join` on a list QSettings split at `a,b` rejoins with no spaces, which matches the original only because QSettings split without trimming. Verify with the test before trusting it; if spaces are lost, the documented workaround is quoting the value in the INI, and the test should assert that instead.

- [ ] **Step 4: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_config`
Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add src/config.h src/config.cpp tests/test_config.cpp
git commit -m "feat: read the calendar's config keys"
```

---

### Task 10: `CalendarSync`

**Files:**
- Create: `src/calendarsync.h`, `src/calendarsync.cpp`
- Modify: `src/CMakeLists.txt`, `tests/CMakeLists.txt` (`add_qtmaildir_test(calendarsync)`)
- Test: `tests/test_calendarsync.cpp`

- [ ] **Step 1: Write the failing tests**

The command is a real shell-free process: `sh -c` would defeat `splitCommand`, so the test uses a tiny script written into a temp dir.

```cpp
/* GPLv2 header */

#include <QtTest>
#include <QFile>
#include <QSignalSpy>
#include <QTemporaryDir>

#include "calendarsync.h"

namespace {

/// A script that appends a line to `log` each run and exits with `code`.
QString script(const QTemporaryDir &dir, int code)
{
    const QString path = dir.filePath(QStringLiteral("sync.sh"));
    QFile f(path);
    f.open(QIODevice::WriteOnly);
    f.write(QStringLiteral("#!/bin/sh\necho run >> %1\necho output\nexit %2\n")
                .arg(dir.filePath(QStringLiteral("log"))).arg(code).toUtf8());
    f.close();
    f.setPermissions(f.permissions() | QFileDevice::ExeOwner);
    return path;
}

int runs(const QTemporaryDir &dir)
{
    QFile f(dir.filePath(QStringLiteral("log")));
    return f.open(QIODevice::ReadOnly) ? f.readAll().count('\n') : 0;
}

} // namespace

class TestCalendarSync : public QObject
{
    Q_OBJECT

private slots:
    void aBurstOfWritesRunsOnce();
    void reportsFailureWithTheOutput();
    void anEmptyCommandNeverRuns();
};

void TestCalendarSync::aBurstOfWritesRunsOnce()
{
    QTemporaryDir dir;
    CalendarSync sync(script(dir, 0), 50);
    QSignalSpy finished(&sync, &CalendarSync::finished);
    sync.schedule();
    sync.schedule();
    sync.schedule();
    QVERIFY(finished.wait(5000));
    QCOMPARE(finished.first().at(0).toBool(), true);
    QTest::qWait(200);  // nothing else is queued, so nothing else may run
    QCOMPARE(runs(dir), 1);
}

void TestCalendarSync::reportsFailureWithTheOutput()
{
    QTemporaryDir dir;
    CalendarSync sync(script(dir, 3), 0);
    QSignalSpy finished(&sync, &CalendarSync::finished);
    sync.schedule();
    QVERIFY(finished.wait(5000));
    QCOMPARE(finished.first().at(0).toBool(), false);
    QVERIFY(finished.first().at(1).toString().contains(QStringLiteral("output")));
}

void TestCalendarSync::anEmptyCommandNeverRuns()
{
    CalendarSync sync(QString(), 0);
    QSignalSpy started(&sync, &CalendarSync::started);
    sync.schedule();
    QTest::qWait(100);
    QCOMPARE(started.count(), 0);
}

QTEST_MAIN(TestCalendarSync)
#include "test_calendarsync.moc"
```

`aBurstOfWritesRunsOnce` waits a fixed 200 ms to assert a NEGATIVE, which AGENTS.md warns passes when the thing never arrives. Here that is the assertion's point (no second run) and the positive half is waited on properly first, so it stands; do not copy the pattern for a positive check.

- [ ] **Step 2: Write the header**

```cpp
/* GPLv2 header */

#pragma once

#include <QObject>
#include <QProcess>
#include <QTimer>

/// Runs calendar_sync_command a short delay after the last write.
///
/// The calendar's counterpart to MailSync, and deliberately smaller: no lock
/// monitoring and no status file, because the command itself takes the
/// flock that cron shares. A write arriving while a run is in progress is not
/// dropped: it queues exactly one more run for when this one finishes, since
/// the running sync may have listed the vdir before the write landed.
class CalendarSync : public QObject
{
    Q_OBJECT

public:
    CalendarSync(const QString &command, int delayMs, QObject *parent = nullptr);

    void schedule();
    bool isRunning() const;

signals:
    void started();
    void finished(bool ok, const QString &output);

private:
    void run();

    QString m_command;
    QTimer m_timer;
    QProcess m_process;
    QByteArray m_output;
    bool m_again = false;
};
```

- [ ] **Step 3: Run to verify they fail**

Run: `cmake --build build 2>&1 | tail -3`
Expected: link failure for `CalendarSync`.

- [ ] **Step 4: Implement**

```cpp
/* GPLv2 header */

#include "calendarsync.h"

CalendarSync::CalendarSync(const QString &command, int delayMs, QObject *parent)
    : QObject(parent), m_command(command)
{
    m_timer.setSingleShot(true);
    m_timer.setInterval(delayMs);
    connect(&m_timer, &QTimer::timeout, this, &CalendarSync::run);
    m_process.setProcessChannelMode(QProcess::MergedChannels);
    connect(&m_process, &QProcess::readyRead, this,
            [this]() { m_output += m_process.readAll(); });
    connect(&m_process, &QProcess::finished, this,
            [this](int code, QProcess::ExitStatus status) {
        emit finished(status == QProcess::NormalExit && code == 0,
                      QString::fromLocal8Bit(m_output));
        if (m_again) {
            m_again = false;
            m_timer.start();
        }
    });
    connect(&m_process, &QProcess::errorOccurred, this,
            [this](QProcess::ProcessError error) {
        if (error == QProcess::FailedToStart)
            emit finished(false, m_process.errorString());
    });
}

void CalendarSync::schedule()
{
    if (m_command.isEmpty())
        return;
    if (isRunning())
        m_again = true;
    else
        m_timer.start();  // restarting is the debounce
}

bool CalendarSync::isRunning() const
{
    return m_process.state() != QProcess::NotRunning;
}

void CalendarSync::run()
{
    // splitCommand, not a shell: quoting works and nothing is interpreted.
    QStringList parts = QProcess::splitCommand(m_command);
    if (parts.isEmpty())
        return;
    const QString program = parts.takeFirst();
    m_output.clear();
    emit started();
    m_process.start(program, parts);
}
```

- [ ] **Step 5: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarsync`
Expected: all PASS.

- [ ] **Step 6: Commit**

```bash
git add src/calendarsync.h src/calendarsync.cpp src/CMakeLists.txt tests/CMakeLists.txt \
        tests/test_calendarsync.cpp
git commit -m "feat: debounce the calendar sync command after writes"
```

---

### Task 11: `MonthLayout`

**Files:**
- Create: `src/monthlayout.h`, `src/monthlayout.cpp`
- Modify: `src/CMakeLists.txt`, `tests/CMakeLists.txt` (`add_qtmaildir_test(monthlayout)`)
- Test: `tests/test_monthlayout.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
/* GPLv2 header */

#include <QtTest>

#include "monthlayout.h"

class TestMonthLayout : public QObject
{
    Q_OBJECT

private slots:
    void theGridStartsOnTheLocalesFirstDay();
    void cellsTileTheAreaWithNoGapOrOverlap();
    void chipsThatDoNotFitBecomeMore();
    void aPointFindsItsCell();
};

void TestMonthLayout::theGridStartsOnTheLocalesFirstDay()
{
    // 2026-09-01 is a Tuesday.
    QCOMPARE(MonthLayout::gridStart(2026, 9, Qt::Monday), QDate(2026, 8, 31));
    QCOMPARE(MonthLayout::gridStart(2026, 9, Qt::Sunday), QDate(2026, 8, 30));
    // A month starting ON the first weekday starts on its own first day.
    QCOMPARE(MonthLayout::gridStart(2026, 6, Qt::Monday), QDate(2026, 6, 1));
    const MonthLayout layout(QRect(0, 0, 700, 600), 2026, 9, Qt::Monday, 20, 16);
    QCOMPARE(layout.dateAt(0), QDate(2026, 8, 31));
    QCOMPARE(layout.dateAt(41), QDate(2026, 10, 11));
}

void TestMonthLayout::cellsTileTheAreaWithNoGapOrOverlap()
{
    // 703 does not divide by 7: the remainder must go somewhere, not vanish
    // as a gap down the right edge.
    const QRect area(0, 0, 703, 605);
    const MonthLayout layout(area, 2026, 9, Qt::Monday, 20, 16);
    QCOMPARE(layout.cellRect(0).left(), area.left());
    QCOMPARE(layout.cellRect(6).right(), area.right());
    QCOMPARE(layout.cellRect(41).bottom(), area.bottom());
    for (int i = 0; i < 6; ++i)
        QCOMPARE(layout.cellRect(i).right() + 1, layout.cellRect(i + 1).left());
    QCOMPARE(layout.cellRect(0).bottom() + 1, layout.cellRect(7).top());
}

void TestMonthLayout::chipsThatDoNotFitBecomeMore()
{
    // 600 / 6 rows = 100 px a cell; 20 px of day number; 16 px chips: 5 fit.
    const MonthLayout layout(QRect(0, 0, 700, 600), 2026, 9, Qt::Monday, 20, 16);
    QCOMPARE(layout.capacity(), 5);
    QCOMPARE(layout.visibleChips(3), 3);
    QCOMPARE(layout.visibleChips(5), 5);
    // Six do not fit: four chips and a "+2 more" line in the fifth slot.
    QCOMPARE(layout.visibleChips(6), 4);
    QCOMPARE(layout.chipRect(0, 0).top(), layout.cellRect(0).top() + 20);
    QVERIFY(layout.cellRect(0).contains(layout.chipRect(0, 4)));
}

void TestMonthLayout::aPointFindsItsCell()
{
    const MonthLayout layout(QRect(0, 0, 700, 600), 2026, 9, Qt::Monday, 20, 16);
    QCOMPARE(layout.cellAt(layout.cellRect(17).center()), 17);
    QCOMPARE(layout.cellAt(QPoint(-5, 10)), -1);
}

QTEST_MAIN(TestMonthLayout)
#include "test_monthlayout.moc"
```

- [ ] **Step 2: Write the header**

```cpp
/* GPLv2 header */

#pragma once

#include <QDate>
#include <QPoint>
#include <QRect>

/// Where everything in the month grid goes, with no painter and no widget.
///
/// The CardLayout precedent: a geometric claim is tested as a function call,
/// because AGENTS.md records how rendering probes lie. Six rows of seven
/// always, so the grid does not jump in height between months.
class MonthLayout
{
public:
    static constexpr int kCells = 42;

    MonthLayout(const QRect &area, int year, int month, Qt::DayOfWeek firstDay,
                int dayNumberHeight, int chipHeight);

    static QDate gridStart(int year, int month, Qt::DayOfWeek firstDay);

    QDate dateAt(int cell) const;
    int cellOf(const QDate &date) const;  ///< -1 when not on the grid.
    QRect cellRect(int cell) const;
    int cellAt(const QPoint &point) const;  ///< -1 outside the grid.

    /// How many chip slots fit under a cell's day number.
    int capacity() const;
    /// How many of `total` chips are drawn; when fewer than `total`, the
    /// next slot holds "+N more".
    int visibleChips(int total) const;
    QRect chipRect(int cell, int slot) const;

private:
    QRect m_area;
    QDate m_start;
    int m_dayNumberHeight;
    int m_chipHeight;
};
```

- [ ] **Step 3: Run to verify they fail**

Run: `cmake --build build 2>&1 | tail -3`
Expected: link failure.

- [ ] **Step 4: Implement**

```cpp
/* GPLv2 header */

#include "monthlayout.h"

MonthLayout::MonthLayout(const QRect &area, int year, int month, Qt::DayOfWeek firstDay,
                         int dayNumberHeight, int chipHeight)
    : m_area(area), m_start(gridStart(year, month, firstDay)),
      m_dayNumberHeight(dayNumberHeight), m_chipHeight(chipHeight)
{
}

QDate MonthLayout::gridStart(int year, int month, Qt::DayOfWeek firstDay)
{
    const QDate first(year, month, 1);
    const int back = (first.dayOfWeek() - firstDay + 7) % 7;
    return first.addDays(-back);
}

QDate MonthLayout::dateAt(int cell) const { return m_start.addDays(cell); }

int MonthLayout::cellOf(const QDate &date) const
{
    const qint64 cell = m_start.daysTo(date);
    return cell >= 0 && cell < kCells ? int(cell) : -1;
}

QRect MonthLayout::cellRect(int cell) const
{
    // Edges computed from the area by proportion, so the rounding remainder
    // is spread across cells and the last edge lands exactly on the area's.
    const int col = cell % 7, row = cell / 7;
    const int left = m_area.left() + m_area.width() * col / 7;
    const int right = m_area.left() + m_area.width() * (col + 1) / 7;  // exclusive
    const int top = m_area.top() + m_area.height() * row / 6;
    const int bottom = m_area.top() + m_area.height() * (row + 1) / 6;
    return QRect(QPoint(left, top), QPoint(right - 1, bottom - 1));
}

int MonthLayout::cellAt(const QPoint &point) const
{
    if (!m_area.contains(point))
        return -1;
    const int col = (point.x() - m_area.left()) * 7 / m_area.width();
    const int row = (point.y() - m_area.top()) * 6 / m_area.height();
    return row * 7 + col;
}

int MonthLayout::capacity() const
{
    const int height = m_area.height() / 6 - m_dayNumberHeight;
    return m_chipHeight > 0 ? qMax(0, height / m_chipHeight) : 0;
}

int MonthLayout::visibleChips(int total) const
{
    const int cap = capacity();
    return total <= cap ? total : qMax(0, cap - 1);
}

QRect MonthLayout::chipRect(int cell, int slot) const
{
    const QRect c = cellRect(cell);
    return QRect(c.left() + 2, c.top() + m_dayNumberHeight + slot * m_chipHeight,
                 c.width() - 4, m_chipHeight - 1);
}
```

`QRect::right()` is inclusive (AGENTS.md, CardLayout): the exclusive edge is carried as a local and converted once in `cellRect`, which is what `cellsTileTheAreaWithNoGapOrOverlap` guards.

- [ ] **Step 5: Run to verify they pass**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_monthlayout`
Expected: all PASS.

- [ ] **Step 6: Commit**

```bash
git add src/monthlayout.h src/monthlayout.cpp src/CMakeLists.txt tests/CMakeLists.txt \
        tests/test_monthlayout.cpp
git commit -m "feat: lay out the calendar's month grid without a painter"
```

---

### Task 12: `MonthView` and `AgendaView`

These are painting and list widgets: their correctness is the user's hand test (AGENTS.md: a green suite is not evidence a UI design is right). No tests here; the geometry they rely on is Task 11's.

**Files:**
- Create: `src/monthview.h`, `src/monthview.cpp`, `src/agendaview.h`, `src/agendaview.cpp`
- Modify: `src/CMakeLists.txt`

- [ ] **Step 1: Write `src/monthview.h`**

```cpp
/* GPLv2 header */

#pragma once

#include "caltypes.h"
#include "monthlayout.h"

#include <QWidget>

/// The month grid. Paints a MonthLayout; knows nothing of libical, files or
/// CalEvent, only the CalendarItems it is handed.
class MonthView : public QWidget
{
    Q_OBJECT

public:
    explicit MonthView(QWidget *parent = nullptr);

    void setMonth(int year, int month);
    void setItems(const QList<CalendarItem> &items);
    /// Index into the items, or -1. Drawn with an outline.
    void setSelected(int item);

    /// The first and one-past-last day on the grid, for the caller's query.
    QDate firstDay() const;
    QDate lastDay() const;

signals:
    void itemClicked(int item);
    void dayDoubleClicked(const QDate &day);
    void moreClicked(const QDate &day);

protected:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;

private:
    MonthLayout layout() const;
    /// Items on each cell, in start order; a multi-day item is on every cell
    /// it covers (spec, Month view).
    QList<QList<int>> itemsPerCell(const MonthLayout &layout) const;

    int m_year;
    int m_month;
    QList<CalendarItem> m_items;
    int m_selected = -1;
};
```

- [ ] **Step 2: Write `src/monthview.cpp`**

```cpp
/* GPLv2 header */

#include "monthview.h"
#include "monthlayout.h"

#include <QLocale>
#include <QMouseEvent>
#include <QPainter>

MonthView::MonthView(QWidget *parent)
    : QWidget(parent),
      m_year(QDate::currentDate().year()), m_month(QDate::currentDate().month())
{
    setMinimumSize(420, 320);
}

void MonthView::setMonth(int year, int month)
{
    m_year = year;
    m_month = month;
    update();
}

void MonthView::setItems(const QList<CalendarItem> &items)
{
    m_items = items;
    m_selected = -1;
    update();
}

void MonthView::setSelected(int item)
{
    m_selected = item;
    update();
}

MonthLayout MonthView::layout() const
{
    const int line = fontMetrics().height();
    return MonthLayout(rect().adjusted(0, line + 4, 0, 0), m_year, m_month,
                       QLocale().firstDayOfWeek(), line + 2, line + 2);
}

QDate MonthView::firstDay() const { return layout().dateAt(0); }
QDate MonthView::lastDay() const { return layout().dateAt(MonthLayout::kCells - 1).addDays(1); }

QList<QList<int>> MonthView::itemsPerCell(const MonthLayout &l) const
{
    QList<QList<int>> cells(MonthLayout::kCells);
    for (int i = 0; i < m_items.size(); ++i) {
        const Occurrence &o = m_items[i].occurrence;
        QDate day = o.start.toLocalTime().date();
        // The end is exclusive: an event ending at midnight does not touch
        // the day that midnight begins.
        const QDate last = o.end > o.start ? o.end.toLocalTime().addMSecs(-1).date() : day;
        for (; day <= last; day = day.addDays(1)) {
            const int cell = l.cellOf(day);
            if (cell >= 0)
                cells[cell].append(i);
        }
    }
    return cells;
}

void MonthView::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.fillRect(rect(), palette().base());
    const MonthLayout l = layout();
    const QLocale locale;
    const int line = fontMetrics().height();

    // Weekday header.
    for (int col = 0; col < 7; ++col) {
        const QRect cell = l.cellRect(col);
        const int dow = (locale.firstDayOfWeek() - 1 + col) % 7 + 1;
        p.setPen(palette().color(QPalette::PlaceholderText));
        p.drawText(QRect(cell.left(), 0, cell.width(), line + 4), Qt::AlignCenter,
                   locale.dayName(dow, QLocale::ShortFormat));
    }

    const QList<QList<int>> cells = itemsPerCell(l);
    const QDate today = QDate::currentDate();
    for (int c = 0; c < MonthLayout::kCells; ++c) {
        const QRect cell = l.cellRect(c);
        const QDate date = l.dateAt(c);
        p.setPen(palette().color(QPalette::Mid));
        p.drawRect(cell.adjusted(0, 0, -1, -1));

        QRect number(cell.left() + 4, cell.top() + 1, fontMetrics().horizontalAdvance(QStringLiteral("00")) + 8, line);
        if (date == today) {
            p.setPen(Qt::NoPen);
            p.setBrush(palette().highlight());
            p.drawRoundedRect(number, line / 2, line / 2);
            p.setPen(palette().color(QPalette::HighlightedText));
        } else {
            p.setPen(palette().color(date.month() == m_month ? QPalette::Text : QPalette::PlaceholderText));
        }
        p.drawText(number, Qt::AlignCenter, QString::number(date.day()));

        const QList<int> &items = cells[c];
        const int shown = l.visibleChips(items.size());
        for (int slot = 0; slot < shown; ++slot) {
            const CalendarItem &item = m_items[items[slot]];
            const QRect chip = l.chipRect(c, slot);
            if (item.occurrence.allDay) {
                p.setPen(Qt::NoPen);
                p.setBrush(item.color);
                p.drawRoundedRect(chip, 3, 3);
                p.setPen(Qt::white);
                p.drawText(chip.adjusted(4, 0, -2, 0), Qt::AlignVCenter | Qt::AlignLeft,
                           fontMetrics().elidedText(item.title, Qt::ElideRight, chip.width() - 6));
            } else {
                const int dot = chip.height() / 2;
                p.setPen(Qt::NoPen);
                p.setBrush(item.color);
                p.drawEllipse(QRect(chip.left() + 2, chip.center().y() - dot / 2, dot, dot));
                p.setPen(palette().color(QPalette::Text));
                const QString text = locale.toString(item.occurrence.start.toLocalTime().time(),
                                                     QLocale::ShortFormat)
                                     + QLatin1Char(' ') + item.title;
                const QRect textRect = chip.adjusted(dot + 6, 0, 0, 0);
                p.drawText(textRect, Qt::AlignVCenter | Qt::AlignLeft,
                           fontMetrics().elidedText(text, Qt::ElideRight, textRect.width()));
            }
            if (items[slot] == m_selected) {
                p.setPen(QPen(palette().color(QPalette::Highlight), 2));
                p.setBrush(Qt::NoBrush);
                p.drawRoundedRect(chip, 3, 3);
            }
        }
        if (shown < items.size()) {
            p.setPen(palette().color(QPalette::Link));
            p.drawText(l.chipRect(c, shown).adjusted(4, 0, 0, 0), Qt::AlignVCenter | Qt::AlignLeft,
                       tr("+%n more", nullptr, int(items.size() - shown)));
        }
    }
}

void MonthView::mousePressEvent(QMouseEvent *event)
{
    const MonthLayout l = layout();
    const int cell = l.cellAt(event->position().toPoint());
    if (cell < 0)
        return;
    const QList<int> items = itemsPerCell(l)[cell];
    const int shown = l.visibleChips(items.size());
    for (int slot = 0; slot < shown; ++slot) {
        if (l.chipRect(cell, slot).contains(event->position().toPoint())) {
            emit itemClicked(items[slot]);
            return;
        }
    }
    if (shown < items.size() && l.chipRect(cell, shown).contains(event->position().toPoint()))
        emit moreClicked(l.dateAt(cell));
}

void MonthView::mouseDoubleClickEvent(QMouseEvent *event)
{
    const MonthLayout l = layout();
    const int cell = l.cellAt(event->position().toPoint());
    if (cell < 0)
        return;
    // A double-click on a chip is two clicks on the chip, not a new event.
    const QList<int> items = itemsPerCell(l)[cell];
    for (int slot = 0; slot < l.visibleChips(items.size()); ++slot)
        if (l.chipRect(cell, slot).contains(event->position().toPoint()))
            return;
    emit dayDoubleClicked(l.dateAt(cell));
}
```

The `tr("+%n more", nullptr, n)` form is the plural-aware one; the Italian `.ts` then needs both plural forms in Task 16.

- [ ] **Step 3: Write `src/agendaview.h` and `src/agendaview.cpp`**

```cpp
/* GPLv2 header */

#pragma once

#include "caltypes.h"

#include <QListWidget>

/// The agenda: the same items as the month grid, as a list under day headers.
class AgendaView : public QListWidget
{
    Q_OBJECT

public:
    explicit AgendaView(QWidget *parent = nullptr);

    void setItems(const QList<CalendarItem> &items);
    void setSelected(int item);
    /// Scrolls so `day`'s header, or the first day after it, is at the top.
    void scrollToDay(const QDate &day);

signals:
    void itemClicked(int item);
};
```

```cpp
/* GPLv2 header */

#include "agendaview.h"

#include <QLocale>
#include <QPainter>
#include <QPixmap>

namespace {
constexpr int kItemRole = Qt::UserRole;      ///< Index into the items, or -1 for a header.
constexpr int kDayRole = Qt::UserRole + 1;   ///< The header's date.
}

AgendaView::AgendaView(QWidget *parent) : QListWidget(parent)
{
    connect(this, &QListWidget::itemClicked, this, [this](QListWidgetItem *row) {
        const int item = row->data(kItemRole).toInt();
        if (item >= 0)
            emit itemClicked(item);
    });
}

void AgendaView::setItems(const QList<CalendarItem> &items)
{
    clear();
    const QLocale locale;
    QDate current;
    for (int i = 0; i < items.size(); ++i) {
        const CalendarItem &item = items[i];
        // A blank item is a placeholder the window leaves so every row's
        // index stays the same as the month grid's: skipped, not shown.
        if (item.title.isEmpty())
            continue;
        const QDate day = item.occurrence.start.toLocalTime().date();
        if (day != current) {
            current = day;
            auto *header = new QListWidgetItem(locale.toString(day, QLocale::LongFormat), this);
            QFont bold = header->font();
            bold.setBold(true);
            header->setFont(bold);
            header->setFlags(Qt::ItemIsEnabled);  // not selectable
            header->setData(kItemRole, -1);
            header->setData(kDayRole, day);
        }
        const QString when = item.occurrence.allDay
            ? tr("all day")
            : tr("%1 - %2").arg(locale.toString(item.occurrence.start.toLocalTime().time(), QLocale::ShortFormat),
                                locale.toString(item.occurrence.end.toLocalTime().time(), QLocale::ShortFormat));
        QPixmap swatch(10, 10);
        swatch.fill(Qt::transparent);
        QPainter(&swatch).fillRect(swatch.rect(), item.color);
        auto *row = new QListWidgetItem(QIcon(swatch), when + QStringLiteral("    ") + item.title, this);
        row->setData(kItemRole, i);
    }
}

void AgendaView::setSelected(int item)
{
    for (int r = 0; r < count(); ++r) {
        if (this->item(r)->data(kItemRole).toInt() == item) {
            setCurrentRow(r);
            return;
        }
    }
    clearSelection();
}

void AgendaView::scrollToDay(const QDate &day)
{
    for (int r = 0; r < count(); ++r) {
        const QDate header = item(r)->data(kDayRole).toDate();
        if (header.isValid() && header >= day) {
            scrollToItem(item(r), QAbstractItemView::PositionAtTop);
            return;
        }
    }
}
```

An item's title reaches `QListWidgetItem` as plain text: a list item has no rich-text mode, so the untrusted-text rule holds here by construction.

- [ ] **Step 4: Build**

Add `monthview.cpp` and `agendaview.cpp` to `src/CMakeLists.txt`.
Run: `cmake --build build 2>&1 | tail -3`
Expected: builds with no warnings from the new files.

- [ ] **Step 5: Commit**

```bash
git add src/monthview.h src/monthview.cpp src/agendaview.h src/agendaview.cpp src/CMakeLists.txt
git commit -m "feat: paint the calendar's month grid and agenda list"
```

---

### Task 13: `EventPane`

The side pane's two pages. Its visual layout is the user's hand test; what is tested (Task 14, through the window) is the edit state it reports.

**Files:**
- Create: `src/eventpane.h`, `src/eventpane.cpp`
- Modify: `src/CMakeLists.txt`

- [ ] **Step 1: Write `src/eventpane.h`**

```cpp
/* GPLv2 header */

#pragma once

#include "caltypes.h"

#include <QStackedWidget>

class QCheckBox;
class QComboBox;
class QDateEdit;
class QDateTimeEdit;
class QLabel;
class QLineEdit;
class QPlainTextEdit;
class QPushButton;
class QSpinBox;

/// The calendar window's right-hand pane: a read-only page for the selected
/// event, and the edit form that replaces it (spec decision 11).
///
/// Every value from a file is shown in a Qt::PlainText label: SUMMARY,
/// DESCRIPTION, LOCATION and attendee names come from strangers once
/// invitations arrive, which is MessageDetailsDialog's rule.
class EventPane : public QStackedWidget
{
    Q_OBJECT

public:
    explicit EventPane(QWidget *parent = nullptr);

    void showNothing();
    void showDetails(const CalEvent &event, const CalCollection &collection,
                     const Occurrence &occurrence, bool editable);

    /// Opens the form. `collections` are the writable ones, for the Calendar
    /// combo; `repeatEditable` is false for a single occurrence, which has no
    /// rule of its own; `collectionEditable` is false for the same reason.
    void startEdit(const EventEdit &initial, const QList<CalCollection> &collections,
                   bool repeatEditable, bool collectionEditable,
                   const QString &reminderText, const QString &attendeesText);
    void stopEdit();

    bool isEditing() const;
    bool isDirty() const;
    EventEdit edit() const;

signals:
    void editRequested();
    void deleteRequested();
    void saveRequested();
    void cancelRequested();

private:
    QWidget *buildDetails();
    QWidget *buildForm();
    QWidget *buildRepeat();
    void setRepeat(const RepeatRule &rule);
    RepeatRule repeat() const;
    void proposeFromStart();
    void refreshRepeatVisibility();
    void refreshAllDay();

    // Details page.
    QLabel *m_title;
    QLabel *m_when;
    QLabel *m_repeatText;
    QLabel *m_calendar;
    QLabel *m_location;
    QLabel *m_notes;
    QLabel *m_reminder;
    QLabel *m_people;
    QLabel *m_notice;
    QPushButton *m_editButton;
    QPushButton *m_deleteButton;

    // Form.
    QLineEdit *m_titleEdit;
    QComboBox *m_calendarBox;
    QCheckBox *m_allDay;
    QDateTimeEdit *m_startEdit;
    QDateTimeEdit *m_endEdit;
    QLineEdit *m_locationEdit;
    QPlainTextEdit *m_notesEdit;
    QLabel *m_formReminder;
    QLabel *m_formPeople;
    QLabel *m_formNotice;

    // Repeat control.
    QWidget *m_repeatBox;
    QComboBox *m_freq;          ///< None, Daily, Weekly, Monthly, Yearly, [Custom]
    QSpinBox *m_interval;
    QWidget *m_weekdayRow;
    QList<QCheckBox *> m_weekdays;  ///< Monday first, index = Qt::DayOfWeek - 1
    QComboBox *m_by;            ///< "on day N" / "on the Nth weekday"
    QSpinBox *m_monthDay;
    QComboBox *m_ordinal;       ///< first..fourth, last
    QComboBox *m_weekday;
    QComboBox *m_month;
    QComboBox *m_end;           ///< never, on a date, after N times
    QDateEdit *m_until;
    QSpinBox *m_count;
    QLabel *m_customLabel;

    EventEdit m_initial;
    RepeatRule m_customRule;    ///< Kept when the rule read was custom.
    QDateTime m_previousStart;  ///< For keeping the duration as the start moves.
    bool m_editing = false;
};
```

- [ ] **Step 2: Write `src/eventpane.cpp`**

```cpp
/* GPLv2 header */

#include "eventpane.h"

#include <QCheckBox>
#include <QComboBox>
#include <QDateEdit>
#include <QDateTimeEdit>
#include <QFormLayout>
#include <QHBoxLayout>
#include <QLabel>
#include <QLineEdit>
#include <QLocale>
#include <QPainter>
#include <QPixmap>
#include <QPlainTextEdit>
#include <QPushButton>
#include <QSpinBox>
#include <QTimeZone>
#include <QVBoxLayout>

namespace {

QLabel *plainLabel(QWidget *parent)
{
    auto *label = new QLabel(parent);
    label->setTextFormat(Qt::PlainText);  // untrusted: never AutoText
    label->setWordWrap(true);
    label->setTextInteractionFlags(Qt::TextSelectableByMouse);
    return label;
}

QIcon swatch(const QColor &colour)
{
    QPixmap pixmap(12, 12);
    pixmap.fill(Qt::transparent);
    QPainter(&pixmap).fillRect(pixmap.rect(), colour);
    return QIcon(pixmap);
}

bool sameEdit(const EventEdit &a, const EventEdit &b)
{
    return a.summary == b.summary && a.location == b.location
        && a.description == b.description && a.start == b.start && a.end == b.end
        && a.allDay == b.allDay && a.repeat == b.repeat && a.collectionDir == b.collectionDir;
}

constexpr int kCustomIndex = 5;

} // namespace

EventPane::EventPane(QWidget *parent) : QStackedWidget(parent)
{
    addWidget(new QWidget(this));   // 0: nothing selected
    addWidget(buildDetails());      // 1
    addWidget(buildForm());         // 2
    setMinimumWidth(260);
    showNothing();
}

QWidget *EventPane::buildDetails()
{
    auto *page = new QWidget(this);
    auto *layout = new QVBoxLayout(page);
    m_title = plainLabel(page);
    QFont big = m_title->font();
    big.setBold(true);
    big.setPointSizeF(big.pointSizeF() > 0 ? big.pointSizeF() * 1.3 : big.pointSizeF());
    m_title->setFont(big);
    layout->addWidget(m_title);

    auto *form = new QFormLayout;
    m_when = plainLabel(page);
    m_repeatText = plainLabel(page);
    m_calendar = plainLabel(page);
    m_location = plainLabel(page);
    m_notes = plainLabel(page);
    m_reminder = plainLabel(page);
    m_people = plainLabel(page);
    form->addRow(tr("When"), m_when);
    form->addRow(tr("Repeats"), m_repeatText);
    form->addRow(tr("Calendar"), m_calendar);
    form->addRow(tr("Location"), m_location);
    form->addRow(tr("Notes"), m_notes);
    form->addRow(tr("Reminder"), m_reminder);
    form->addRow(tr("People"), m_people);
    layout->addLayout(form);

    m_notice = plainLabel(page);
    m_notice->setObjectName(QStringLiteral("eventNotice"));
    layout->addWidget(m_notice);

    auto *buttons = new QHBoxLayout;
    m_editButton = new QPushButton(tr("&Edit"), page);
    m_editButton->setObjectName(QStringLiteral("editEvent"));
    m_deleteButton = new QPushButton(tr("&Delete"), page);
    m_deleteButton->setObjectName(QStringLiteral("deleteEvent"));
    buttons->addWidget(m_editButton);
    buttons->addWidget(m_deleteButton);
    buttons->addStretch();
    layout->addLayout(buttons);
    layout->addStretch();

    connect(m_editButton, &QPushButton::clicked, this, &EventPane::editRequested);
    connect(m_deleteButton, &QPushButton::clicked, this, &EventPane::deleteRequested);
    return page;
}

QWidget *EventPane::buildForm()
{
    auto *page = new QWidget(this);
    auto *layout = new QVBoxLayout(page);
    auto *form = new QFormLayout;

    m_titleEdit = new QLineEdit(page);
    m_titleEdit->setObjectName(QStringLiteral("eventTitle"));
    m_calendarBox = new QComboBox(page);
    m_calendarBox->setObjectName(QStringLiteral("eventCalendar"));
    m_allDay = new QCheckBox(tr("All day"), page);
    m_startEdit = new QDateTimeEdit(page);
    m_startEdit->setObjectName(QStringLiteral("eventStart"));
    m_startEdit->setCalendarPopup(true);
    m_endEdit = new QDateTimeEdit(page);
    m_endEdit->setObjectName(QStringLiteral("eventEnd"));
    m_endEdit->setCalendarPopup(true);
    m_locationEdit = new QLineEdit(page);
    m_notesEdit = new QPlainTextEdit(page);
    m_formReminder = plainLabel(page);
    m_formPeople = plainLabel(page);

    form->addRow(tr("Title"), m_titleEdit);
    form->addRow(tr("Calendar"), m_calendarBox);
    form->addRow(QString(), m_allDay);
    form->addRow(tr("Starts"), m_startEdit);
    form->addRow(tr("Ends"), m_endEdit);
    form->addRow(tr("Repeat"), buildRepeat());
    form->addRow(tr("Location"), m_locationEdit);
    form->addRow(tr("Notes"), m_notesEdit);
    form->addRow(tr("Reminder"), m_formReminder);
    form->addRow(tr("People"), m_formPeople);
    layout->addLayout(form);

    m_formNotice = plainLabel(page);
    layout->addWidget(m_formNotice);

    auto *buttons = new QHBoxLayout;
    auto *save = new QPushButton(tr("&Save"), page);
    save->setObjectName(QStringLiteral("saveEvent"));
    save->setDefault(true);
    auto *cancel = new QPushButton(tr("Cancel"), page);
    cancel->setObjectName(QStringLiteral("cancelEvent"));
    buttons->addStretch();
    buttons->addWidget(cancel);
    buttons->addWidget(save);
    layout->addLayout(buttons);

    connect(save, &QPushButton::clicked, this, &EventPane::saveRequested);
    connect(cancel, &QPushButton::clicked, this, &EventPane::cancelRequested);
    connect(m_allDay, &QCheckBox::toggled, this, &EventPane::refreshAllDay);
    // Keep the duration when the start moves, as every calendar does.
    connect(m_startEdit, &QDateTimeEdit::dateTimeChanged, this, [this](const QDateTime &start) {
        if (m_previousStart.isValid() && m_editing) {
            const qint64 length = m_previousStart.secsTo(m_endEdit->dateTime());
            m_endEdit->setDateTime(start.addSecs(qMax<qint64>(0, length)));
        }
        m_previousStart = start;
        proposeFromStart();
    });
    return page;
}
```

`m_previousStart` is a member, reset in `startEdit`: a function-local static would carry one edit's start into the next.

```cpp
QWidget *EventPane::buildRepeat()
{
    m_repeatBox = new QWidget(this);
    auto *box = new QVBoxLayout(m_repeatBox);
    box->setContentsMargins(0, 0, 0, 0);
    const QLocale locale;

    auto *row = new QHBoxLayout;
    m_freq = new QComboBox(m_repeatBox);
    m_freq->setObjectName(QStringLiteral("eventRepeat"));
    m_freq->addItems({ tr("Does not repeat"), tr("Daily"), tr("Weekly"),
                       tr("Monthly"), tr("Yearly") });
    m_interval = new QSpinBox(m_repeatBox);
    m_interval->setRange(1, 99);
    m_interval->setPrefix(tr("every "));
    row->addWidget(m_freq);
    row->addWidget(m_interval);
    box->addLayout(row);

    m_weekdayRow = new QWidget(m_repeatBox);
    auto *days = new QHBoxLayout(m_weekdayRow);
    days->setContentsMargins(0, 0, 0, 0);
    for (int d = 1; d <= 7; ++d) {
        auto *check = new QCheckBox(locale.dayName(d, QLocale::NarrowFormat), m_weekdayRow);
        m_weekdays.append(check);
        days->addWidget(check);
    }
    box->addWidget(m_weekdayRow);

    auto *byRow = new QHBoxLayout;
    m_by = new QComboBox(m_repeatBox);
    m_by->addItems({ tr("on day"), tr("on the") });
    m_monthDay = new QSpinBox(m_repeatBox);
    m_monthDay->setRange(1, 31);
    m_ordinal = new QComboBox(m_repeatBox);
    m_ordinal->addItem(tr("first"), 1);
    m_ordinal->addItem(tr("second"), 2);
    m_ordinal->addItem(tr("third"), 3);
    m_ordinal->addItem(tr("fourth"), 4);
    m_ordinal->addItem(tr("last"), -1);
    m_weekday = new QComboBox(m_repeatBox);
    for (int d = 1; d <= 7; ++d)
        m_weekday->addItem(locale.dayName(d), d);
    m_month = new QComboBox(m_repeatBox);
    for (int m = 1; m <= 12; ++m)
        m_month->addItem(tr("of %1").arg(locale.monthName(m)), m);
    byRow->addWidget(m_by);
    byRow->addWidget(m_monthDay);
    byRow->addWidget(m_ordinal);
    byRow->addWidget(m_weekday);
    byRow->addWidget(m_month);
    box->addLayout(byRow);

    auto *endRow = new QHBoxLayout;
    m_end = new QComboBox(m_repeatBox);
    m_end->addItems({ tr("forever"), tr("until"), tr("for") });
    m_until = new QDateEdit(m_repeatBox);
    m_until->setCalendarPopup(true);
    m_count = new QSpinBox(m_repeatBox);
    m_count->setRange(1, 999);
    m_count->setSuffix(tr(" times"));
    endRow->addWidget(m_end);
    endRow->addWidget(m_until);
    endRow->addWidget(m_count);
    box->addLayout(endRow);

    m_customLabel = new QLabel(tr("Custom rule, kept as is"), m_repeatBox);
    box->addWidget(m_customLabel);

    for (QComboBox *combo : { m_freq, m_by, m_end })
        connect(combo, &QComboBox::currentIndexChanged, this, &EventPane::refreshRepeatVisibility);
    connect(m_freq, &QComboBox::currentIndexChanged, this, &EventPane::proposeFromStart);
    return m_repeatBox;
}

void EventPane::refreshRepeatVisibility()
{
    const int freq = m_freq->currentIndex();
    const bool custom = freq == kCustomIndex;
    const bool repeats = freq > 0 && !custom;
    const bool monthly = freq == 3, yearly = freq == 4;
    const bool byWeekday = m_by->currentIndex() == 1;
    m_interval->setVisible(repeats);
    m_weekdayRow->setVisible(freq == 2);
    m_by->setVisible(monthly || yearly);
    // Yearly "on day" means on the start date, which needs no control.
    m_monthDay->setVisible(monthly && !byWeekday);
    m_ordinal->setVisible((monthly || yearly) && byWeekday);
    m_weekday->setVisible((monthly || yearly) && byWeekday);
    m_month->setVisible(yearly && byWeekday);
    m_end->setVisible(repeats);
    m_until->setVisible(repeats && m_end->currentIndex() == 1);
    m_count->setVisible(repeats && m_end->currentIndex() == 2);
    m_customLabel->setVisible(custom);
}

/// Re-proposes the day-dependent defaults from the start date, as Thunderbird
/// does: "on day 24", or "the fourth Thursday" (the fifth becomes "last").
void EventPane::proposeFromStart()
{
    const QDate start = m_startEdit->date();
    m_monthDay->setValue(start.day());
    const int ordinal = (start.day() - 1) / 7 + 1;
    m_ordinal->setCurrentIndex(m_ordinal->findData(ordinal > 4 ? -1 : ordinal));
    m_weekday->setCurrentIndex(m_weekday->findData(start.dayOfWeek()));
    m_month->setCurrentIndex(start.month() - 1);
    if (m_freq->currentIndex() == 2
        && std::none_of(m_weekdays.cbegin(), m_weekdays.cend(),
                        [](QCheckBox *c) { return c->isChecked(); }))
        m_weekdays[start.dayOfWeek() - 1]->setChecked(true);
}

void EventPane::setRepeat(const RepeatRule &rule)
{
    if (m_freq->count() > kCustomIndex)
        m_freq->removeItem(kCustomIndex);
    m_customRule = RepeatRule();
    if (rule.custom) {
        m_customRule = rule;
        m_freq->addItem(tr("Custom rule"));
        m_freq->setCurrentIndex(kCustomIndex);
        refreshRepeatVisibility();
        return;
    }
    m_freq->setCurrentIndex(static_cast<int>(rule.freq));
    proposeFromStart();
    m_interval->setValue(rule.interval);
    for (int d = 0; d < 7; ++d)
        m_weekdays[d]->setChecked(rule.weekdays.contains(d + 1));
    m_by->setCurrentIndex(rule.by == RepeatRule::By::Weekday ? 1 : 0);
    if (rule.monthDay)
        m_monthDay->setValue(rule.monthDay);
    if (rule.ordinal)
        m_ordinal->setCurrentIndex(m_ordinal->findData(rule.ordinal));
    if (rule.weekday)
        m_weekday->setCurrentIndex(m_weekday->findData(rule.weekday));
    if (rule.month)
        m_month->setCurrentIndex(rule.month - 1);
    m_end->setCurrentIndex(static_cast<int>(rule.end));
    m_until->setDate(rule.until.isValid() ? rule.until : m_startEdit->date().addMonths(1));
    m_count->setValue(qMax(1, rule.count));
    refreshRepeatVisibility();
}

RepeatRule EventPane::repeat() const
{
    if (m_freq->currentIndex() == kCustomIndex)
        return m_customRule;
    RepeatRule rule;
    rule.freq = static_cast<RepeatRule::Freq>(m_freq->currentIndex());
    if (rule.freq == RepeatRule::Freq::None)
        return rule;
    rule.interval = m_interval->value();
    rule.wkst = m_initial.repeat.wkst;  // carried through, spec
    if (rule.freq == RepeatRule::Freq::Weekly)
        for (int d = 0; d < 7; ++d)
            if (m_weekdays[d]->isChecked())
                rule.weekdays.append(d + 1);
    if (rule.freq == RepeatRule::Freq::Monthly || rule.freq == RepeatRule::Freq::Yearly) {
        rule.by = m_by->currentIndex() == 1 ? RepeatRule::By::Weekday : RepeatRule::By::MonthDay;
        if (rule.by == RepeatRule::By::Weekday) {
            rule.ordinal = m_ordinal->currentData().toInt();
            rule.weekday = m_weekday->currentData().toInt();
            if (rule.freq == RepeatRule::Freq::Yearly)
                rule.month = m_month->currentData().toInt();
        } else if (rule.freq == RepeatRule::Freq::Monthly) {
            rule.monthDay = m_monthDay->value();
        }
    }
    rule.end = static_cast<RepeatRule::End>(m_end->currentIndex());
    if (rule.end == RepeatRule::End::Until)
        rule.until = m_until->date();
    else if (rule.end == RepeatRule::End::Count)
        rule.count = m_count->value();
    return rule;
}

void EventPane::refreshAllDay()
{
    // All-day shows DATES, and the end is the LAST day, inclusive: what a
    // person means by "24 to 25 September". edit() converts back to the
    // exclusive end iCalendar needs.
    const QString format = m_allDay->isChecked()
        ? QLocale().dateFormat(QLocale::ShortFormat)
        : QLocale().dateTimeFormat(QLocale::ShortFormat);
    m_startEdit->setDisplayFormat(format);
    m_endEdit->setDisplayFormat(format);
}

void EventPane::showNothing()
{
    m_editing = false;
    setCurrentIndex(0);
}

void EventPane::showDetails(const CalEvent &event, const CalCollection &collection,
                            const Occurrence &occurrence, bool editable)
{
    m_editing = false;
    const QLocale locale;
    const CalOverride *ov = occurrence.isOverride ? &event.overrides[occurrence.overrideIndex] : nullptr;
    const QString summary = ov ? ov->summary : event.summary;
    m_title->setText(summary.isEmpty() ? tr("(no title)") : summary);

    const QDateTime start = occurrence.start.toLocalTime(), end = occurrence.end.toLocalTime();
    if (occurrence.allDay) {
        const QDate last = end.date().addDays(-1);
        m_when->setText(last > start.date()
            ? tr("%1 to %2, all day").arg(locale.toString(start.date(), QLocale::LongFormat),
                                          locale.toString(last, QLocale::LongFormat))
            : tr("%1, all day").arg(locale.toString(start.date(), QLocale::LongFormat)));
    } else {
        m_when->setText(tr("%1, %2 - %3").arg(locale.toString(start.date(), QLocale::LongFormat),
                                             locale.toString(start.time(), QLocale::ShortFormat),
                                             locale.toString(end.time(), QLocale::ShortFormat)));
    }
    m_repeatText->setText(event.repeat.freq == RepeatRule::Freq::None && !event.repeat.custom
                              ? tr("Does not repeat") : event.repeat.describe());
    m_calendar->setText(collection.displayName);
    m_location->setText(ov ? ov->location : event.location);
    m_notes->setText(ov ? ov->description : event.description);
    m_reminder->setText(event.hasAlarm ? tr("Yes, kept as set elsewhere") : tr("None"));

    QStringList people;
    if (!event.organizer.address.isEmpty())
        people << tr("Organiser: %1").arg(event.organizer.name.isEmpty()
                                              ? event.organizer.address : event.organizer.name);
    for (const CalPerson &a : event.attendees)
        people << QStringLiteral("%1 (%2)").arg(a.name.isEmpty() ? a.address : a.name,
                                                 a.partstat.isEmpty() ? tr("no reply") : a.partstat.toLower());
    m_people->setText(people.join(QLatin1Char('\n')));

    QString notice;
    if (collection.readOnly)
        notice = tr("Read-only calendar.");
    else if (!editable)
        notice = tr("Organised by %1: read-only.").arg(event.organizer.name.isEmpty()
                                                           ? event.organizer.address : event.organizer.name);
    m_notice->setText(notice);
    m_notice->setVisible(!notice.isEmpty());
    // Absent, not disabled (AGENTS.md precedent).
    m_editButton->setVisible(editable);
    m_deleteButton->setVisible(editable);
    setCurrentIndex(1);
}

void EventPane::startEdit(const EventEdit &initial, const QList<CalCollection> &collections,
                          bool repeatEditable, bool collectionEditable,
                          const QString &reminderText, const QString &attendeesText)
{
    m_initial = initial;
    m_editing = false;  // no duration-keeping while the fields are filled
    m_calendarBox->clear();
    for (const CalCollection &c : collections)
        m_calendarBox->addItem(swatch(c.color), c.displayName, c.dir);
    m_calendarBox->setCurrentIndex(qMax(0, m_calendarBox->findData(initial.collectionDir)));
    m_calendarBox->setEnabled(collectionEditable);

    m_previousStart = QDateTime();
    m_titleEdit->setText(initial.summary);
    m_allDay->setChecked(initial.allDay);
    refreshAllDay();
    m_startEdit->setDateTime(initial.start.toLocalTime());
    m_endEdit->setDateTime(initial.allDay ? initial.end.toLocalTime().addDays(-1)
                                          : initial.end.toLocalTime());
    m_locationEdit->setText(initial.location);
    m_notesEdit->setPlainText(initial.description);
    setRepeat(initial.repeat);
    m_repeatBox->setEnabled(repeatEditable);
    m_formReminder->setText(reminderText);
    m_formPeople->setText(attendeesText);
    m_formNotice->setText(attendeesText.isEmpty() ? QString()
                              : tr("Attendees have not been notified of changes."));
    m_formNotice->setVisible(!attendeesText.isEmpty());

    // The form rounds what it shows (seconds, the display format), so the
    // baseline for isDirty() is what the form PRODUCES, not what came in.
    m_initial = edit();
    m_editing = true;
    setCurrentIndex(2);
    m_titleEdit->setFocus();
}

void EventPane::stopEdit() { m_editing = false; }
bool EventPane::isEditing() const { return m_editing; }
bool EventPane::isDirty() const { return m_editing && !sameEdit(edit(), m_initial); }

EventEdit EventPane::edit() const
{
    EventEdit e;
    e.summary = m_titleEdit->text().trimmed();
    e.location = m_locationEdit->text().trimmed();
    e.description = m_notesEdit->toPlainText();
    e.allDay = m_allDay->isChecked();
    e.collectionDir = m_calendarBox->currentData().toString();
    if (e.allDay) {
        e.start = QDateTime(m_startEdit->date(), QTime(0, 0));
        e.end = QDateTime(qMax(m_endEdit->date(), m_startEdit->date()).addDays(1), QTime(0, 0));
    } else {
        e.start = m_startEdit->dateTime();
        e.end = qMax(m_endEdit->dateTime(), e.start);
    }
    e.repeat = repeat();
    return e;
}
```

Add `#include <algorithm>`. `QDateTimeEdit::dateTime()` returns local time with the edit's time spec; check it is `Qt::LocalTime` so `applyEdit` converts it into the event's zone correctly, and that the test `saveWritesAndUndoRestores` (Task 14) still round-trips the unchanged start.

- [ ] **Step 3: Build**

Add `eventpane.cpp` to `src/CMakeLists.txt`.
Run: `cmake --build build 2>&1 | tail -3`
Expected: builds cleanly.

- [ ] **Step 4: Commit**

```bash
git add src/eventpane.h src/eventpane.cpp src/CMakeLists.txt
git commit -m "feat: show and edit a calendar event in the side pane"
```

---

### Task 14: `CalendarWindow`

**Files:**
- Create: `src/calendarwindow.h`, `src/calendarwindow.cpp`
- Modify: `src/CMakeLists.txt`, `tests/CMakeLists.txt` (`add_qtmaildir_test(calendarwindow)`)
- Test: `tests/test_calendarwindow.cpp`

- [ ] **Step 1: Write the failing tests**

```cpp
/* GPLv2 header */

#include <QtTest>
#include <QApplication>
#include <QDir>
#include <QFile>
#include <QLineEdit>
#include <QMessageBox>
#include <QPushButton>
#include <QTemporaryDir>
#include <QUndoStack>

#include "calendarwindow.h"
#include "config.h"

namespace {

QByteArray eventText(const QString &uid, const QString &summary, int day)
{
    return QStringLiteral(
        "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//example//test//EN\r\n"
        "BEGIN:VEVENT\r\nUID:%1\r\nDTSTAMP:20260901T000000Z\r\n"
        "DTSTART:202609%2T080000Z\r\nDTEND:202609%2T090000Z\r\nSUMMARY:%3\r\n"
        "END:VEVENT\r\nEND:VCALENDAR\r\n")
        .arg(uid).arg(day, 2, 10, QLatin1Char('0')).arg(summary).toUtf8();
}

void writeFile(const QString &path, const QByteArray &content)
{
    QDir().mkpath(QFileInfo(path).absolutePath());
    QFile f(path);
    QVERIFY(f.open(QIODevice::WriteOnly | QIODevice::Truncate));
    f.write(content);
}

QByteArray read(const QString &path)
{
    QFile f(path);
    return f.open(QIODevice::ReadOnly) ? f.readAll() : QByteArray();
}

/// A vdir with collections "a" and "b", two events in "a", and a config
/// pointing at it with syncing off, so no test ever runs vdirsyncer.
struct Fixture
{
    QTemporaryDir dir;
    Config config;
    QString a() const { return dir.filePath(QStringLiteral("cal/a/one.ics")); }

    Fixture()
    {
        writeFile(a(), eventText(QStringLiteral("one@example.org"), QStringLiteral("One"), 22));
        writeFile(dir.filePath(QStringLiteral("cal/a/two.ics")),
                  eventText(QStringLiteral("two@example.org"), QStringLiteral("Two"), 23));
        QDir().mkpath(dir.filePath(QStringLiteral("cal/b")));
        const QString ini = dir.filePath(QStringLiteral("qtmaildir.conf"));
        writeFile(ini, QStringLiteral("[general]\ncalendars_dir = %1\n"
                                      "default_calendar = b\ncalendar_sync_command = \n")
                           .arg(dir.filePath(QStringLiteral("cal"))).toUtf8());
        config.load(ini);
    }

    CalendarWindow *window()
    {
        auto *w = new CalendarWindow(config, { QStringLiteral("me@example.org") },
                                     dir.filePath(QStringLiteral("uistate.conf")));
        w->showMonth(2026, 9);
        w->show();
        return w;
    }
};

/// Answers the next modal QMessageBox with `button` once it is up.
void answerNextBox(QMessageBox::StandardButton button)
{
    QTimer::singleShot(0, [button]() {
        auto *box = qobject_cast<QMessageBox *>(QApplication::activeModalWidget());
        QVERIFY2(box, "no modal message box appeared");
        box->button(button)->click();
    });
}

void editTitle(CalendarWindow *w, const QString &title)
{
    w->findChild<QPushButton *>(QStringLiteral("editEvent"))->click();
    w->findChild<QLineEdit *>(QStringLiteral("eventTitle"))->setText(title);
}

} // namespace

class TestCalendarWindow : public QObject
{
    Q_OBJECT

private slots:
    void loadsAndSelects();
    void theEditLockRefusesASelectionChange();
    void closingWithUnsavedChangesAsksOnEveryRoute();
    void saveWritesAndUndoRestoresTheOriginalBytes();
    void aNewEventGoesToTheDefaultCalendar();
    void aStaleSaveKeepsTheFormAndTheSyncedFile();
};

void TestCalendarWindow::loadsAndSelects()
{
    Fixture f;
    std::unique_ptr<CalendarWindow> w(f.window());
    QVERIFY(w->selectEvent(QStringLiteral("two@example.org")));
    QCOMPARE(w->selectedUid(), QStringLiteral("two@example.org"));
    QVERIFY(!w->selectEvent(QStringLiteral("absent@example.org")));
}

void TestCalendarWindow::theEditLockRefusesASelectionChange()
{
    Fixture f;
    std::unique_ptr<CalendarWindow> w(f.window());
    QVERIFY(w->selectEvent(QStringLiteral("one@example.org")));
    editTitle(w.get(), QStringLiteral("Changed"));
    QVERIFY(!w->selectEvent(QStringLiteral("two@example.org")));
    QCOMPARE(w->selectedUid(), QStringLiteral("one@example.org"));
}

void TestCalendarWindow::closingWithUnsavedChangesAsksOnEveryRoute()
{
    Fixture f;
    const QByteArray original = read(f.a());

    // Cancel keeps the window and the file. Route: close().
    std::unique_ptr<CalendarWindow> w(f.window());
    w->selectEvent(QStringLiteral("one@example.org"));
    editTitle(w.get(), QStringLiteral("Changed"));
    answerNextBox(QMessageBox::Cancel);
    w->close();
    QVERIFY(w->isVisible());
    QCOMPARE(read(f.a()), original);

    // Discard closes and writes nothing. Route: the File menu's Close action.
    answerNextBox(QMessageBox::Discard);
    w->findChild<QAction *>(QStringLiteral("closeCalendar"))->trigger();
    QVERIFY(!w->isVisible());
    QCOMPARE(read(f.a()), original);

    // Save closes and writes.
    std::unique_ptr<CalendarWindow> again(f.window());
    again->selectEvent(QStringLiteral("one@example.org"));
    editTitle(again.get(), QStringLiteral("Saved on close"));
    answerNextBox(QMessageBox::Save);
    again->close();
    QVERIFY(!again->isVisible());
    QVERIFY(read(f.a()).contains("SUMMARY:Saved on close"));
}

void TestCalendarWindow::saveWritesAndUndoRestoresTheOriginalBytes()
{
    Fixture f;
    const QByteArray original = read(f.a());
    std::unique_ptr<CalendarWindow> w(f.window());
    w->selectEvent(QStringLiteral("one@example.org"));
    editTitle(w.get(), QStringLiteral("Renamed"));
    w->findChild<QPushButton *>(QStringLiteral("saveEvent"))->click();
    QVERIFY(read(f.a()).contains("SUMMARY:Renamed"));

    w->undoStack()->undo();
    QCOMPARE(read(f.a()), original);   // exactly the bytes it had: item 176's rule
    w->undoStack()->redo();
    QVERIFY(read(f.a()).contains("SUMMARY:Renamed"));
}

void TestCalendarWindow::aNewEventGoesToTheDefaultCalendar()
{
    Fixture f;
    std::unique_ptr<CalendarWindow> w(f.window());
    w->findChild<QAction *>(QStringLiteral("newEvent"))->trigger();
    w->findChild<QLineEdit *>(QStringLiteral("eventTitle"))->setText(QStringLiteral("Fresh"));
    w->findChild<QPushButton *>(QStringLiteral("saveEvent"))->click();
    const QStringList created = QDir(f.dir.filePath(QStringLiteral("cal/b")))
                                    .entryList({ QStringLiteral("*.ics") }, QDir::Files);
    QCOMPARE(created.size(), 1);
    QVERIFY(read(f.dir.filePath(QStringLiteral("cal/b/")) + created.first()).contains("SUMMARY:Fresh"));

    w->undoStack()->undo();
    QVERIFY(QDir(f.dir.filePath(QStringLiteral("cal/b"))).entryList({ QStringLiteral("*.ics") }).isEmpty());
}

void TestCalendarWindow::aStaleSaveKeepsTheFormAndTheSyncedFile()
{
    Fixture f;
    std::unique_ptr<CalendarWindow> w(f.window());
    w->selectEvent(QStringLiteral("one@example.org"));
    editTitle(w.get(), QStringLiteral("Mine"));
    // A sync pulls a server change while the form is open.
    const QByteArray synced = eventText(QStringLiteral("one@example.org"), QStringLiteral("Theirs"), 22);
    writeFile(f.a(), synced);
    w->findChild<QPushButton *>(QStringLiteral("saveEvent"))->click();
    QCOMPARE(read(f.a()), synced);           // nothing clobbered
    QVERIFY(w->isEditing());                  // the user's values are still there
    QCOMPARE(w->findChild<QLineEdit *>(QStringLiteral("eventTitle"))->text(), QStringLiteral("Mine"));
}

QTEST_MAIN(TestCalendarWindow)
#include "test_calendarwindow.moc"
```

`std::unique_ptr<CalendarWindow>` requires the window NOT to set `WA_DeleteOnClose` itself; `MainWindow` sets that when it opens one (Task 15), as it does for composers. Add `#include <memory>` and `#include <QTimer>`.

- [ ] **Step 2: Write `src/calendarwindow.h`**

```cpp
/* GPLv2 header */

#pragma once

#include "caltypes.h"
#include "config.h"

#include <QFileSystemWatcher>
#include <QHash>
#include <QMainWindow>
#include <QTimer>
#include <QUndoStack>

#include <optional>

class AgendaView;
class CalendarSync;
class EventPane;
class MonthView;
class QComboBox;
class QLabel;
class QSpinBox;
class QStackedWidget;
class QToolButton;

/// The calendar (item 206): its own top-level window, like ComposeWindow.
/// Spec: docs/superpowers/specs/2026-09-24-calendar-design.md.
class CalendarWindow : public QMainWindow
{
    Q_OBJECT

public:
    CalendarWindow(const Config &config, const QStringList &ownAddresses,
                   const QString &uiStatePath, QWidget *parent = nullptr);
    ~CalendarWindow() override;

    void showMonth(int year, int month);
    /// Selects an event's occurrence (the first in view when `start` is
    /// invalid). False when not found, or refused by the edit lock.
    bool selectEvent(const QString &uid, const QDateTime &start = {});
    QString selectedUid() const;
    bool isEditing() const;
    QUndoStack *undoStack() { return &m_undo; }

    /// One file's before and after, either absent. What a write and its undo
    /// are made of.
    struct Change
    {
        QString path;
        std::optional<QByteArray> before;
        std::optional<QByteArray> after;
    };
    /// Applies `changes` in order through CalendarWriter. On a failure the
    /// ones already applied are rolled back and the reason is reported.
    bool applyChanges(const QList<Change> &changes, bool reverse);

protected:
    void closeEvent(QCloseEvent *event) override;

private:
    void buildUi();
    void buildActions();
    void reload();
    void rebuildItems();
    void refreshToolbar();
    void select(int item);
    void startEdit();
    void startNew(const QDate &day);
    QDate defaultNewDay() const;
    bool save();
    void cancelEdit();
    void deleteSelected();
    bool writeAndRecord(const QString &label, const QList<Change> &changes);
    void checkAfterSync();
    const CalCollection *collection(const QString &dir) const;
    QList<CalCollection> writableCollections() const;
    QString defaultCollection() const;
    void status(const QString &text);

    Config m_config;
    QStringList m_ownAddresses;
    QString m_uiStatePath;

    LoadResult m_data;
    QList<CalendarItem> m_items;
    int m_year;
    int m_month;
    int m_selected = -1;
    QString m_selectedUid;         ///< survives a reload
    QDateTime m_selectedStart;

    // The open edit. m_editPath empty with m_editing: a new event.
    QString m_editPath;
    QByteArray m_editBase;
    bool m_editWholeSeries = true;
    QDateTime m_editRecurrenceId;

    QUndoStack m_undo;
    CalendarSync *m_sync;
    QFileSystemWatcher m_watcher;
    QTimer m_reloadTimer;
    /// Written since the last sync started: path to the text written, or
    /// nullopt for a deletion. Checked by meaning after the next sync.
    QHash<QString, std::optional<QByteArray>> m_written;
    QHash<QString, std::optional<QByteArray>> m_checking;

    QComboBox *m_collectionBox;
    QComboBox *m_monthBox;
    QSpinBox *m_yearSpin;
    QToolButton *m_monthButton;
    QToolButton *m_agendaButton;
    QStackedWidget *m_views;
    MonthView *m_monthView;
    AgendaView *m_agendaView;
    EventPane *m_pane;
    QLabel *m_dataWarning;
};
```

- [ ] **Step 3: Run to verify the tests fail**

Run: `cmake --build build 2>&1 | tail -3`
Expected: link failure for `CalendarWindow`.

- [ ] **Step 4: Write `src/calendarwindow.cpp`**

The undo command first, then the window. It is long; the reviewer should read it against the spec's "Writing" and "The window" sections line by line.

```cpp
/* GPLv2 header */

#include "calendarwindow.h"
#include "agendaview.h"
#include "calendarstore.h"
#include "calendarsync.h"
#include "calendarwriter.h"
#include "eventpane.h"
#include "monthview.h"

#include <QButtonGroup>
#include <QCloseEvent>
#include <QComboBox>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QHBoxLayout>
#include <QLabel>
#include <QLocale>
#include <QMenuBar>
#include <QMessageBox>
#include <QPainter>
#include <QPixmap>
#include <QPushButton>
#include <QSettings>
#include <QSpinBox>
#include <QSplitter>
#include <QStackedWidget>
#include <QStatusBar>
#include <QTimeZone>
#include <QToolBar>
#include <QToolButton>
#include <QUndoCommand>

namespace {

/// One undoable write. The write itself happened before the push, so the
/// first redo() (which QUndoStack::push calls) does nothing. Undo restores
/// exactly the bytes the write replaced, expecting on disk exactly the bytes
/// it wrote: a sync in between makes it refuse, and the command is dropped.
class FileCommand : public QUndoCommand
{
public:
    FileCommand(const QString &text, const QList<CalendarWindow::Change> &changes,
                CalendarWindow *window)
        : QUndoCommand(text), m_changes(changes), m_window(window) {}

    void undo() override
    {
        if (!m_window->applyChanges(m_changes, true))
            setObsolete(true);
    }

    void redo() override
    {
        if (m_first) {
            m_first = false;
            return;
        }
        if (!m_window->applyChanges(m_changes, false))
            setObsolete(true);
    }

private:
    QList<CalendarWindow::Change> m_changes;
    CalendarWindow *m_window;
    bool m_first = true;
};

QIcon swatch(const QColor &colour)
{
    QPixmap pixmap(12, 12);
    pixmap.fill(Qt::transparent);
    QPainter(&pixmap).fillRect(pixmap.rect(), colour);
    return QIcon(pixmap);
}

QByteArray readFile(const QString &path)
{
    QFile f(path);
    return f.open(QIODevice::ReadOnly) ? f.readAll() : QByteArray();
}

} // namespace

CalendarWindow::CalendarWindow(const Config &config, const QStringList &ownAddresses,
                               const QString &uiStatePath, QWidget *parent)
    : QMainWindow(parent), m_config(config), m_ownAddresses(ownAddresses),
      m_uiStatePath(uiStatePath),
      m_year(QDate::currentDate().year()), m_month(QDate::currentDate().month())
{
    setWindowTitle(tr("Calendar"));
    m_sync = new CalendarSync(m_config.calendarSyncCommand(),
                              m_config.calendarSyncDelayMs(), this);
    connect(m_sync, &CalendarSync::started, this, [this]() {
        status(tr("Syncing calendars..."));
        m_checking.insert(m_written);  // insert(QHash) merges
        m_written.clear();
    });
    connect(m_sync, &CalendarSync::finished, this, [this](bool ok, const QString &output) {
        if (!ok) {
            QMessageBox::warning(this, tr("Calendar sync failed"), output);
            status(tr("Calendar sync failed."));
        }
        checkAfterSync();
    });

    m_reloadTimer.setSingleShot(true);
    m_reloadTimer.setInterval(500);
    connect(&m_reloadTimer, &QTimer::timeout, this, &CalendarWindow::reload);
    connect(&m_watcher, &QFileSystemWatcher::directoryChanged, this,
            [this]() { m_reloadTimer.start(); });

    buildUi();
    buildActions();

    QSettings state(m_uiStatePath, QSettings::IniFormat);
    state.beginGroup(QStringLiteral("calendar"));
    restoreGeometry(state.value(QStringLiteral("geometry")).toByteArray());
    const bool agenda = state.value(QStringLiteral("agenda"), false).toBool();
    const QString collectionDir = state.value(QStringLiteral("collection")).toString();
    state.endGroup();

    reload();
    const int index = m_collectionBox->findData(collectionDir);
    if (index >= 0)
        m_collectionBox->setCurrentIndex(index);
    (agenda ? m_agendaButton : m_monthButton)->click();
}

CalendarWindow::~CalendarWindow() = default;

void CalendarWindow::buildUi()
{
    auto *toolbar = addToolBar(tr("Calendar"));
    toolbar->setObjectName(QStringLiteral("calendarToolbar"));
    toolbar->setMovable(false);

    m_collectionBox = new QComboBox(this);
    m_collectionBox->setObjectName(QStringLiteral("collectionBox"));
    toolbar->addWidget(m_collectionBox);
    toolbar->addSeparator();

    auto addButton = [&](const QString &text, auto slot) {
        auto *b = new QToolButton(this);
        b->setText(text);
        connect(b, &QToolButton::clicked, this, slot);
        toolbar->addWidget(b);
        return b;
    };
    addButton(QStringLiteral("‹"), [this]() {
        const QDate d = QDate(m_year, m_month, 1).addMonths(-1);
        showMonth(d.year(), d.month());
    })->setToolTip(tr("Previous month"));
    addButton(tr("Today"), [this]() {
        showMonth(QDate::currentDate().year(), QDate::currentDate().month());
        m_agendaView->scrollToDay(QDate::currentDate());
    })->setToolTip(tr("Go to today"));
    addButton(QStringLiteral("›"), [this]() {
        const QDate d = QDate(m_year, m_month, 1).addMonths(1);
        showMonth(d.year(), d.month());
    })->setToolTip(tr("Next month"));

    m_monthBox = new QComboBox(this);
    for (int m = 1; m <= 12; ++m)
        m_monthBox->addItem(QLocale().standaloneMonthName(m), m);
    toolbar->addWidget(m_monthBox);
    m_yearSpin = new QSpinBox(this);
    m_yearSpin->setRange(1900, 2200);
    toolbar->addWidget(m_yearSpin);
    connect(m_monthBox, &QComboBox::activated, this,
            [this](int index) { showMonth(m_year, index + 1); });
    connect(m_yearSpin, &QSpinBox::valueChanged, this, [this](int year) {
        if (year != m_year)
            showMonth(year, m_month);
    });

    auto *spacer = new QWidget(this);
    spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    toolbar->addWidget(spacer);

    m_monthButton = new QToolButton(this);
    m_monthButton->setText(tr("Month"));
    m_monthButton->setCheckable(true);
    m_agendaButton = new QToolButton(this);
    m_agendaButton->setText(tr("Agenda"));
    m_agendaButton->setCheckable(true);
    auto *group = new QButtonGroup(this);
    group->addButton(m_monthButton, 0);
    group->addButton(m_agendaButton, 1);
    toolbar->addWidget(m_monthButton);
    toolbar->addWidget(m_agendaButton);

    auto *splitter = new QSplitter(this);
    m_views = new QStackedWidget(splitter);
    m_monthView = new MonthView(m_views);
    m_agendaView = new AgendaView(m_views);
    m_views->addWidget(m_monthView);
    m_views->addWidget(m_agendaView);
    m_pane = new EventPane(splitter);
    splitter->addWidget(m_views);
    splitter->addWidget(m_pane);
    splitter->setStretchFactor(0, 3);
    splitter->setStretchFactor(1, 1);
    setCentralWidget(splitter);

    m_dataWarning = new QLabel(this);
    statusBar()->addPermanentWidget(m_dataWarning);

    connect(group, &QButtonGroup::idClicked, m_views, &QStackedWidget::setCurrentIndex);
    connect(m_collectionBox, &QComboBox::currentIndexChanged, this, &CalendarWindow::rebuildItems);
    connect(m_monthView, &MonthView::itemClicked, this, &CalendarWindow::select);
    connect(m_agendaView, &AgendaView::itemClicked, this, &CalendarWindow::select);
    connect(m_monthView, &MonthView::dayDoubleClicked, this, &CalendarWindow::startNew);
    connect(m_monthView, &MonthView::moreClicked, this, [this](const QDate &day) {
        m_agendaButton->click();
        m_agendaView->scrollToDay(day);
    });
    connect(m_pane, &EventPane::editRequested, this, &CalendarWindow::startEdit);
    connect(m_pane, &EventPane::deleteRequested, this, &CalendarWindow::deleteSelected);
    connect(m_pane, &EventPane::saveRequested, this, &CalendarWindow::save);
    connect(m_pane, &EventPane::cancelRequested, this, &CalendarWindow::cancelEdit);
}
```

The actions. **The shortcut contexts are load-bearing.** A `QAction` shortcut is dispatched before the focused widget sees the key (AGENTS.md), so a window-wide `Delete` would delete the EVENT while the user deletes a character in the Title field, `Ctrl+Z` would undo a file write instead of a typo, and `PgUp`/`Home` would change month from inside the Notes box. Those actions are therefore added to the views widget with `Qt::WidgetWithChildrenShortcut`, so they fire only when focus is in the grid or the list. The menu entries still work from anywhere, because a menu triggers the action directly.

```cpp
void CalendarWindow::buildActions()
{
    auto make = [this](const QString &name, const QString &text, const QKeySequence &key,
                       QWidget *scope, auto slot) {
        auto *a = new QAction(text, this);
        a->setObjectName(name);
        a->setShortcut(key);
        if (scope) {
            a->setShortcutContext(Qt::WidgetWithChildrenShortcut);
            scope->addAction(a);
        } else {
            addAction(a);
        }
        connect(a, &QAction::triggered, this, slot);
        return a;
    };

    QAction *newEvent = make(QStringLiteral("newEvent"), tr("&New event"),
                             QKeySequence(Qt::CTRL | Qt::Key_N), nullptr,
                             [this]() { startNew(defaultNewDay()); });
    QAction *close = make(QStringLiteral("closeCalendar"), tr("&Close"),
                          QKeySequence(Qt::CTRL | Qt::Key_W), nullptr, [this]() { this->close(); });
    QAction *edit = make(QStringLiteral("editEvent"), tr("&Edit event"),
                         QKeySequence(Qt::CTRL | Qt::Key_E), nullptr, &CalendarWindow::startEdit);
    QAction *del = make(QStringLiteral("deleteEvent"), tr("&Delete event"),
                        QKeySequence(Qt::Key_Delete), m_views, &CalendarWindow::deleteSelected);
    QAction *cancel = make(QStringLiteral("cancelEdit"), tr("Cancel &editing"),
                           QKeySequence(Qt::Key_Escape), m_pane, &CalendarWindow::cancelEdit);

    QAction *undo = m_undo.createUndoAction(this, tr("&Undo"));
    undo->setShortcut(QKeySequence::Undo);
    undo->setShortcutContext(Qt::WidgetWithChildrenShortcut);
    m_views->addAction(undo);
    QAction *redo = m_undo.createRedoAction(this, tr("&Redo"));
    redo->setShortcut(QKeySequence(Qt::CTRL | Qt::SHIFT | Qt::Key_Z));
    redo->setShortcutContext(Qt::WidgetWithChildrenShortcut);
    m_views->addAction(redo);

    QAction *prev = make(QStringLiteral("previousMonth"), tr("&Previous month"),
                         QKeySequence(Qt::Key_PageUp), m_views, [this]() {
        const QDate d = QDate(m_year, m_month, 1).addMonths(-1);
        showMonth(d.year(), d.month());
    });
    QAction *next = make(QStringLiteral("nextMonth"), tr("&Next month"),
                         QKeySequence(Qt::Key_PageDown), m_views, [this]() {
        const QDate d = QDate(m_year, m_month, 1).addMonths(1);
        showMonth(d.year(), d.month());
    });
    QAction *today = make(QStringLiteral("today"), tr("&Today"),
                          QKeySequence(Qt::Key_Home), m_views, [this]() {
        showMonth(QDate::currentDate().year(), QDate::currentDate().month());
    });
    QAction *month = make(QStringLiteral("monthView"), tr("&Month"), {}, nullptr,
                          [this]() { m_monthButton->click(); });
    QAction *agenda = make(QStringLiteral("agendaView"), tr("&Agenda"), {}, nullptr,
                           [this]() { m_agendaButton->click(); });

    QMenu *file = menuBar()->addMenu(tr("&File"));
    file->addAction(newEvent);
    file->addSeparator();
    file->addAction(close);
    QMenu *editMenu = menuBar()->addMenu(tr("&Edit"));
    editMenu->addAction(undo);
    editMenu->addAction(redo);
    editMenu->addSeparator();
    editMenu->addAction(edit);
    editMenu->addAction(del);
    editMenu->addAction(cancel);
    QMenu *view = menuBar()->addMenu(tr("&View"));
    view->addAction(month);
    view->addAction(agenda);
    view->addSeparator();
    view->addAction(prev);
    view->addAction(next);
    view->addAction(today);
}
```

```cpp
/// Where + New puts an event: today when today is in the shown month,
/// otherwise the month's first day, so the new event is on screen.
QDate CalendarWindow::defaultNewDay() const
{
    const QDate first(m_year, m_month, 1);
    const QDate today = QDate::currentDate();
    return today >= first && today < first.addMonths(1) ? today : first;
}

void CalendarWindow::showMonth(int year, int month)
{
    m_year = year;
    m_month = month;
    m_monthView->setMonth(year, month);
    refreshToolbar();
    rebuildItems();
}

void CalendarWindow::refreshToolbar()
{
    const QSignalBlocker a(m_monthBox), b(m_yearSpin);
    m_monthBox->setCurrentIndex(m_month - 1);
    m_yearSpin->setValue(m_year);
}

void CalendarWindow::reload()
{
    m_data = CalendarStore::load(m_config.calendarsDir());

    if (!m_watcher.directories().isEmpty())
        m_watcher.removePaths(m_watcher.directories());
    QStringList dirs{ m_config.calendarsDir() };
    for (const CalCollection &c : m_data.collections)
        dirs << c.path;
    m_watcher.addPaths(dirs);

    const QString current = m_collectionBox->currentData().toString();
    {
        const QSignalBlocker block(m_collectionBox);
        m_collectionBox->clear();
        m_collectionBox->addItem(tr("All calendars"), QString());
        for (const CalCollection &c : m_data.collections)
            m_collectionBox->addItem(swatch(c.color), c.displayName, c.dir);
        m_collectionBox->setCurrentIndex(qMax(0, m_collectionBox->findData(current)));
    }

    QStringList warnings;
    if (m_data.unparsable)
        warnings << tr("%n file(s) could not be read", nullptr, m_data.unparsable);
    if (m_data.unknownZones)
        warnings << tr("%n event(s) in an unknown time zone, shown in local time", nullptr,
                       m_data.unknownZones);
    m_dataWarning->setText(warnings.join(QStringLiteral("; ")));
    rebuildItems();
}

void CalendarWindow::rebuildItems()
{
    const QString filter = m_collectionBox->currentData().toString();
    const QDateTime from(m_monthView->firstDay(), QTime(0, 0));
    const QDateTime to(m_monthView->lastDay(), QTime(0, 0));
    m_items.clear();
    for (const Occurrence &o : CalendarStore::occurrences(m_data.events, from, to)) {
        const CalEvent &e = m_data.events[o.eventIndex];
        if (!filter.isEmpty() && e.collectionDir != filter)
            continue;
        const CalCollection *c = collection(e.collectionDir);
        QString title = o.isOverride ? e.overrides[o.overrideIndex].summary : e.summary;
        if (title.isEmpty())
            title = tr("(no title)");
        m_items.append({ o, title, c ? c->color : QColor(Qt::gray) });
    }
    m_monthView->setItems(m_items);

    // The agenda covers the month the toolbar names, not the grid's
    // spill-over. Out-of-month items become blanks, which AgendaView skips,
    // so a row's index is the same index the month grid reports.
    // ponytail: blanks rather than an index map; add the map if the agenda
    // ever needs a range of its own.
    const QDate first(m_year, m_month, 1);
    QList<CalendarItem> agenda;
    for (const CalendarItem &item : m_items) {
        const QDate d = item.occurrence.start.toLocalTime().date();
        agenda.append(d >= first && d < first.addMonths(1) ? item : CalendarItem{});
    }
    m_agendaView->setItems(agenda);

    // Re-find the selection by identity: a reload renumbers everything.
    m_selected = -1;
    for (int i = 0; i < m_items.size(); ++i) {
        const Occurrence &o = m_items[i].occurrence;
        if (m_data.events[o.eventIndex].uid == m_selectedUid
            && (!m_selectedStart.isValid() || o.start == m_selectedStart)) {
            m_selected = i;
            break;
        }
    }
    m_monthView->setSelected(m_selected);
    m_agendaView->setSelected(m_selected);
    if (!m_pane->isEditing()) {
        if (m_selected >= 0) {
            const Occurrence &o = m_items[m_selected].occurrence;
            const CalEvent &e = m_data.events[o.eventIndex];
            const CalCollection *c = collection(e.collectionDir);
            m_pane->showDetails(e, c ? *c : CalCollection{}, o,
                                c && CalendarStore::isEditable(e, *c, m_ownAddresses));
        } else {
            m_pane->showNothing();
        }
    }
}
```

```cpp
void CalendarWindow::select(int item)
{
    if (m_pane->isEditing()) {
        status(tr("Save or cancel the event being edited first."));
        return;
    }
    if (item < 0 || item >= m_items.size())
        return;
    const Occurrence &o = m_items[item].occurrence;
    m_selectedUid = m_data.events[o.eventIndex].uid;
    m_selectedStart = o.start;
    rebuildItems();
}

bool CalendarWindow::selectEvent(const QString &uid, const QDateTime &start)
{
    if (m_pane->isEditing())
        return false;
    for (int i = 0; i < m_items.size(); ++i) {
        const Occurrence &o = m_items[i].occurrence;
        if (m_data.events[o.eventIndex].uid == uid && (!start.isValid() || o.start == start)) {
            select(i);
            return true;
        }
    }
    return false;
}

QString CalendarWindow::selectedUid() const
{
    return m_selected >= 0 ? m_data.events[m_items[m_selected].occurrence.eventIndex].uid : QString();
}

bool CalendarWindow::isEditing() const { return m_pane->isEditing(); }

const CalCollection *CalendarWindow::collection(const QString &dir) const
{
    for (const CalCollection &c : m_data.collections)
        if (c.dir == dir)
            return &c;
    return nullptr;
}

QList<CalCollection> CalendarWindow::writableCollections() const
{
    QList<CalCollection> result;
    for (const CalCollection &c : m_data.collections)
        if (!c.readOnly)
            result.append(c);
    return result;
}

QString CalendarWindow::defaultCollection() const
{
    const QList<CalCollection> writable = writableCollections();
    for (const CalCollection &c : writable)
        if (c.dir == m_config.defaultCalendar())
            return c.dir;
    return writable.isEmpty() ? QString() : writable.first().dir;
}

void CalendarWindow::startEdit()
{
    if (m_pane->isEditing() || m_selected < 0)
        return;
    const Occurrence &o = m_items[m_selected].occurrence;
    const CalEvent &e = m_data.events[o.eventIndex];
    const CalCollection *c = collection(e.collectionDir);
    if (!c || !CalendarStore::isEditable(e, *c, m_ownAddresses))
        return;

    // A repeating event asks its scope when Edit is pressed, never after.
    m_editWholeSeries = true;
    m_editRecurrenceId = {};
    if (e.repeat.freq != RepeatRule::Freq::None || e.repeat.custom) {
        QMessageBox box(QMessageBox::Question, tr("Edit a repeating event"),
                        tr("Edit only this occurrence, or every occurrence?"),
                        QMessageBox::Cancel, this);
        QPushButton *one = box.addButton(tr("This occurrence"), QMessageBox::AcceptRole);
        QPushButton *all = box.addButton(tr("All occurrences"), QMessageBox::AcceptRole);
        box.exec();
        if (box.clickedButton() != one && box.clickedButton() != all)
            return;
        m_editWholeSeries = box.clickedButton() == all;
        m_editRecurrenceId = o.recurrenceId;
    }

    EventEdit initial;
    const CalOverride *ov = o.isOverride ? &e.overrides[o.overrideIndex] : nullptr;
    initial.summary = ov ? ov->summary : e.summary;
    initial.location = ov ? ov->location : e.location;
    initial.description = ov ? ov->description : e.description;
    initial.allDay = m_editWholeSeries ? e.allDay : o.allDay;
    initial.start = m_editWholeSeries ? e.start : o.start;
    initial.end = m_editWholeSeries ? e.end : o.end;
    initial.repeat = e.repeat;
    initial.collectionDir = e.collectionDir;

    QStringList people;
    for (const CalPerson &a : e.attendees)
        people << (a.name.isEmpty() ? a.address : a.name);

    m_editPath = e.filePath;
    m_editBase = e.rawText;
    m_pane->startEdit(initial, writableCollections(), m_editWholeSeries, m_editWholeSeries,
                      e.hasAlarm ? tr("Kept as set elsewhere") : tr("None"),
                      people.join(QStringLiteral(", ")));
}

void CalendarWindow::startNew(const QDate &day)
{
    if (m_pane->isEditing() || defaultCollection().isEmpty())
        return;
    EventEdit initial;
    initial.start = QDateTime(day, QTime(9, 0));
    initial.end = initial.start.addSecs(3600);
    initial.collectionDir = defaultCollection();
    m_editPath.clear();
    m_editBase.clear();
    m_editWholeSeries = true;
    m_editRecurrenceId = {};
    m_pane->startEdit(initial, writableCollections(), true, true, tr("None"), QString());
}

bool CalendarWindow::save()
{
    const EventEdit edit = m_pane->edit();
    const CalCollection *target = collection(edit.collectionDir);
    if (!target)
        return false;
    QList<Change> changes;
    QString label;

    if (m_editPath.isEmpty()) {
        const QByteArray text = CalendarStore::newEvent(edit, QTimeZone::systemTimeZoneId());
        bool ignored = false;
        const QString uid = CalendarStore::parseEvent(text, {}, {}, &ignored).uid;
        changes.append({ target->path + QLatin1Char('/') + uid + QStringLiteral(".ics"),
                         std::nullopt, text });
        label = tr("New event");
    } else {
        const QByteArray text = CalendarStore::applyEdit(
            m_editBase, edit,
            m_editWholeSeries ? CalendarStore::Scope::All : CalendarStore::Scope::ThisOccurrence,
            m_editRecurrenceId);
        if (text.isEmpty())
            return false;
        const QString newPath = target->path + QLatin1Char('/') + QFileInfo(m_editPath).fileName();
        if (newPath == m_editPath) {
            changes.append({ m_editPath, m_editBase, text });
        } else {
            // Moving to another calendar: the new file first, then the old
            // one removed, so a failure between them duplicates rather than
            // loses the event.
            changes.append({ newPath, std::nullopt, text });
            changes.append({ m_editPath, m_editBase, std::nullopt });
        }
        label = tr("Edit event");
    }

    if (!writeAndRecord(label, changes))
        return false;  // the form stays open with the user's values
    m_pane->stopEdit();
    bool ignored = false;
    m_selectedUid = CalendarStore::parseEvent(*changes.first().after, {}, {}, &ignored).uid;
    m_selectedStart = {};
    reload();
    return true;
}

void CalendarWindow::cancelEdit()
{
    if (!m_pane->isEditing())
        return;
    m_pane->stopEdit();
    rebuildItems();
}

void CalendarWindow::deleteSelected()
{
    if (m_pane->isEditing() || m_selected < 0)
        return;
    const Occurrence &o = m_items[m_selected].occurrence;
    const CalEvent &e = m_data.events[o.eventIndex];
    const CalCollection *c = collection(e.collectionDir);
    if (!c || !CalendarStore::isEditable(e, *c, m_ownAddresses))
        return;

    // No confirmation: the delete is undoable (spec decision 14). A repeating
    // event asks its SCOPE, which is a choice, not a confirmation.
    std::optional<QByteArray> after = std::nullopt;
    if (e.repeat.freq != RepeatRule::Freq::None || e.repeat.custom) {
        QMessageBox box(QMessageBox::Question, tr("Delete a repeating event"),
                        tr("Delete only this occurrence, or every occurrence?"),
                        QMessageBox::Cancel, this);
        QPushButton *one = box.addButton(tr("This occurrence"), QMessageBox::AcceptRole);
        QPushButton *all = box.addButton(tr("All occurrences"), QMessageBox::AcceptRole);
        box.exec();
        if (box.clickedButton() == one)
            after = CalendarStore::deleteOccurrence(e.rawText, o.recurrenceId);
        else if (box.clickedButton() != all)
            return;
    }
    if (writeAndRecord(tr("Delete event"), { { e.filePath, e.rawText, after } })) {
        m_selectedUid.clear();
        reload();
    }
}

bool CalendarWindow::applyChanges(const QList<Change> &changes, bool reverse)
{
    QList<Change> done;
    for (int i = 0; i < changes.size(); ++i) {
        const Change &c = changes[reverse ? changes.size() - 1 - i : i];
        const auto from = reverse ? c.after : c.before;
        const auto to = reverse ? c.before : c.after;
        QString error;
        const CalendarWriter::Result r = CalendarWriter::replace(c.path, from, to, &error);
        if (r != CalendarWriter::Result::Ok) {
            // Roll back what this call already did, newest first.
            // ponytail: best effort; a rollback that itself fails is reported
            // by the file being wrong on the next reload, not handled here.
            for (int j = done.size() - 1; j >= 0; --j) {
                QString ignored;
                CalendarWriter::replace(done[j].path, done[j].after, done[j].before, &ignored);
            }
            status(r == CalendarWriter::Result::Stale
                       ? tr("The event changed on disk, probably from a sync. Check it and try again.")
                       : tr("Could not write the calendar: %1").arg(error));
            reload();
            return false;
        }
        done.append({ c.path, from, to });
        m_written.insert(c.path, to);
    }
    m_sync->schedule();
    m_reloadTimer.start();
    return true;
}

bool CalendarWindow::writeAndRecord(const QString &label, const QList<Change> &changes)
{
    if (!applyChanges(changes, false))
        return false;
    m_undo.push(new FileCommand(label, changes, this));
    return true;
}

void CalendarWindow::checkAfterSync()
{
    // Compared by MEANING: the server may normalise the text on the round
    // trip, and a byte comparison would warn on every save.
    QStringList lost;
    for (auto it = m_checking.cbegin(); it != m_checking.cend(); ++it) {
        const bool exists = QFile::exists(it.key());
        const bool kept = it.value()
            ? exists && CalendarStore::sameMeaning(readFile(it.key()), *it.value())
            : !exists;
        if (!kept) {
            bool ignored = false;
            const QString title = it.value()
                ? CalendarStore::parseEvent(*it.value(), {}, {}, &ignored).summary
                : QFileInfo(it.key()).completeBaseName();
            lost << title;
        }
    }
    m_checking.clear();
    status(lost.isEmpty()
               ? tr("Calendars synced.")
               : tr("The server kept a different version of: %1").arg(lost.join(QStringLiteral(", "))));
}

void CalendarWindow::status(const QString &text)
{
    statusBar()->showMessage(text, 10000);
}

void CalendarWindow::closeEvent(QCloseEvent *event)
{
    // A QMainWindow, not a QDialog, so every route out (the title bar, the
    // File menu, close()) arrives here; AGENTS.md's QDialog trap does not
    // apply, but the test still drives two routes.
    if (m_pane->isDirty()) {
        const auto answer = QMessageBox::question(
            this, tr("Unsaved event"), tr("Save the changes to this event?"),
            QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Save);
        if (answer == QMessageBox::Cancel || (answer == QMessageBox::Save && !save())) {
            event->ignore();
            return;
        }
        m_pane->stopEdit();
    }
    QDir().mkpath(QFileInfo(m_uiStatePath).absolutePath());
    QSettings state(m_uiStatePath, QSettings::IniFormat);
    state.beginGroup(QStringLiteral("calendar"));
    state.setValue(QStringLiteral("geometry"), saveGeometry());
    state.setValue(QStringLiteral("agenda"), m_views->currentIndex() == 1);
    state.setValue(QStringLiteral("collection"), m_collectionBox->currentData().toString());
    state.endGroup();
    QMainWindow::closeEvent(event);
}
```

Two things to confirm while implementing rather than trust: `QHash::insert(const QHash &)` exists in Qt 6 (it does from 6.0; otherwise loop), and `QTimeZone::systemTimeZoneId()` returns an IANA id on this system (`Europe/Rome`), which `newEvent` needs for its VTIMEZONE.

- [ ] **Step 5: Run the tests**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarwindow`
Expected: all PASS. A hang means a message box appeared that no test answered: the scope question for a repeating event, most likely, which none of these fixtures should trigger.

- [ ] **Step 6: Mutation-check the two data-safety tests**

Per AGENTS.md, a test that cannot fail proves nothing. Temporarily:
1. In `CalendarWriter::replace`, change `if (current.readAll() != *expected)` to `if (false)`. Run `test_calendarwindow`: `aStaleSaveKeepsTheFormAndTheSyncedFile` must FAIL. Revert.
2. In `FileCommand::undo`, make it return without calling `applyChanges`. `saveWritesAndUndoRestoresTheOriginalBytes` must FAIL. Revert.

- [ ] **Step 7: Commit**

```bash
git add src/calendarwindow.h src/calendarwindow.cpp src/CMakeLists.txt \
        tests/CMakeLists.txt tests/test_calendarwindow.cpp
git commit -m "feat: the calendar window, with undo and a stale-safe save"
```

---

### Task 15: Opening the calendar from the main window

**Files:**
- Modify: `src/keymap.cpp` (`knownActions`)
- Modify: `src/mainwindow.h`, `src/mainwindow.cpp` (action, icon, View menu, toolbar, open, close)
- Test: `tests/test_mainwindow.cpp`

- [ ] **Step 1: Write the failing test**

```cpp
    void theCalendarActionWithNoCalendarOpensNothing();
```

```cpp
void TestMainWindow::theCalendarActionWithNoCalendarOpensNothing()
{
    // The default test config sets no calendars_dir: the feature is off.
    MainWindow window(Config{});
    QAction *action = window.findChild<QAction *>(QStringLiteral("calendar"));
    QVERIFY(action);
    action->trigger();
    const QWidgetList tops = QApplication::topLevelWidgets();
    QVERIFY(std::none_of(tops.cbegin(), tops.cend(), [](QWidget *w) {
        return qobject_cast<CalendarWindow *>(w) != nullptr;
    }));
}
```

Check how the other `test_mainwindow` cases build a window (they may use a fixture config rather than `Config{}`) and follow them. Check also how `MainWindow::addAction` names its QActions; if it does not set `objectName`, find the action through the map the tests already use. Add `#include "calendarwindow.h"`.

- [ ] **Step 2: Run to verify it fails**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_mainwindow theCalendarActionWithNoCalendarOpensNothing`
Expected: FAIL, no `calendar` action.

- [ ] **Step 3: Register the action in all five places**

1. `src/keymap.cpp`, `knownActions()`, after `QStringLiteral("tag_rules"),`:

```cpp
        // Item 206. No default chord: the calendar is opened from the View
        // menu and the toolbar, and a shortcut is a chosen subset (item 132).
        QStringLiteral("calendar"),
```

2. `defaultBindings()`: no entry, deliberately.

3. The icon table in `mainwindow.cpp`, beside `tag_rules`:

```cpp
    { QStringLiteral("calendar"),        { QStringLiteral("x-office-calendar"), QString() } },
```

4. `addAction` beside `tag_rules`:

```cpp
    addAction(QStringLiteral("calendar"), tr("&Calendar"),
              tr("Open the calendar"), [this]() {
        openCalendar();
    });
```

5. The View menu, after `zoom_reset`, and the main toolbar after `mark_all_read`:

```cpp
    viewMenu->addSeparator();
    viewMenu->addAction(m_actions.value(QStringLiteral("calendar")));
```

```cpp
    toolBar->addAction(m_actions.value(QStringLiteral("calendar")));
```

- [ ] **Step 4: Open it, once, and close it with the main window**

`src/mainwindow.h`: forward-declare `class CalendarWindow;`, add `void openCalendar();` to the private functions and `QPointer<CalendarWindow> m_calendar;` beside `m_composers`.

`src/mainwindow.cpp`:

```cpp
void MainWindow::openCalendar()
{
    if (m_config.calendarsDir().isEmpty()) {
        statusBar()->showMessage(
            tr("No calendar is configured: set calendars_dir under [general]."), 10000);
        return;
    }
    if (m_calendar) {
        m_calendar->raise();
        m_calendar->activateWindow();
        return;
    }
    QStringList own;
    for (const Account &account : m_config.accounts())
        if (!account.address.isEmpty())
            own << account.address;
    // Parentless, like a composer: its own entry in the task switcher.
    m_calendar = new CalendarWindow(m_config, own, uiStatePath());
    m_calendar->setAttribute(Qt::WA_DeleteOnClose);
    m_calendar->show();
}
```

If the status bar is reached through a member (`m_statusLabel`, AGENTS.md) rather than `statusBar()`, use the same route the neighbouring code uses for a transient message.

In `MainWindow::closeEvent`, directly after the `m_syncingForExit` guard and BEFORE the first prompt, so a Cancel in the calendar's own prompt stops the quit before anything else is asked:

```cpp
    // The calendar is parentless, so Qt would leave it open with nothing
    // behind it (the composer precedent above). Its own closeEvent asks about
    // an unsaved event; a Cancel there cancels the quit.
    if (m_calendar) {
        m_calendar->close();
        if (m_calendar && m_calendar->isVisible()) {
            event->ignore();
            return;
        }
    }
```

- [ ] **Step 5: Run the whole main-window suite**

Run: `cmake --build build && QT_QPA_PLATFORM=offscreen ./build/tests/test_mainwindow`
Expected: the new test PASSES, and so do `everyActionIsReachableFromAMenu`, the icon-uniqueness test and the `KeyMap` constructor assert, which are the other three of the five places. `undoMovesTheMessageBack` fails as before; nothing else may.

- [ ] **Step 6: Commit**

```bash
git add src/keymap.cpp src/mainwindow.h src/mainwindow.cpp tests/test_mainwindow.cpp
git commit -m "feat: open the calendar from the View menu and the toolbar"
```

---

### Task 16: Translation, documentation, backlog, and the live check

**Files:**
- Modify: `translations/qtmaildir_it_IT.ts`, `README.md`, `CHANGELOG.md`, `AGENTS.md`
- Modify: `docs/superpowers/specs/2026-09-24-calendar-design.md` (the rulings)
- Modify: `docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md`
- Test: `tests/test_calendarstore.cpp` (the opt-in live check)

- [ ] **Step 1: The read-only live check**

Add to `test_calendarstore.cpp`:

```cpp
    void theLiveVdirLoadsCleanly();
```

```cpp
void TestCalendarStore::theLiveVdirLoadsCleanly()
{
    // Opt-in, READ-ONLY: never writes. Run by hand before handing the build
    // over: QTMAILDIR_LIVE_CALENDARS=~/.local/share/calendars ./test_calendarstore
    const QString dir = qEnvironmentVariable("QTMAILDIR_LIVE_CALENDARS");
    if (dir.isEmpty())
        QSKIP("QTMAILDIR_LIVE_CALENDARS not set");
    const LoadResult r = CalendarStore::load(dir);
    qInfo("collections=%lld events=%lld unparsable=%d unknownZones=%d",
          qlonglong(r.collections.size()), qlonglong(r.events.size()),
          r.unparsable, r.unknownZones);
    QCOMPARE(r.unparsable, 0);
    const QList<Occurrence> year = CalendarStore::occurrences(
        r.events, QDateTime(QDate(2026, 1, 1), QTime(0, 0)),
        QDateTime(QDate(2027, 1, 1), QTime(0, 0)));
    qInfo("occurrences in 2026=%lld", qlonglong(year.size()));
}
```

Run: `QTMAILDIR_LIVE_CALENDARS=$HOME/.local/share/calendars QT_QPA_PLATFORM=offscreen ./build/tests/test_calendarstore theLiveVdirLoadsCleanly`
Expected: PASS with `collections=3 events=312 unparsable=0`. Report the `unknownZones` and occurrence counts to the user; they are real measurements and belong in the hand-off (AGENTS.md: counts are not personal data).

- [ ] **Step 2: Translate**

Run: `lupdate-qt6 src/ -ts translations/qtmaildir_it_IT.ts -no-obsolete -locations none`
Expected: zero "tr() cannot be called without context" warnings. Translate every new entry in Italian, including BOTH plural forms of `+%n more`, `%n file(s) could not be read` and `%n event(s) in an unknown time zone...`, and the `RepeatRule` context's ordinals.
Run: `lrelease-qt6 translations/qtmaildir_it_IT.ts`
Expected: `0 unfinished`.
Run: `ctest --test-dir build -R translations --output-on-failure`
Expected: PASS.

- [ ] **Step 3: README**

Add a `## Calendar` section after the contact-completion section: what the window does (Month, Agenda, edit in the side pane, undo), that it reads a vdirsyncer vdir and needs no khal, that names and colours come from each collection's `displayname` and `color` files, which `vdirsyncer metasync` fills when the pair has `metadata = ["color", "displayname"]`, and that events organised by someone else are read-only. Document the four keys in the config reference table:

| Key | Default | Meaning |
|---|---|---|
| `calendars_dir` | unset (off) | The vdir root, e.g. `~/.local/share/calendars/`. |
| `default_calendar` | first collection | Directory name new events go to. |
| `calendar_sync_command` | `flock -w 60 /tmp/vdirsyncer.lock vdirsyncer sync calendars` | Run after writes; empty disables. |
| `calendar_sync_delay_ms` | `2000` | Delay before it runs. |

And the cron note: prefix the vdirsyncer cron line with the same `flock -w 60 /tmp/vdirsyncer.lock` so the two never run together; append `&& vdirsyncer metasync` to keep names and colours current.

- [ ] **Step 4: CHANGELOG**

Under `## [Unreleased]`, `### Added`: a calendar window (item 206) with the one-line summary; and `### Upgrading`: the calendar is off until `calendars_dir` is set, and the cron line wants the `flock` prefix.

- [ ] **Step 5: AGENTS.md**

Add `CalendarWindow` and `EventPane` to the list of widget classes; `CalendarStore`, `CalendarWriter` and `MonthLayout` to the namespaces paragraph; the diagram line `CalendarWindow (its own top-level window) ... CalendarStore (the only libical user)`. Then a section of the calendar's traps, each learned in this plan:

- libical is confined to `calendarstore.cpp` behind `icalraii.h`, the nmraii rule.
- Expansion runs in the event's own zone: a weekly 10:00 Rome event is 10:00 on both sides of DST, so its UTC time moves.
- All-day `DTEND` is exclusive; the form shows the inclusive last day and converts.
- 120 of the user's files name a `TZID` without a `VTIMEZONE`; an edit must write the `TZID` parameter back, never convert.
- The calendar's `Delete`, `Ctrl+Z`, `PgUp`/`PgDn` and `Home` shortcuts are scoped to the views with `Qt::WidgetWithChildrenShortcut`, or they fire while the user types in the form.
- `calendar_sync_command` is read through a QStringList join, because QSettings splits a comma-holding value and `toString()` on the list is empty.

- [ ] **Step 6: Amend the spec**

In `docs/superpowers/specs/2026-09-24-calendar-design.md`: `Status: approved, implemented on branch calendar`; the config table's `calendars_dir` default becomes "unset (off)" (ruling 1); "byte for byte" becomes "value for value" in the Testing section (ruling 2); the atomic write names `QSaveFile`; the shortcut scoping is added under "Menus and keys".

- [ ] **Step 7: Backlog**

In the status table of `docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md`:
- 206's row: `open, **built on branch calendar** YYYY-MM-DD, awaiting hand test; spec specs/2026-09-24-calendar-design.md, plan plans/2026-09-24-calendar.md`.
- 205's row: append "its write-during-sync question is answered by 206's spec, § Writing: the same writer and stale check serve a vCard".
- New row 209: `The calendar has no Week view | presentation | M | open, from 206's brainstorm. The occurrence list is the seam: a new painter over CalendarItem, no store change.`
- New row 210: `A repeating event cannot be edited "this and following" | workflow | S-M | open, from 206's brainstorm. Splits a series into two files, divides EXDATEs and overrides, shifts moved RECURRENCE-IDs, converts COUNT; see the spec's Out of scope.`
- Add sections `## 209.` and `## 210.` with Observed / Cause / Approach / Constraints, citing the spec.

- [ ] **Step 8: Full suite**

Run: `ctest --test-dir build --output-on-failure`
Expected: everything passes except the known pre-existing `test_mainwindow::undoMovesTheMessageBack` (and possibly the two order-dependent flakes; rerun those alone before calling anything a regression).

- [ ] **Step 9: Commit**

```bash
git add translations/qtmaildir_it_IT.ts README.md CHANGELOG.md AGENTS.md \
        docs/superpowers/specs/2026-09-24-calendar-design.md \
        docs/superpowers/plans/2026-08-03-post-0.1.0-usability.md tests/test_calendarstore.cpp
git commit -m "docs: document the calendar, translate it, file its follow-ups"
```

- [ ] **Step 10: Hand over for the hand test**

Do NOT launch the application (AGENTS.md). Tell the user the branch is ready, give the live-check counts, and say what to look at:
1. View > Calendar opens one window; a second trigger raises it.
2. The collection combo shows your three calendars with their server colours; "All calendars" first.
3. Today's pill; ‹ Today › and the month/year controls; PgUp/PgDn with the grid focused.
4. A birthday (yearly) and the monthly day-18 series fall where they should; a DST-crossing weekly event keeps its hour in late October.
5. Clicking an invitation someone else organised shows "Organised by ...: read-only" and no Edit/Delete.
6. Edit an event you organised: the form replaces the pane; the grid still navigates; clicking another event is refused with a hint; typing Delete or Ctrl+Z in the Title field edits the text, not the calendar.
7. Save; Ctrl+Z (grid focused) restores it; the status bar reports the sync and, after it, "Calendars synced."
8. + New and double-click on an empty day open a form in the default calendar.
9. Close with an unsaved edit: Save / Discard / Cancel.

Merge `calendar` to master only after the user's verdict (memory: test before commit applies to the merge).