diff --git a/README.md b/README.md
index b6acde8b..eabdebc9 100644
--- a/README.md
+++ b/README.md
@@ -80,7 +80,7 @@ not an exhaustive list; the in-app **What's New** is the complete, current recor
   can toggle off. PM only reads your calendars unless you turn on editing for a Google account;
   then you can create events on its calendars (+ New event, or press c; Shift+C opens a quick box,
   and in the day, week, month and agenda views the new event shows as you type, except in the
-  Terminal look), and change and
+  Terminal look), repeating ones too (Google's choices, or your own with Custom…), and change and
   delete events you organise without guests, repeating ones included. Every change goes straight to
   Google, a save never overwrites a field someone changed there in the meantime, and a new
   event whose save loses the connection is looked for in Google before it's ever sent again.
diff --git a/package-lock.json b/package-lock.json
index 155f25b2..1df6f4b6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "pm",
-  "version": "3.152.1-alpha",
+  "version": "3.153.0-alpha",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pm",
-      "version": "3.152.1-alpha",
+      "version": "3.153.0-alpha",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "@fontsource/atkinson-hyperlegible": "^5.3.0",
diff --git a/package.json b/package.json
index 53e8e37b..def2699d 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "pm",
   "private": true,
-  "version": "3.152.1-alpha",
+  "version": "3.153.0-alpha",
   "license": "AGPL-3.0-or-later",
   "type": "module",
   "engines": {
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index bd5de3f8..0c6174bf 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -3072,7 +3072,7 @@ dependencies = [
 
 [[package]]
 name = "pm"
-version = "3.152.1-alpha"
+version = "3.153.0-alpha"
 dependencies = [
  "argon2",
  "base64 0.23.1",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index b2dbebca..ead2a9ea 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pm"
-version = "3.152.1-alpha"
+version = "3.153.0-alpha"
 description = "PM — a local-first personal manager (Archivist + Personal Assistant)"
 authors = ["Bobby Yu"]
 edition = "2021"
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 57497bb5..120968ac 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "PM",
-  "version": "3.152.1-alpha",
+  "version": "3.153.0-alpha",
   "identifier": "org.itsatlas.pm",
   "build": {
     "beforeDevCommand": "npm run dev",
diff --git a/src/components/CalendarConnection.tsx b/src/components/CalendarConnection.tsx
index 1a51ebba..81f4492c 100644
--- a/src/components/CalendarConnection.tsx
+++ b/src/components/CalendarConnection.tsx
@@ -626,7 +626,7 @@ const EDITING_COPY: Record<
     enable: true,
   },
   on: {
-    text: "Editing on: PM can create events on this account’s calendars, and change and delete events you organise without guests there, repeating ones included.",
+    text: "Editing on: PM can create events, one-off or repeating, on this account’s calendars, and change and delete events you organise without guests there, repeating ones included.",
     action: "Turn off editing",
     enable: false,
     paused: true,
diff --git a/src/components/calendar/CalendarView.test.tsx b/src/components/calendar/CalendarView.test.tsx
index 16c85dbf..3dbfdce6 100644
--- a/src/components/calendar/CalendarView.test.tsx
+++ b/src/components/calendar/CalendarView.test.tsx
@@ -44,6 +44,8 @@ const ipc = vi.hoisted(() => ({
   updateCalendarEvent: vi.fn(),
   eventFlags: vi.fn(),
   openUrl: vi.fn(),
+  recurrencePresets: vi.fn(),
+  describeRecurrence: vi.fn(),
 }));
 // What the views and the header are shown: the System, the hidden calendars, and what the Year view
 // was handed (it lays nothing out without a measured pane, so it's a stand-in that keeps its events).
@@ -208,6 +210,8 @@ beforeEach(() => {
   ipc.listHeldDeletes.mockResolvedValue([]);
   ipc.onCalendarDeleteSettled.mockResolvedValue(() => {});
   ipc.eventFlags.mockResolvedValue([]);
+  // The Repeat row in quick create and the full editor: no ready-made rules, so just its own rows.
+  ipc.recurrencePresets.mockResolvedValue([]);
 });
 
 afterEach(() => {
diff --git a/src/components/calendar/edit/CalendarPicker.test.tsx b/src/components/calendar/edit/CalendarPicker.test.tsx
index a0763f97..5cd8c579 100644
--- a/src/components/calendar/edit/CalendarPicker.test.tsx
+++ b/src/components/calendar/edit/CalendarPicker.test.tsx
@@ -253,6 +253,17 @@ describe("CalendarPicker", () => {
     );
   });
 
+  // A click on a Mac leaves focus where it was (jsdom's click does the same).
+  it("Escape closes the list with focus on the button, even after a click that didn't focus it", async () => {
+    const { trigger, list } = open();
+    await waitFor(() =>
+      expect(document.activeElement).toBe(within(list).getByRole("radio", { name: "Personal" })),
+    );
+    fireEvent.keyDown(document.activeElement!, { key: "Escape" });
+    expect(screen.queryByRole("group", { name: "Calendars that can take a new event" })).toBeNull();
+    expect(document.activeElement).toBe(trigger);
+  });
+
   it("closes when it's disabled, and doesn't come back by itself", () => {
     const props = {
       targets: createTargets(overview),
diff --git a/src/components/calendar/edit/CalendarPicker.tsx b/src/components/calendar/edit/CalendarPicker.tsx
index 37126063..dedfcf1f 100644
--- a/src/components/calendar/edit/CalendarPicker.tsx
+++ b/src/components/calendar/edit/CalendarPicker.tsx
@@ -111,7 +111,12 @@ export function CalendarPicker({
           aria-label={`Calendar: ${label}`}
           aria-expanded={expanded}
           disabled={disabled}
-          onClick={toggle}
+          onClick={() => {
+            // A click on a Mac leaves focus where it was. The button takes it, so the list's Escape
+            // hands it back here.
+            triggerRef.current?.focus();
+            toggle();
+          }}
         >
           {picked && (
             <SourceDot
diff --git a/src/components/calendar/edit/CustomRecurrenceDialog.test.tsx b/src/components/calendar/edit/CustomRecurrenceDialog.test.tsx
new file mode 100644
index 00000000..842f13fb
--- /dev/null
+++ b/src/components/calendar/edit/CustomRecurrenceDialog.test.tsx
@@ -0,0 +1,249 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Custom recurrence dialog (#884, C11 §7): what it can't make is said in the backend's words and
+// Done waits (more than 730 times, an end date before the start or one it couldn't read, no weekday);
+// Done hands the rule back, Cancel nothing; inside the editor's dialog one Escape closes only it;
+// focus starts on "Repeat every"; and a rule read from Google keeps its own monthly choice.
+
+import { useState } from "react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import type { RepeatRule } from "../../../lib/types";
+
+vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth: "standard" }),
+}));
+
+import { Dialog } from "../../ui";
+import { CustomRecurrenceDialog } from "./CustomRecurrenceDialog";
+
+// jsdom ships no ResizeObserver, and the end date's picker (escapeClipping) builds one.
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+});
+
+afterEach(() => {
+  cleanup();
+  vi.resetAllMocks();
+});
+
+const T2 = "2026-10-13"; // a Tuesday
+
+function open(rule: RepeatRule | null = null) {
+  const onDone = vi.fn();
+  const onClose = vi.fn();
+  render(<CustomRecurrenceDialog rule={rule} startDate={T2} onDone={onDone} onClose={onClose} />);
+  return { onDone, onClose };
+}
+
+const done = () => screen.getByRole<HTMLButtonElement>("button", { name: "Done" });
+const interval = () => screen.getByLabelText<HTMLInputElement>("Repeat every");
+const unit = () => screen.getByLabelText<HTMLSelectElement>("Unit");
+const count = () => screen.getByLabelText<HTMLInputElement>("Occurrences");
+const endDate = () => screen.getByLabelText<HTMLInputElement>("End date");
+const day = (name: string) => screen.getByRole<HTMLButtonElement>("button", { name });
+
+/** Type `text` into a date field and leave it, as the user would. */
+function typeDate(input: HTMLInputElement, text: string) {
+  input.focus();
+  fireEvent.change(input, { target: { value: text } });
+  fireEvent.blur(input);
+}
+
+describe("CustomRecurrenceDialog", () => {
+  it("focus starts on Repeat every", () => {
+    open();
+    expect(screen.getByRole("dialog", { name: "Custom recurrence" })).toBeTruthy();
+    expect(document.activeElement).toBe(interval());
+  });
+
+  it("After 731 is rejected and Done stays disabled", () => {
+    const { onDone } = open();
+    fireEvent.click(screen.getByLabelText("After"));
+    fireEvent.change(count(), { target: { value: "731" } });
+    expect(
+      screen.getByText("Google allows at most 730 occurrences of a repeating event."),
+    ).toBeTruthy();
+    expect(done().disabled).toBe(true);
+    fireEvent.click(done());
+    expect(onDone).not.toHaveBeenCalled();
+  });
+
+  it("After 730 is accepted", () => {
+    const { onDone } = open();
+    // The count is off until its row is chosen.
+    expect(count().disabled).toBe(true);
+    fireEvent.click(screen.getByLabelText("After"));
+    expect(count().disabled).toBe(false);
+    fireEvent.change(count(), { target: { value: "730" } });
+    fireEvent.click(done());
+    expect(onDone).toHaveBeenCalledWith({
+      pattern: { kind: "weekly", days: ["tue"] },
+      interval: 1,
+      ends: { kind: "after", count: 730 },
+    });
+    // "occurrence" for one.
+    fireEvent.change(count(), { target: { value: "1" } });
+    expect(screen.getByText("occurrence")).toBeTruthy();
+  });
+
+  // The end date has no lower limit: a date before the start is said, not silently moved to it
+  // (C11 critiques C1-M5, C2-M3).
+  it("an Ends date before the start is rejected", () => {
+    const { onDone } = open();
+    expect(endDate().disabled).toBe(true);
+    fireEvent.click(screen.getByLabelText("On"));
+    typeDate(endDate(), "01-10-2026");
+    expect(endDate().value).toBe("01-10-2026");
+    expect(screen.getByText("The end date is before the first occurrence.")).toBeTruthy();
+    expect(done().disabled).toBe(true);
+    // On the start day itself, it's fine.
+    typeDate(endDate(), "13-10-2026");
+    fireEvent.click(done());
+    expect(onDone).toHaveBeenCalledWith({
+      pattern: { kind: "weekly", days: ["tue"] },
+      interval: 1,
+      ends: { kind: "on_date", date: T2 },
+    });
+  });
+
+  // The field shows its date again after text it can't read: Done must not end the rule on it.
+  it("an end date it can't read waits until it's given one", () => {
+    const { onDone } = open();
+    fireEvent.click(screen.getByLabelText("On"));
+    typeDate(endDate(), "31-02-2027");
+    expect(
+      screen.getByText(
+        "End date: “31-02-2027” isn't a date PM can read. Type the end date again as dd-mm-yyyy, or pick it from the calendar.",
+      ),
+    ).toBeTruthy();
+    expect(endDate().getAttribute("aria-invalid")).toBe("true");
+    expect(done().disabled).toBe(true);
+    // Ending another way doesn't need the date.
+    fireEvent.click(screen.getByLabelText("Never"));
+    expect(done().disabled).toBe(false);
+    fireEvent.click(screen.getByLabelText("On"));
+    expect(done().disabled).toBe(true);
+    typeDate(endDate(), "20-12-2026");
+    fireEvent.click(done());
+    expect(onDone).toHaveBeenCalledWith(
+      expect.objectContaining({ ends: { kind: "on_date", date: "2026-12-20" } }),
+    );
+  });
+
+  it("weekday toggles are aria-pressed and turning the last one off says to pick one", () => {
+    open();
+    expect(screen.getByRole("group", { name: "Repeat on" })).toBeTruthy();
+    // Monday first; the start's own day is on.
+    const names = Array.from(
+      screen.getByRole("group", { name: "Repeat on" }).querySelectorAll("button"),
+    ).map((b) => [b.textContent, b.getAttribute("aria-label"), b.getAttribute("aria-pressed")]);
+    expect(names).toEqual([
+      ["M", "Monday", "false"],
+      ["T", "Tuesday", "true"],
+      ["W", "Wednesday", "false"],
+      ["T", "Thursday", "false"],
+      ["F", "Friday", "false"],
+      ["S", "Saturday", "false"],
+      ["S", "Sunday", "false"],
+    ]);
+    fireEvent.click(day("Tuesday"));
+    expect(day("Tuesday").getAttribute("aria-pressed")).toBe("false");
+    expect(screen.getByText("Pick at least one day of the week.")).toBeTruthy();
+    expect(done().disabled).toBe(true);
+    fireEvent.click(day("Friday"));
+    fireEvent.click(day("Monday"));
+    expect(done().disabled).toBe(false);
+  });
+
+  it("the unit's plural follows the interval", () => {
+    open();
+    const units = () => Array.from(unit().options).map((o) => o.text);
+    expect(units()).toEqual(["day", "week", "month", "year"]);
+    fireEvent.change(interval(), { target: { value: "2" } });
+    expect(units()).toEqual(["days", "weeks", "months", "years"]);
+    fireEvent.change(interval(), { target: { value: "100" } });
+    expect(screen.getByText("Repeat every 1 to 99.")).toBeTruthy();
+    expect(done().disabled).toBe(true);
+  });
+
+  it("Done hands back the rule; Cancel hands back nothing", () => {
+    const first = open();
+    fireEvent.change(interval(), { target: { value: "2" } });
+    fireEvent.click(day("Monday"));
+    fireEvent.click(done());
+    expect(first.onDone).toHaveBeenCalledWith({
+      pattern: { kind: "weekly", days: ["mon", "tue"] },
+      interval: 2,
+      ends: { kind: "never" },
+    });
+    expect(first.onClose).not.toHaveBeenCalled();
+    cleanup();
+    const second = open();
+    fireEvent.change(unit(), { target: { value: "year" } });
+    expect(screen.getByText("Annually on 13 October")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(second.onClose).toHaveBeenCalledTimes(1);
+    expect(second.onDone).not.toHaveBeenCalled();
+  });
+
+  it("Escape closes only the custom dialog", () => {
+    const outerClose = vi.fn();
+    function Harness() {
+      const [custom, setCustom] = useState(true);
+      return (
+        <Dialog open onClose={outerClose} title="New event">
+          <p>The editor</p>
+          {custom && (
+            <CustomRecurrenceDialog
+              rule={null}
+              startDate={T2}
+              onDone={() => setCustom(false)}
+              onClose={() => setCustom(false)}
+            />
+          )}
+        </Dialog>
+      );
+    }
+    render(<Harness />);
+    expect(screen.getByRole("dialog", { name: "Custom recurrence" })).toBeTruthy();
+    fireEvent.keyDown(window, { key: "Escape" });
+    expect(screen.queryByRole("dialog", { name: "Custom recurrence" })).toBeNull();
+    expect(outerClose).not.toHaveBeenCalled();
+    expect(screen.getByRole("dialog", { name: "New event" })).toBeTruthy();
+  });
+
+  it("opening on a monthly last-Friday rule keeps that choice", () => {
+    const { onDone } = open({
+      pattern: { kind: "monthly_weekday", nth: "last", weekday: "fri" },
+      interval: 1,
+      ends: { kind: "never" },
+    });
+    const monthly = screen.getByLabelText<HTMLSelectElement>("Monthly on");
+    expect(Array.from(monthly.options).map((o) => o.text)).toEqual([
+      "Monthly on day 13",
+      "Monthly on the second Tuesday",
+      "Monthly on the last Friday",
+    ]);
+    expect(monthly.selectedOptions[0].text).toBe("Monthly on the last Friday");
+    // Picking another and back keeps it on offer.
+    fireEvent.change(monthly, { target: { value: "0" } });
+    fireEvent.change(monthly, { target: { value: "2" } });
+    fireEvent.click(done());
+    expect(onDone).toHaveBeenCalledWith({
+      pattern: { kind: "monthly_weekday", nth: "last", weekday: "fri" },
+      interval: 1,
+      ends: { kind: "never" },
+    });
+  });
+});
diff --git a/src/components/calendar/edit/CustomRecurrenceDialog.tsx b/src/components/calendar/edit/CustomRecurrenceDialog.tsx
new file mode 100644
index 00000000..3c2ad329
--- /dev/null
+++ b/src/components/calendar/edit/CustomRecurrenceDialog.tsx
@@ -0,0 +1,262 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// Google Calendar's "Custom recurrence" dialog, in PM's words (#884, C11): repeat every N days, weeks,
+// months or years; on the weekdays chosen, or the month's day or numbered weekday; ending never, on a
+// date, or after a number of times. Done hands the rule back and changes nothing else; Cancel, ✕
+// and Escape hand back nothing.
+//
+// It is rendered inside the editor's own dialog, so it alone is topmost: one Escape closes only it,
+// and Tab stays in it. Where it differs from Google's: the weekdays start on Monday, as PM's weeks
+// do; and the end date has no lower limit, so a date before the start is said rather than silently
+// moved to it (C11 critiques C1-M5, C2-M3). What the fields can't make is said in one line, with
+// the backend's own words, and Done waits until it's fixed.
+
+import { useId, useState } from "react";
+import type { DayCode, RepeatRule } from "../../../lib/types";
+import {
+  formFromRule,
+  monthlyChoices,
+  monthlyLabel,
+  repeatProblemText,
+  ruleFromForm,
+  WEEKDAYS,
+  yearlyLabel,
+  type RepeatForm,
+  type RepeatUnit,
+} from "../../../lib/calendarEdit/recurrenceDraft";
+import { badDateText } from "../../../lib/calendarEdit/editReasons";
+import { Button, Dialog, Select, cn } from "../../ui";
+import { DateField } from "../../DateField";
+
+interface Props {
+  /** The rule to start from (the Repeat row's), or null for Google's defaults. */
+  rule: RepeatRule | null;
+  /** The event's start date (YYYY-MM-DD): the defaults, the monthly choices and the yearly date
+   *  come from it. */
+  startDate: string;
+  onDone: (rule: RepeatRule) => void;
+  onClose: () => void;
+}
+
+const UNITS: { value: RepeatUnit; one: string; many: string }[] = [
+  { value: "day", one: "day", many: "days" },
+  { value: "week", one: "week", many: "weeks" },
+  { value: "month", one: "month", many: "months" },
+  { value: "year", one: "year", many: "years" },
+];
+
+/** A small number field, in the editor's field tokens. */
+const NUMBER =
+  "w-16 rounded-[var(--radius-sm)] border border-border2 bg-surface px-2 py-1 text-sm text-ink2 outline-none transition focus:border-accent disabled:cursor-not-allowed disabled:bg-transparent disabled:text-ink3";
+
+/** Rendered only while open (the parent mounts it), so its fields start afresh each time. */
+export function CustomRecurrenceDialog({ rule, startDate, onDone, onClose }: Props) {
+  const [first] = useState(() => formFromRule(rule, startDate));
+  const [form, setForm] = useState<RepeatForm>(first);
+  // Text the end date field couldn't read: it shows its date again, so Done waits until it's given
+  // one, typed or picked, rather than ending on a date the user was changing.
+  const [badEnd, setBadEnd] = useState<string | null>(null);
+  const id = useId();
+  const set = (patch: Partial<RepeatForm>) => setForm((f) => ({ ...f, ...patch }));
+
+  const made = ruleFromForm(form, startDate);
+  const problem =
+    form.ends === "on_date" && badEnd !== null
+      ? badDateText("End date", badEnd)
+      : made.ok
+        ? null
+        : repeatProblemText(made.problem);
+  const one = form.interval.trim() === "1";
+  // The rule's own monthly choice stays on offer when the start date's are others (a rule from
+  // another app, or Google's own "last" on a day outside the month's last week).
+  const monthly = monthlyChoices(startDate, first.monthly);
+  const monthlyIndex = monthly.findIndex((c) =>
+    c.by === "day"
+      ? form.monthly.by === "day" && form.monthly.day === c.day
+      : form.monthly.by === "weekday" &&
+        form.monthly.nth === c.nth &&
+        form.monthly.weekday === c.weekday,
+  );
+  const problemId = `${id}-problem`;
+  const ends = `${id}-ends`;
+
+  function toggle(day: DayCode) {
+    set({
+      days: form.days.includes(day) ? form.days.filter((d) => d !== day) : [...form.days, day],
+    });
+  }
+
+  function done() {
+    if (made.ok && problem === null) onDone(made.rule);
+  }
+
+  return (
+    <Dialog
+      open
+      onClose={onClose}
+      title="Custom recurrence"
+      widthClassName="max-w-md"
+      footer={
+        <>
+          <Button variant="tertiary" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button variant="primary" disabled={problem !== null} onClick={done}>
+            Done
+          </Button>
+        </>
+      }
+    >
+      <div className="mt-3 flex flex-col gap-4 text-sm text-ink2">
+        <div className="flex flex-wrap items-center gap-2">
+          <label htmlFor={`${id}-interval`}>Repeat every</label>
+          <input
+            id={`${id}-interval`}
+            type="number"
+            min={1}
+            max={99}
+            data-autofocus
+            className={NUMBER}
+            value={form.interval}
+            onChange={(e) => set({ interval: e.currentTarget.value })}
+          />
+          <Select
+            aria-label="Unit"
+            value={form.unit}
+            onChange={(e) => set({ unit: e.target.value as RepeatUnit })}
+          >
+            {UNITS.map((u) => (
+              <option key={u.value} value={u.value}>
+                {one ? u.one : u.many}
+              </option>
+            ))}
+          </Select>
+        </div>
+
+        {form.unit === "week" && (
+          <div className="flex flex-col gap-1.5">
+            <span id={`${id}-on`}>Repeat on</span>
+            <div role="group" aria-labelledby={`${id}-on`} className="flex gap-1.5">
+              {WEEKDAYS.map((d) => {
+                const on = form.days.includes(d.code);
+                return (
+                  <button
+                    key={d.code}
+                    type="button"
+                    aria-pressed={on}
+                    aria-label={d.name}
+                    title={d.name}
+                    onClick={() => toggle(d.code)}
+                    className={cn(
+                      "inline-flex h-8 w-8 items-center justify-center rounded-full text-xs transition",
+                      // Off, the edge is `--ink4`: the contrast floor a control's own edge needs.
+                      on
+                        ? "bg-accent font-medium text-accent-ink"
+                        : "text-ink2 shadow-[inset_0_0_0_1px_var(--ink4)] hover:text-ink",
+                    )}
+                  >
+                    {d.name[0]}
+                  </button>
+                );
+              })}
+            </div>
+          </div>
+        )}
+
+        {form.unit === "month" && (
+          <Select
+            aria-label="Monthly on"
+            className="self-start"
+            value={String(monthlyIndex)}
+            onChange={(e) => {
+              const choice = monthly[Number(e.target.value)];
+              if (choice) set({ monthly: choice });
+            }}
+          >
+            {monthly.map((c, i) => (
+              <option key={monthlyLabel(c)} value={String(i)}>
+                {monthlyLabel(c)}
+              </option>
+            ))}
+          </Select>
+        )}
+
+        {/* Google's dialog offers no yearly choices: the date comes from the start. */}
+        {form.unit === "year" && <p className="text-ink3">{yearlyLabel(form.yearly, startDate)}</p>}
+
+        <fieldset className="flex flex-col gap-2">
+          <legend className="mb-1">Ends</legend>
+          <div className="flex items-center gap-2">
+            <input
+              id={`${ends}-never`}
+              type="radio"
+              name={ends}
+              checked={form.ends === "never"}
+              onChange={() => set({ ends: "never" })}
+            />
+            <label htmlFor={`${ends}-never`}>Never</label>
+          </div>
+          <div className="flex flex-wrap items-center gap-2">
+            <input
+              id={`${ends}-on`}
+              type="radio"
+              name={ends}
+              checked={form.ends === "on_date"}
+              onChange={() => set({ ends: "on_date" })}
+            />
+            <label htmlFor={`${ends}-on`} className="w-10">
+              On
+            </label>
+            <DateField
+              ariaLabel="End date"
+              value={form.date}
+              clearable={false}
+              disabled={form.ends !== "on_date"}
+              refused={form.ends === "on_date" && badEnd !== null}
+              describedBy={form.ends === "on_date" && badEnd !== null ? problemId : undefined}
+              wrapperClassName="w-36"
+              onReject={setBadEnd}
+              onAccept={() => setBadEnd(null)}
+              onCommit={(date) => set({ date })}
+            />
+          </div>
+          <div className="flex flex-wrap items-center gap-2">
+            <input
+              id={`${ends}-after`}
+              type="radio"
+              name={ends}
+              checked={form.ends === "after"}
+              onChange={() => set({ ends: "after" })}
+            />
+            <label htmlFor={`${ends}-after`} className="w-10">
+              After
+            </label>
+            <input
+              type="number"
+              min={1}
+              max={730}
+              aria-label="Occurrences"
+              className={NUMBER}
+              disabled={form.ends !== "after"}
+              value={form.count}
+              onChange={(e) => set({ count: e.currentTarget.value })}
+            />
+            <span className="text-ink3">
+              {form.count.trim() === "1" ? "occurrence" : "occurrences"}
+            </span>
+          </div>
+        </fieldset>
+
+        {/* Always mounted, so a screen reader hears the line as it comes and goes. */}
+        <div aria-live="polite">
+          {problem !== null && (
+            <p id={problemId} className="text-xs text-st-due">
+              {problem}
+            </p>
+          )}
+        </div>
+      </div>
+    </Dialog>
+  );
+}
diff --git a/src/components/calendar/edit/EventFields.tsx b/src/components/calendar/edit/EventFields.tsx
index cee52eab..e35e4cd2 100644
--- a/src/components/calendar/edit/EventFields.tsx
+++ b/src/components/calendar/edit/EventFields.tsx
@@ -3,9 +3,11 @@
 
 // The event fields both editors share (#884): changing an event (`EventEditor`) and creating one
 // (`NewEventEditor`) show the same title, When, zone and choice controls, so they live here once.
+// The Repeat row is here too, for creating (C11): the full editor and quick create both draw it.
 //
 // Time fields never use `<input type="time">` (WebKitGTK has no widget): TimeField and DateField.
 
+import type { ReactNode } from "react";
 import type { EventVisibility, ShowAs, TimeDraft } from "../../../lib/types";
 import {
   dateFieldId,
@@ -14,10 +16,18 @@ import {
   type EndChoice,
 } from "../../../lib/calendarEdit/eventDraft";
 import { badDateText } from "../../../lib/calendarEdit/editReasons";
+import {
+  movedStartText,
+  startDateOf,
+  type RepeatValue,
+} from "../../../lib/calendarEdit/recurrenceDraft";
+import { cityOf } from "../../../lib/zoneLabel";
 import { Button, Input, SegmentedControl, Select, Textarea, Toggle, useFieldA11y } from "../../ui";
 import { DateField } from "../../DateField";
 import { TimeField } from "../../TimeField";
 import { ZoneSearchList } from "../ZoneSearchList";
+import { RecurrenceSelect } from "./RecurrenceSelect";
+import type { RepeatState } from "./useRepeat";
 
 export type Timed = Extract<TimeDraft, { kind: "timed" }>;
 
@@ -198,6 +208,7 @@ export function WhenFields({
   onSwitchKind,
   canSwitchKind,
   onPickZone,
+  repeat,
 }: {
   /** What its date fields' ids start with (`dateFieldId`), so a save can find one. */
   id: string;
@@ -222,6 +233,9 @@ export function WhenFields({
   onSwitchKind: () => void;
   canSwitchKind: boolean;
   onPickZone: (which: "both" | "start" | "end") => void;
+  /** The Repeat row (`RepeatRow`), drawn last: Google puts "Does not repeat" under the date and
+   *  time, and inside this fieldset it is off whenever the times are. */
+  repeat?: ReactNode;
 }) {
   const t = draft.time;
   const names = DATE_FIELD[t.kind];
@@ -239,7 +253,8 @@ export function WhenFields({
     onAccept: () => onAcceptDate(half),
   });
   return (
-    <fieldset className="flex flex-col gap-2" disabled={disabled}>
+    // Never wider than the editor: a fieldset is as wide as its widest content unless told otherwise.
+    <fieldset className="flex min-w-0 flex-col gap-2" disabled={disabled}>
       <legend className="text-sm text-ink2">When</legend>
       <label className="flex items-center gap-2 text-xs text-ink3">
         <Toggle
@@ -346,6 +361,66 @@ export function WhenFields({
           )
         );
       })}
+      {repeat}
     </fieldset>
   );
 }
+
+/** The Repeat row (#884, C11): the repeat menu, and under it where the event really starts when its
+ *  rule moves it (A27), why the rule can't be saved, and the zone it repeats in when that isn't this
+ *  computer's (a weekly 09:00 in New York moves in London's weeks around the clocks changing). What
+ *  the backend says of the rule (`view`) is the editor's to ask, since it also stops the editor's
+ *  saves. */
+export function RepeatRow({
+  value,
+  view,
+  time,
+  deviceZone,
+  skippedTime,
+  disabled,
+  compact,
+  onChange,
+  onCustom,
+}: {
+  value: RepeatValue;
+  view: RepeatState;
+  time: TimeDraft;
+  /** This computer's zone, which the zone note compares the event's with. */
+  deviceZone: string | null;
+  /** The editor already refuses a start or end the clocks skip. The rule's own refusal then waits
+   *  until the time is fixed: for a first occurrence on that day it says the same in other words. */
+  skippedTime: boolean;
+  disabled: boolean;
+  compact?: boolean;
+  onChange: (value: RepeatValue) => void;
+  /** "Custom…" was picked. */
+  onCustom: () => void;
+}) {
+  // A rule repeats in its start's zone; an all-day one in none.
+  const zone = time.kind === "timed" ? time.start_zone : null;
+  const note =
+    value.kind === "rule" && zone !== null && deviceZone !== null && zone !== deviceZone
+      ? `Repeats in ${cityOf(zone)} time.`
+      : null;
+  return (
+    <div className="flex flex-col items-start gap-1">
+      <RecurrenceSelect
+        value={value}
+        startDate={startDateOf(time) || null}
+        disabled={disabled}
+        compact={compact}
+        ruleWords={view.state === "ready" ? view.summary : null}
+        onChange={onChange}
+        onCustom={onCustom}
+      />
+      {/* Always mounted, so a screen reader hears where it starts, or why it can't be saved. */}
+      <div aria-live="polite" className="text-xs">
+        {view.state === "ready" && view.moved && (
+          <p className="text-ink4">{movedStartText(view.starts)}</p>
+        )}
+        {view.state === "refused" && !skippedTime && <p className="text-st-due">{view.message}</p>}
+      </div>
+      {note && <p className="text-xs text-ink4">{note}</p>}
+    </div>
+  );
+}
diff --git a/src/components/calendar/edit/NewEventEditor.test.tsx b/src/components/calendar/edit/NewEventEditor.test.tsx
index 55a5e2d3..3cd91790 100644
--- a/src/components/calendar/edit/NewEventEditor.test.tsx
+++ b/src/components/calendar/edit/NewEventEditor.test.tsx
@@ -11,6 +11,14 @@
 // draft, the words that warn before a save PM's calendar won't show, a date it can't read (here or
 // in quick create) refusing every save until its own field is given one (that field named, marked,
 // and where a save it stops puts focus), and a calendar list the keyboard can reach.
+//
+// Repeating (C11): the rule chosen is sent, and the Repeat button, its list arrowed through, names
+// exactly the rule a save sends; the list sits inside the dialog and Escape closes only it, never
+// the editor; the backend's words say where it really starts, or why it can't be saved
+// (a start the clocks skip said once), and every way to save but Check again waits for them; the
+// zone it repeats in is said when it isn't this computer's; one from before the months PM syncs is
+// said to show inside them; a rule's own day follows a moved start; and the Custom dialog, opened
+// here or handed over by quick create, closes alone on Escape and holds every save while open.
 
 import { StrictMode } from "react";
 import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
@@ -20,10 +28,14 @@ import type {
   CalendarAccount,
   CalendarOverview,
   NewEventDraft,
+  RepeatPreset,
+  RepeatRule,
+  RepeatStart,
+  RepeatView,
   WriteOutcome,
 } from "../../../lib/types";
 import { CREATE_LOST } from "../../../lib/calendarEdit/editReasons";
-import type { EditorFields } from "../../../lib/calendarEdit/eventDraft";
+import { toNewEvent, type EditorFields } from "../../../lib/calendarEdit/eventDraft";
 import { createTargets } from "../../../lib/calendarEdit/createTargets";
 
 const createEvent =
@@ -32,6 +44,8 @@ const createEvent =
   >();
 const noteCreateResult = vi.fn();
 const noteHeldCreate = vi.fn();
+const recurrencePresets = vi.fn<(day: string) => Promise<RepeatPreset[]>>();
+const describeRecurrence = vi.fn<(rule: RepeatRule, start: RepeatStart) => Promise<RepeatView>>();
 let deviceZone: string | null = "Europe/London";
 
 vi.mock("./useEventWrites", () => ({
@@ -41,6 +55,13 @@ vi.mock("./useEventWrites", () => ({
   noteHeldCreate: (...a: unknown[]) => noteHeldCreate(...a),
 }));
 
+// The repeat menu's two reads, answered as the test says.
+vi.mock("../../../lib/ipc", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  recurrencePresets: (day: string) => recurrencePresets(day),
+  describeRecurrence: (rule: RepeatRule, start: RepeatStart) => describeRecurrence(rule, start),
+}));
+
 vi.mock("../../../theme/timezones", async (importOriginal) => ({
   ...(await importOriginal<object>()),
   deviceTimeZoneOrNull: () => deviceZone,
@@ -116,6 +137,7 @@ const seed: EditorFields = {
     end_time: "10:00",
     end_zone: "Europe/London",
   },
+  recurrence: { kind: "once" },
   show_as: "busy",
   visibility: "default",
 };
@@ -156,8 +178,39 @@ beforeAll(() => {
   }
 });
 
+/** A rule from the editor's set: `pattern`, every week or month, never ending. */
+const ruleOf = (pattern: RepeatRule["pattern"]): RepeatRule => ({
+  pattern,
+  interval: 1,
+  ends: { kind: "never" },
+});
+const MONDAYS = ruleOf({ kind: "weekly", days: ["mon"] });
+const TUESDAYS = ruleOf({ kind: "weekly", days: ["tue"] });
+const MON_WED = ruleOf({ kind: "weekly", days: ["mon", "wed"] });
+
+/** The ready-made rules for a start date, as the backend gives them (the first two are enough). */
+function presetsFor(day: string): RepeatPreset[] {
+  const tuesday = day === "2026-10-13";
+  return [
+    { label: "Daily", rule: ruleOf({ kind: "daily" }) },
+    tuesday
+      ? { label: "Weekly on Tuesday", rule: TUESDAYS }
+      : { label: "Weekly on Monday", rule: MONDAYS },
+  ];
+}
+
+/** The backend's answer for a rule that starts where asked. */
+const readyAt = (start: RepeatStart, summary = "Weekly on Monday"): RepeatView => ({
+  outcome: "ready",
+  summary,
+  starts: start.date,
+  moved: false,
+});
+
 beforeEach(() => {
   deviceZone = "Europe/London";
+  recurrencePresets.mockImplementation(async (day) => presetsFor(day));
+  describeRecurrence.mockImplementation(async (_rule, start) => readyAt(start));
 });
 
 afterEach(() => {
@@ -210,6 +263,7 @@ const handed = (draft: EditorFields, over: Partial<CreateHandover> = {}): Create
   showAsTouched: false,
   timeTouched: false,
   badDate: null,
+  openCustom: false,
   ...over,
 });
 
@@ -1062,7 +1116,8 @@ describe("NewEventEditor", () => {
     // Enter or Space on a button is its click, with no pointer behind it.
     fireEvent.click(trigger, { detail: 0 });
     const list = screen.getByRole("group", LIST);
-    expect(screen.getByRole("dialog", { name: "New event" }).contains(list)).toBe(true);
+    // In the dialog itself, never inside its scrolling body, which would cut it off.
+    expect(list.parentElement).toBe(screen.getByRole("dialog", { name: "New event" }));
     await waitFor(() =>
       expect(document.activeElement).toBe(within(list).getByRole("radio", { name: "Personal" })),
     );
@@ -1085,4 +1140,456 @@ describe("NewEventEditor", () => {
     expect(screen.queryByRole("group", LIST)).toBeNull();
     expect(document.activeElement).toBe(trigger);
   });
+
+  // --- repeating (C11) ---
+
+  const repeat = () => screen.getByRole<HTMLButtonElement>("button", { name: /^Repeat: / });
+  const saveButton = () => screen.getByRole<HTMLButtonElement>("button", { name: "Save" });
+  /** The rule the Repeat button names. */
+  const shownRepeat = () =>
+    repeat()
+      .getAttribute("aria-label")
+      ?.replace(/^Repeat: /, "");
+  const REPEATS = { name: "Repeat" };
+
+  /** Open the Repeat list, once the menu has its ready-made rules. */
+  async function openRepeat() {
+    await act(async () => {});
+    fireEvent.click(repeat());
+    return screen.getByRole("group", REPEATS);
+  }
+
+  /** Click the Repeat row whose words are `label`; and let the backend's words for it land. */
+  async function pickRepeat(label: string) {
+    const list = await openRepeat();
+    fireEvent.click(within(list).getByRole("radio", { name: label }), { detail: 1 });
+    await act(async () => {});
+  }
+
+  /** Click Custom… in the Repeat list. */
+  async function chooseCustom() {
+    const list = await openRepeat();
+    fireEvent.click(within(list).getByRole("button", { name: "Custom…" }), { detail: 1 });
+  }
+
+  /** A timed event on `date`, 09:00 to 10:00 in `zone`. */
+  const timedOn = (date: string, zone = "Europe/London"): EditorFields["time"] => ({
+    kind: "timed",
+    start_date: date,
+    start_time: "09:00",
+    start_zone: zone,
+    end_date: date,
+    end_time: "10:00",
+    end_zone: zone,
+  });
+
+  const GAP =
+    "The first occurrence would be on 29-03-2027, when the clocks skip that time. Pick a time outside that hour.";
+
+  it("a repeating create sends the rule", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    // Asked at the start, with where its first occurrence ends.
+    expect(describeRecurrence).toHaveBeenLastCalledWith(MONDAYS, {
+      kind: "timed",
+      date: "2026-10-12",
+      time: "09:00",
+      zone: "Europe/London",
+      end: { date: "2026-10-12", time: "10:00", zone: "Europe/London" },
+    });
+    expect(shownRepeat()).toBe("Weekly on Monday");
+    // It starts on the day typed, so nothing says it moved.
+    expect(screen.queryByText(/the first day this repeat allows/)).toBeNull();
+    fireEvent.click(saveButton());
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([
+      [PERSONAL, { ...sentFor("Dentist").draft, recurrence: MONDAYS }, null],
+    ]);
+  });
+
+  // The arrow keys move the rule and the button follows, so a save sends what the button names.
+  it("arrowed through the Repeat list, Ctrl+S sends exactly the rule the button names", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    await act(async () => {});
+    // Enter or Space on a button is its click, with no pointer behind it.
+    repeat().focus();
+    fireEvent.click(repeat(), { detail: 0 });
+    const list = screen.getByRole("group", REPEATS);
+    await waitFor(() =>
+      expect(document.activeElement).toBe(
+        within(list).getByRole("radio", { name: "Does not repeat" }),
+      ),
+    );
+    // An arrow key: the browser moves focus and the choice, with a click no pointer made.
+    for (const name of ["Daily", "Weekly on Monday"]) {
+      fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
+      const next = within(list).getByRole("radio", { name });
+      next.focus();
+      fireEvent.click(next, { detail: 0 });
+      await act(async () => {});
+    }
+    expect(shownRepeat()).toBe("Weekly on Monday");
+    expect(screen.queryByRole("group", REPEATS)).not.toBeNull();
+    expect(screen.queryByRole("dialog", { name: "Custom recurrence" })).toBeNull();
+    await ctrlS();
+    // The save closes the list.
+    expect(screen.queryByRole("group", REPEATS)).toBeNull();
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([
+      [PERSONAL, { ...sentFor("Standup").draft, recurrence: MONDAYS }, null],
+    ]);
+  });
+
+  // The list sits inside the dialog, so its focus trap and aria-modal cover it; Escape there closes
+  // only the list, focus back on its button.
+  it("the Repeat list is inside the dialog, and Escape closes only it", async () => {
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Gym" } });
+    const list = await openRepeat();
+    // In the dialog itself, never inside its scrolling body, which would cut it off.
+    expect(list.parentElement).toBe(screen.getByRole("dialog", { name: "New event" }));
+    const picked = within(list).getByRole("radio", { name: "Does not repeat" });
+    await waitFor(() => expect(document.activeElement).toBe(picked));
+    fireEvent.keyDown(picked, { key: "Escape" });
+    expect(screen.queryByRole("group", REPEATS)).toBeNull();
+    expect(screen.getByRole("dialog", { name: "New event" })).toBeTruthy();
+    expect(screen.queryByText("Discard this new event?")).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(repeat());
+  });
+
+  it("a long rule's words never widen the editor", async () => {
+    const LONG = "Weekly on Monday, Wednesday, Thursday and Friday, until 20-12-2026";
+    describeRecurrence.mockImplementation(async (_rule, start) => readyAt(start, LONG));
+    open({
+      handover: handed({ ...seed, summary: "Gym", recurrence: { kind: "rule", rule: MON_WED } }),
+    });
+    await act(async () => {});
+    expect(shownRepeat()).toBe(LONG);
+    // The button fits its row, its words wrapping, and the When fields may be narrower than the
+    // widest thing in them.
+    expect(repeat().className.split(" ")).toContain("max-w-full");
+    expect(within(repeat()).getByText(LONG).className).not.toMatch(/truncate|whitespace-nowrap/);
+    expect(screen.getByRole("group", { name: "When" }).className.split(" ")).toContain("min-w-0");
+  });
+
+  // The backend lists and lands its occurrences inside the months PM syncs, wherever it starts.
+  it("a repeat that starts before the months PM syncs says only its occurrences there show", async () => {
+    const draft: EditorFields = {
+      ...seed,
+      summary: "Gym",
+      time: timedOn("2026-07-06"),
+      recurrence: { kind: "rule", rule: MONDAYS },
+    };
+    open({ handover: handed(draft) });
+    await act(async () => {});
+    expect(
+      screen.getByText(
+        /^This starts before the months PM syncs \(.+\), so only its occurrences within them will show here\.$/,
+      ),
+    ).toBeTruthy();
+    expect(screen.queryByText(/won't show here/)).toBeNull();
+    // Not repeating, none of it would.
+    await pickRepeat("Does not repeat");
+    expect(
+      screen.getByText(/^This starts outside the months PM syncs \(.+\), so it'll be saved/),
+    ).toBeTruthy();
+  });
+
+  // The When fields already refuse a start the clocks skip, and the backend refuses a first
+  // occurrence on it in other words: said once.
+  it("a start the clocks skip is refused once, not again under Repeat", async () => {
+    const SKIPPED =
+      "The first occurrence would be on 29-03-2026, when the clocks skip that time. Pick a time outside that hour.";
+    describeRecurrence.mockImplementation(async (_rule, start) =>
+      start.kind === "timed" && start.time === "01:30"
+        ? { outcome: "refused", message: SKIPPED }
+        : { outcome: "refused", message: "PM couldn't check this repeat. Try again." },
+    );
+    open();
+    fireEvent.change(title(), { target: { value: "Swim" } });
+    typeOver(screen.getByLabelText<HTMLInputElement>("Start date"), "29-03-2026");
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "01:30" } });
+    await pickRepeat("Daily");
+    expect(screen.getAllByText(/the clocks skip/)).toHaveLength(1);
+    expect(screen.getByText(/^01:30 doesn't happen in Europe\/London that night/)).toBeTruthy();
+    expect(saveButton().disabled).toBe(true);
+    // The time fixed, what the backend says of the rule is the Repeat row's to say.
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "09:00" } });
+    await act(async () => {});
+    expect(screen.queryByText(/the clocks skip/)).toBeNull();
+    expect(screen.getByText("PM couldn't check this repeat. Try again.")).toBeTruthy();
+  });
+
+  it("Does not repeat sends recurrence null", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    await pickRepeat("Does not repeat");
+    fireEvent.click(saveButton());
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([[PERSONAL, sentFor("Dentist").draft, null]]);
+  });
+
+  it("Weekly Mon, Wed chosen on a Tuesday says it starts Wednesday", async () => {
+    createEvent.mockResolvedValue(saved);
+    describeRecurrence.mockResolvedValue({
+      outcome: "ready",
+      summary: "Weekly on Monday and Wednesday",
+      starts: "2026-10-14",
+      moved: true,
+    });
+    const draft: EditorFields = {
+      ...seed,
+      summary: "Gym",
+      time: timedOn("2026-10-13"),
+      recurrence: { kind: "rule", rule: MON_WED },
+    };
+    const { onClose } = open({ handover: handed(draft) });
+    await act(async () => {});
+    expect(shownRepeat()).toBe("Weekly on Monday and Wednesday");
+    expect(
+      screen.getByText(/^Starts on Wed 14-10(-2026)?, the first day this repeat allows\.$/),
+    ).toBeTruthy();
+    // Said, never written into the date: the save moves it, and no repeat gives back what was typed.
+    expect(screen.getByLabelText<HTMLInputElement>("Start date").value).toBe("13-10-2026");
+    fireEvent.click(saveButton());
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls[0][1]).toMatchObject({
+      time: { start_date: "2026-10-13" },
+      recurrence: MON_WED,
+    });
+  });
+
+  it("a gap start shows the words and Save stays disabled", async () => {
+    describeRecurrence.mockResolvedValue({ outcome: "refused", message: GAP });
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    expect(screen.getByText(GAP)).toBeTruthy();
+    expect(saveButton().disabled).toBe(true);
+    // Every way to save waits on it: Enter in the title and Ctrl+S too.
+    title().focus();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await ctrlS();
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(title());
+    // Not repeating, it saves.
+    createEvent.mockResolvedValue(saved);
+    await pickRepeat("Does not repeat");
+    expect(screen.queryByText(GAP)).toBeNull();
+    expect(saveButton().disabled).toBe(false);
+  });
+
+  it("nothing saves until the backend has said what the repeat means", async () => {
+    let answer: (v: RepeatView) => void = () => {};
+    describeRecurrence.mockReturnValue(new Promise<RepeatView>((r) => (answer = r)));
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    expect(saveButton().disabled).toBe(true);
+    await ctrlS();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    await act(async () =>
+      answer({ outcome: "ready", summary: "Weekly on Monday", starts: "2026-10-12", moved: false }),
+    );
+    expect(saveButton().disabled).toBe(false);
+    await ctrlS();
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent).toHaveBeenCalledTimes(1);
+  });
+
+  // Ctrl+S commits a date typed and not yet left as it saves: the rule was never asked about at that
+  // start, so the answer for the start before it says nothing.
+  it("a start typed and saved at once waits for the repeat's words at that start", async () => {
+    createEvent.mockResolvedValue(saved);
+    let answer: (v: RepeatView) => void = () => {};
+    describeRecurrence.mockImplementation((_rule, start) =>
+      start.date === "2026-10-12"
+        ? Promise.resolve(readyAt(start))
+        : new Promise<RepeatView>((r) => (answer = r)),
+    );
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    expect(saveButton().disabled).toBe(false);
+    const date = screen.getByLabelText<HTMLInputElement>("Start date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "19-10-2026" } });
+    await ctrlS();
+    expect(createEvent).not.toHaveBeenCalled();
+    await act(async () => answer({ outcome: "refused", message: GAP }));
+    expect(screen.getByText(GAP)).toBeTruthy();
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("Repeats in New York time shows when the zones differ, not when they match", async () => {
+    const draft = (zone: string, repeats = true): EditorFields => ({
+      ...seed,
+      time: timedOn("2026-10-12", zone),
+      recurrence: repeats ? { kind: "rule", rule: MONDAYS } : { kind: "once" },
+    });
+    const first = open({ handover: handed(draft("America/New_York")) });
+    await act(async () => {});
+    expect(screen.getByText("Repeats in New York time.")).toBeTruthy();
+    first.unmount();
+    // The same zone as this computer's: nothing to say.
+    open({ handover: handed(draft("Europe/London")) });
+    await act(async () => {});
+    expect(screen.queryByText(/^Repeats in /)).toBeNull();
+    cleanup();
+    // Nor for an event that doesn't repeat.
+    open({ handover: handed(draft("America/New_York", false)) });
+    await act(async () => {});
+    expect(screen.queryByText(/^Repeats in /)).toBeNull();
+    cleanup();
+    // It's this computer's zone that counts.
+    deviceZone = "America/New_York";
+    open({ handover: handed(draft("Europe/London")) });
+    await act(async () => {});
+    expect(screen.getByText("Repeats in London time.")).toBeTruthy();
+  });
+
+  it("moving the start date moves a one-day weekly rule", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    await pickRepeat("Weekly on Monday");
+    typeOver(screen.getByLabelText<HTMLInputElement>("Start date"), "13-10-2026");
+    await act(async () => {});
+    expect(shownRepeat()).toBe("Weekly on Tuesday");
+    expect(describeRecurrence).toHaveBeenLastCalledWith(
+      TUESDAYS,
+      expect.objectContaining({ date: "2026-10-13" }),
+    );
+    fireEvent.click(saveButton());
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls[0][1].recurrence).toEqual(TUESDAYS);
+  });
+
+  // An end date is the user's: a start moved past it leaves it as set, and the backend's refusal
+  // stops the save (C11 critiques C1-M5, C2-M3).
+  it("a start moved past the repeat's end date is refused, the end left as set", async () => {
+    const ENDS = "The end date is before the first occurrence.";
+    describeRecurrence.mockImplementation(async (rule, start) =>
+      rule.ends.kind === "on_date" && start.date > rule.ends.date
+        ? { outcome: "refused", message: ENDS }
+        : readyAt(start),
+    );
+    const until: RepeatRule = { ...MONDAYS, ends: { kind: "on_date", date: "2026-10-19" } };
+    open({
+      handover: handed({ ...seed, summary: "Gym", recurrence: { kind: "rule", rule: until } }),
+    });
+    await act(async () => {});
+    expect(saveButton().disabled).toBe(false);
+    typeOver(screen.getByLabelText<HTMLInputElement>("Start date"), "27-10-2026");
+    await act(async () => {});
+    expect(describeRecurrence).toHaveBeenLastCalledWith(
+      { ...TUESDAYS, ends: { kind: "on_date", date: "2026-10-19" } },
+      expect.objectContaining({ date: "2026-10-27" }),
+    );
+    expect(screen.getByText(ENDS)).toBeTruthy();
+    expect(saveButton().disabled).toBe(true);
+  });
+
+  it("Custom… sets the rule: Done shows it in the backend's words, focus back on the menu", async () => {
+    createEvent.mockResolvedValue(saved);
+    describeRecurrence.mockImplementation(async (rule, start) =>
+      readyAt(
+        start,
+        rule.pattern.kind === "weekly" && rule.pattern.days.length === 2
+          ? "Weekly on Monday and Wednesday"
+          : "Weekly on Monday",
+      ),
+    );
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Gym" } });
+    await chooseCustom();
+    const custom = screen.getByRole("dialog", { name: "Custom recurrence" });
+    // Weekly on the start's own day to begin with, as Google's dialog opens.
+    expect(
+      within(custom).getByRole("button", { name: "Monday" }).getAttribute("aria-pressed"),
+    ).toBe("true");
+    fireEvent.click(within(custom).getByRole("button", { name: "Wednesday" }));
+    fireEvent.click(within(custom).getByRole("button", { name: "Done" }));
+    await act(async () => {});
+    expect(screen.queryByRole("dialog", { name: "Custom recurrence" })).toBeNull();
+    expect(shownRepeat()).toBe("Weekly on Monday and Wednesday");
+    expect(document.activeElement).toBe(repeat());
+    fireEvent.click(saveButton());
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls[0][1].recurrence).toEqual(MON_WED);
+  });
+
+  it("Escape in the custom dialog leaves the editor open", async () => {
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Gym" } });
+    await chooseCustom();
+    expect(screen.getByRole("dialog", { name: "Custom recurrence" })).toBeTruthy();
+    fireEvent.keyDown(window, { key: "Escape" });
+    expect(screen.queryByRole("dialog", { name: "Custom recurrence" })).toBeNull();
+    // The editor stays, asking nothing, its repeat as it was, and focus back on the menu.
+    expect(screen.getByRole("dialog", { name: "New event" })).toBeTruthy();
+    expect(screen.queryByText("Discard this new event?")).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(shownRepeat()).toBe("Does not repeat");
+    expect(document.activeElement).toBe(repeat());
+  });
+
+  it("nothing saves from behind the custom dialog", async () => {
+    createEvent.mockResolvedValue(saved);
+    open();
+    fireEvent.change(title(), { target: { value: "Gym" } });
+    await chooseCustom();
+    await ctrlS();
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(screen.getByRole("dialog", { name: "Custom recurrence" })).toBeTruthy();
+  });
+
+  it("quick create's Custom… opens the dialog here; Cancel puts focus on the title", async () => {
+    open({ handover: handed({ ...seed, summary: "Gym" }, { openCustom: true }) });
+    const custom = screen.getByRole("dialog", { name: "Custom recurrence" });
+    expect(document.activeElement).toBe(within(custom).getByLabelText("Repeat every"));
+    fireEvent.click(within(custom).getByRole("button", { name: "Cancel" }));
+    expect(screen.queryByRole("dialog", { name: "Custom recurrence" })).toBeNull();
+    await waitFor(() => expect(document.activeElement).toBe(title()));
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  // Check again sends exactly what was sent: what the Repeat row says of the fields now can't hold it.
+  it("a handed-over retry token's Check again doesn't wait for the repeat's words", async () => {
+    describeRecurrence.mockReturnValue(new Promise<RepeatView>(() => {}));
+    createEvent.mockResolvedValue(saved);
+    const draft: EditorFields = {
+      ...seed,
+      summary: "Gym",
+      recurrence: { kind: "rule", rule: MONDAYS },
+    };
+    const sent = { calendarId: PERSONAL, draft: toNewEvent(draft) };
+    expect(sent.draft.recurrence).toEqual(MONDAYS);
+    const first = open({ handover: handed(draft, { held: { token: "ref-1", sent } }) });
+    await act(async () => {});
+    const again = screen.getByRole<HTMLButtonElement>("button", { name: "Check again" });
+    expect(again.disabled).toBe(false);
+    // With the words still to come, it sends the held body, rule and all, under the same token.
+    fireEvent.click(again);
+    await waitFor(() => expect(first.onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([[PERSONAL, sent.draft, "ref-1"]]);
+    cleanup();
+    // Ctrl+S too.
+    createEvent.mockClear();
+    const second = open({ handover: handed(draft, { held: { token: "ref-1", sent } }) });
+    await act(async () => {});
+    await ctrlS();
+    await waitFor(() => expect(second.onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([[PERSONAL, sent.draft, "ref-1"]]);
+  });
 });
diff --git a/src/components/calendar/edit/NewEventEditor.tsx b/src/components/calendar/edit/NewEventEditor.tsx
index abc6c808..bf0e5878 100644
--- a/src/components/calendar/edit/NewEventEditor.tsx
+++ b/src/components/calendar/edit/NewEventEditor.tsx
@@ -19,6 +19,13 @@
 //
 // Times are in this computer's zone (plan rule R6): when it can't be read, the times can't be
 // changed and nothing can be saved, rather than guessing UTC.
+//
+// It can repeat (C11): the Repeat row under When offers Google's ready-made rules for the start
+// date and Custom…, whose dialog opens inside this one. The backend says what a rule means at the
+// start: its words, the day it really starts on when the rule doesn't allow the one typed (said,
+// never written into the date fields; the save moves it), or why it can't be saved. Until it has
+// said so for exactly the rule and start on screen, nothing saves, by any way to save. A rule whose
+// day came from the start date follows the start when it moves.
 
 import {
   useCallback,
@@ -41,6 +48,7 @@ import {
   endTimeChoices,
   endsAfterStart,
   firstEndOnItsDate,
+  followStart,
   halfInstant,
   hasBadDate,
   refusedDateId,
@@ -65,12 +73,15 @@ import {
   targetById,
   type CreateTargets,
 } from "../../../lib/calendarEdit/createTargets";
+import { repeatStartOf, startDateOf } from "../../../lib/calendarEdit/recurrenceDraft";
 import { isLetterKey } from "../../../lib/letterKey";
 import { deviceTimeZoneOrNull } from "../../../theme";
 import { Button, Callout, ConfirmDialog, Dialog } from "../../ui";
 import { CalendarPicker } from "./CalendarPicker";
+import { CustomRecurrenceDialog } from "./CustomRecurrenceDialog";
 import {
   NO_ZONE_CREATE,
+  RepeatRow,
   ShowAsControl,
   TextRow,
   VisibilitySelect,
@@ -79,6 +90,7 @@ import {
   type Timed,
 } from "./EventFields";
 import { createEvent, noteCreateResult, noteHeldCreate, type CreateSent } from "./useEventWrites";
+import { useRepeatView } from "./useRepeat";
 
 interface Props {
   /** The fields it starts with (`newEventSeed`): closing unchanged from these asks nothing. */
@@ -117,8 +129,15 @@ export interface CreateHandover {
   /** Text quick create's date field couldn't read: it stands here as the start's (Start date or
    *  First day), refusing a save until that field is given a date, as it did there. */
   badDate: string | null;
+  /** Quick create's Repeat row picked Custom…: the dialog opens here, over the full editor, since a
+   *  modal dialog over quick create's box would fight its click-outside rule. */
+  openCustom: boolean;
 }
 
+/** Where the Custom dialog was opened from: the Repeat row here (focus goes back to it), or quick
+ *  create's hand-over (focus goes to the title). */
+type CustomFrom = "row" | "handover";
+
 /** An answer that never arrived: its retry token, exactly what was sent, and the fields that were. */
 interface Held {
   token: string;
@@ -198,6 +217,10 @@ export function NewEventEditor({
   const [askDiscard, setAskDiscardState] = useState(false);
   const askDiscardRef = useRef(false);
   const [zonePick, setZonePick] = useState<"both" | "start" | "end" | null>(null);
+  // The Custom dialog, while open: no save goes from behind it (Ctrl+S included).
+  const startCustom: CustomFrom | null = handover?.openCustom ? "handover" : null;
+  const customRef = useRef<CustomFrom | null>(startCustom);
+  const [custom, setCustomState] = useState<CustomFrom | null>(startCustom);
   const saveButton = useRef<HTMLButtonElement>(null);
   const titleBox = useRef<HTMLDivElement>(null);
   // The latest overview and hidden set, for the words an answer gets after the props moved on.
@@ -209,6 +232,8 @@ export function NewEventEditor({
   });
   // Whether this editor is still showing: an answer after it has gone is said as a notice instead.
   const alive = useRef(true);
+  // What the backend says of the repeat at this start; until it says it can be saved, nothing saves.
+  const repeat = useRepeatView(draft.recurrence, repeatStartOf(draft.time));
 
   const setDraft = (next: EditorFields) => {
     draftRef.current = next;
@@ -230,6 +255,10 @@ export function NewEventEditor({
     askDiscardRef.current = open;
     setAskDiscardState(open);
   };
+  const setCustom = (from: CustomFrom | null) => {
+    customRef.current = from;
+    setCustomState(from);
+  };
   const focusTitle = useCallback(
     () => titleBox.current?.querySelector<HTMLInputElement>("input")?.focus(),
     [],
@@ -237,9 +266,10 @@ export function NewEventEditor({
   const refocusSave = () => setTimeout(() => saveButton.current?.focus(), 0);
   const whereOf = (id: string) => createdWhere(overviewRef.current, hiddenRef.current, id);
 
-  // The title takes focus first (after the dialog's own first focus, which this runs after).
+  // The title takes focus first (after the dialog's own first focus, which this runs after), unless
+  // quick create handed over with the Custom dialog open, which has it.
   useEffect(() => {
-    focusTitle();
+    if (!customRef.current) focusTitle();
   }, [focusTitle]);
 
   useEffect(() => {
@@ -334,10 +364,20 @@ export function NewEventEditor({
     return endAfterStart(NEW_EVENT_BASE, moved, length);
   }
 
-  /** A time change by the user: from now on the time is theirs, whatever the calendar. */
+  /** The Custom dialog closed (Done, Cancel or Escape). Opened from the Repeat row, its focus trap
+   *  hands focus back to that row; opened by quick create's hand-over, there's nothing here it came
+   *  from, so the title takes it, as it would have on open. */
+  function closeCustom() {
+    const from = customRef.current;
+    setCustom(null);
+    if (from === "handover") setTimeout(focusTitle, 0);
+  }
+
+  /** A time change by the user: from now on the time is theirs, whatever the calendar. A rule whose
+   *  day came from the start date follows it. */
   function changeTime(next: EditorFields) {
     timeTouched.current = true;
-    setDraft(next);
+    setDraft(followStart(draftRef.current, next));
   }
 
   /** Another calendar. While the time is still the seed's, the end follows that account's length
@@ -353,9 +393,15 @@ export function NewEventEditor({
     }
   }
 
+  /** Whether the backend has said `fields`' repeat can be saved, for exactly its rule and start (a
+   *  date the blur before a save just committed is a new start, not yet asked about). */
+  const repeatReady = (fields: EditorFields) =>
+    repeat.saveable(fields.recurrence, repeatStartOf(fields.time));
+
   async function save() {
-    // Refused before anything is blurred: focus stays put (in the discard question too).
-    if (savingRef.current || askDiscardRef.current) return;
+    // Refused before anything is blurred: focus stays put (in the discard question, and the Custom
+    // dialog, too).
+    if (savingRef.current || askDiscardRef.current || customRef.current) return;
     const h = heldRef.current;
     // Without a zone a new draft can't go (that's said under the fields); a held one goes as sent.
     if (!h && deviceZone === null) return;
@@ -377,7 +423,8 @@ export function NewEventEditor({
         refocus(document.getElementById(refusedDateId(whenId, badDatesRef.current)));
         return;
       }
-      if (checkDraft(NEW_EVENT_BASE, current).problems.length > 0) {
+      // A repeat the backend refused, or hasn't answered for yet, is said under the Repeat row too.
+      if (checkDraft(NEW_EVENT_BASE, current).problems.length > 0 || !repeatReady(current)) {
         setBanner(null);
         refocus(focused);
         return;
@@ -470,11 +517,12 @@ export function NewEventEditor({
   // The End list resolves every quarter hour, so it's worked out once per time change.
   const endChoices = useMemo(() => (timed ? endTimeChoices(NEW_EVENT_BASE, timed) : []), [timed]);
   const endMin = useMemo(() => (timed ? endDateMin(NEW_EVENT_BASE, timed) : undefined), [timed]);
+  const repeatHolds = repeat.state.state === "loading" || repeat.state.state === "refused";
   // A date a field couldn't read is said under When, naming the field.
   const lines = [...new Set(check.problems.map(problemText))];
   const notes = [
     ...(timeOff ? [NO_ZONE_CREATE] : []),
-    ...createNotes(draft.time, overview, hidden, calendarId),
+    ...createNotes(draft.time, draft.recurrence.kind === "rule", overview, hidden, calendarId),
     ...(noPrivate ? [PRIVATE_OFF] : []),
   ];
 
@@ -502,7 +550,8 @@ export function NewEventEditor({
               onKeyDown={(e) => {
                 if (e.key === "Enter" && e.repeat) e.preventDefault();
               }}
-              disabled={saving || timeOff}
+              // Check again sends exactly what was sent, whatever the Repeat row says now.
+              disabled={saving || timeOff || (!held && repeatHolds)}
             >
               {saving ? (held ? "Checking…" : "Saving…") : held ? "Check again" : "Save"}
             </Button>
@@ -573,6 +622,18 @@ export function NewEventEditor({
             }
             canSwitchKind={!timeOff}
             onPickZone={setZonePick}
+            repeat={
+              <RepeatRow
+                value={draft.recurrence}
+                view={repeat.state}
+                time={draft.time}
+                deviceZone={deviceZone}
+                skippedTime={check.problems.some((p) => p.kind === "gap")}
+                disabled={!timeEditable}
+                onChange={(recurrence) => setDraft({ ...draftRef.current, recurrence })}
+                onCustom={() => setCustom("row")}
+              />
+            }
           />
           {zonePick && timeEditable && draft.time.kind === "timed" && (
             <ZonePanel
@@ -641,6 +702,19 @@ export function NewEventEditor({
             </p>
           ))}
         </div>
+        {/* Inside the editor's dialog, not beside it: nested, it alone is topmost, so one Escape
+            closes only it and Tab stays in it. */}
+        {custom && (
+          <CustomRecurrenceDialog
+            rule={draft.recurrence.kind === "rule" ? draft.recurrence.rule : null}
+            startDate={startDateOf(draft.time)}
+            onDone={(rule) => {
+              setDraft({ ...draftRef.current, recurrence: { kind: "rule", rule } });
+              closeCustom();
+            }}
+            onClose={closeCustom}
+          />
+        )}
       </Dialog>
 
       <ConfirmDialog
diff --git a/src/components/calendar/edit/QuickCreatePopover.test.tsx b/src/components/calendar/edit/QuickCreatePopover.test.tsx
index a80b88c8..e15410bd 100644
--- a/src/components/calendar/edit/QuickCreatePopover.test.tsx
+++ b/src/components/calendar/edit/QuickCreatePopover.test.tsx
@@ -12,7 +12,11 @@
 // save it stops puts focus; and it goes on refusing with More options), a titled draft that goes
 // with the tab is handed back to open on again, the keyboard comes back into the box even while it's
 // locked, the ghost is told how far the event has got, and the calendar list the keyboard can reach
-// stays inside the box.
+// stays inside the box. Repeating (C11): a ready-made rule is sent with the create, one the backend
+// refuses stops every save (a start the clocks skip said once), one from before the months PM syncs
+// is said to show inside them, a rule's own day follows a moved date, the Repeat list stays inside
+// the box (Escape there closing only it), and Custom…, clicked or reached by the keyboard, carries
+// on in the full editor with its dialog open, sending nothing.
 
 import { createRef, StrictMode } from "react";
 import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
@@ -22,6 +26,10 @@ import type {
   CalendarAccount,
   CalendarOverview,
   NewEventDraft,
+  RepeatPreset,
+  RepeatRule,
+  RepeatStart,
+  RepeatView,
   WriteOutcome,
 } from "../../../lib/types";
 import { CREATE_LOST } from "../../../lib/calendarEdit/editReasons";
@@ -36,8 +44,17 @@ const createEvent =
   >();
 const noteCreateResult = vi.fn();
 const noteHeldCreate = vi.fn();
+const recurrencePresets = vi.fn<(day: string) => Promise<RepeatPreset[]>>();
+const describeRecurrence = vi.fn<(rule: RepeatRule, start: RepeatStart) => Promise<RepeatView>>();
 let deviceZone: string | null = "Europe/London";
 
+// The repeat menu's two reads, answered as the test says.
+vi.mock("../../../lib/ipc", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  recurrencePresets: (day: string) => recurrencePresets(day),
+  describeRecurrence: (rule: RepeatRule, start: RepeatStart) => describeRecurrence(rule, start),
+}));
+
 vi.mock("./useEventWrites", async (importOriginal) => ({
   // The rest as it is, for the write notices drawn beside the box.
   ...(await importOriginal<object>()),
@@ -121,6 +138,7 @@ const seed: EditorFields = {
     end_time: "10:00",
     end_zone: "Europe/London",
   },
+  recurrence: { kind: "once" },
   show_as: "busy",
   visibility: "default",
 };
@@ -175,8 +193,28 @@ beforeAll(() => {
   }
 });
 
+const weeklyOn = (day: "mon" | "tue"): RepeatRule => ({
+  pattern: { kind: "weekly", days: [day] },
+  interval: 1,
+  ends: { kind: "never" },
+});
+
 beforeEach(() => {
   deviceZone = "Europe/London";
+  // The ready-made rules for the start date (the first two are enough), and a rule that starts where
+  // asked.
+  recurrencePresets.mockImplementation(async (day) => [
+    { label: "Daily", rule: { ...weeklyOn("mon"), pattern: { kind: "daily" } } },
+    day === "2026-10-13"
+      ? { label: "Weekly on Tuesday", rule: weeklyOn("tue") }
+      : { label: "Weekly on Monday", rule: weeklyOn("mon") },
+  ]);
+  describeRecurrence.mockImplementation(async (_rule, start) => ({
+    outcome: "ready",
+    summary: "Weekly on Monday",
+    starts: start.date,
+    moved: false,
+  }));
 });
 
 afterEach(() => {
@@ -327,6 +365,7 @@ describe("QuickCreatePopover", () => {
       showAsTouched: false,
       timeTouched: true,
       badDate: null,
+      openCustom: false,
     });
   });
 
@@ -747,7 +786,7 @@ describe("QuickCreatePopover", () => {
     // Enter or Space on a button is its click, with no pointer behind it.
     fireEvent.click(trigger, { detail: 0 });
     const list = screen.getByRole("group", LIST);
-    expect(screen.getByRole("dialog", { name: "New event" }).contains(list)).toBe(true);
+    expect(list.parentElement).toBe(screen.getByRole("dialog", { name: "New event" }));
     const picked = within(list).getByRole("radio", { name: "Personal" });
     await waitFor(() => expect(document.activeElement).toBe(picked));
     fireEvent.keyDown(picked, { key: "Tab" });
@@ -1017,4 +1056,175 @@ describe("QuickCreatePopover", () => {
     await screen.findByText("“Dentist” wasn't created: PM couldn't reach Google.");
     expect(onDraft.mock.lastCall![2]).toBe("unsaved");
   });
+
+  // --- repeating (C11) ---
+
+  const repeat = () => screen.getByRole<HTMLButtonElement>("button", { name: /^Repeat: / });
+  /** The rule the Repeat button names. */
+  const shownRepeat = () =>
+    repeat()
+      .getAttribute("aria-label")
+      ?.replace(/^Repeat: /, "");
+  const REPEATS = { name: "Repeat" };
+
+  /** Open the Repeat list, once the menu has its ready-made rules. */
+  async function openRepeat() {
+    await act(async () => {});
+    fireEvent.click(repeat());
+    return screen.getByRole("group", REPEATS);
+  }
+
+  /** Click the Repeat row whose words are `label`. */
+  async function pickRepeat(label: string) {
+    const list = await openRepeat();
+    fireEvent.click(within(list).getByRole("radio", { name: label }), { detail: 1 });
+    await act(async () => {});
+  }
+
+  it("a preset is sent with the create", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    await pickRepeat("Weekly on Monday");
+    expect(shownRepeat()).toBe("Weekly on Monday");
+    // It starts on the day picked, so nothing says it moved.
+    expect(screen.queryByText(/the first day this repeat allows/)).toBeNull();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    expect(createEvent.mock.calls).toEqual([
+      [PERSONAL, { ...sentFor("Standup").draft, recurrence: weeklyOn("mon") }, null],
+    ]);
+  });
+
+  it("a repeat the backend refuses stops every save, and says why", async () => {
+    const GAP =
+      "The first occurrence would be on 29-03-2027, when the clocks skip that time. Pick a time outside that hour.";
+    describeRecurrence.mockResolvedValue({ outcome: "refused", message: GAP });
+    open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    await pickRepeat("Weekly on Monday");
+    expect(screen.getByText(GAP)).toBeTruthy();
+    expect(screen.getByRole<HTMLButtonElement>("button", { name: "Save" }).disabled).toBe(true);
+    title().focus();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(title());
+  });
+
+  /** Give the Date field `text`, as typed and left. */
+  function typeDate(text: string) {
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: text } });
+    fireEvent.blur(date);
+  }
+
+  // The time line already refuses a start the clocks skip, and the backend refuses a first
+  // occurrence on it in other words: said once.
+  it("a start the clocks skip is refused once, not again under Repeat", async () => {
+    const SKIPPED =
+      "The first occurrence would be on 28-03-2027, when the clocks skip that time. Pick a time outside that hour.";
+    describeRecurrence.mockResolvedValue({ outcome: "refused", message: SKIPPED });
+    open();
+    fireEvent.change(title(), { target: { value: "Swim" } });
+    typeDate("28-03-2027");
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "01:30" } });
+    await pickRepeat("Daily");
+    expect(screen.getAllByText(/the clocks skip/)).toHaveLength(1);
+    expect(screen.getByText(/^01:30 doesn't happen in Europe\/London that night/)).toBeTruthy();
+    expect(screen.getByRole<HTMLButtonElement>("button", { name: "Save" }).disabled).toBe(true);
+  });
+
+  // The backend lists and lands its occurrences inside the months PM syncs, wherever it starts.
+  it("a repeat that starts before the months PM syncs says only its occurrences there show", async () => {
+    open();
+    fireEvent.change(title(), { target: { value: "Gym" } });
+    typeDate("06-07-2026");
+    await pickRepeat("Weekly on Monday");
+    expect(
+      screen.getByText(
+        /^This starts before the months PM syncs \(.+\), so only its occurrences within them will show here\.$/,
+      ),
+    ).toBeTruthy();
+    expect(screen.queryByText(/won't show here/)).toBeNull();
+  });
+
+  it("moving the date moves a one-day weekly rule", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    await pickRepeat("Weekly on Monday");
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "13-10-2026" } });
+    fireEvent.blur(date);
+    await act(async () => {});
+    expect(shownRepeat()).toBe("Weekly on Tuesday");
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    expect(createEvent.mock.calls[0][1].recurrence).toEqual(weeklyOn("tue"));
+  });
+
+  // The Repeat list stays inside the box, as in the full editor's dialog, and Escape there closes
+  // the list, never the box (even an empty one, which Escape in the box itself would close).
+  it("the Repeat list is inside the box, and Escape closes only it", async () => {
+    const { onClose } = open();
+    const list = await openRepeat();
+    expect(list.parentElement).toBe(screen.getByRole("dialog", { name: "New event" }));
+    const picked = within(list).getByRole("radio", { name: "Does not repeat" });
+    await waitFor(() => expect(document.activeElement).toBe(picked));
+    fireEvent.keyDown(picked, { key: "Escape" });
+    expect(screen.queryByRole("group", REPEATS)).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(repeat());
+  });
+
+  it("Custom… reached by the keyboard hands over on Enter, and an arrow key never does", async () => {
+    const { onMore } = open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    const list = await openRepeat();
+    const picked = within(list).getByRole("radio", { name: "Does not repeat" });
+    await waitFor(() => expect(document.activeElement).toBe(picked));
+    // The arrow keys go round the rules only: up from the first is the last.
+    fireEvent.keyDown(picked, { key: "ArrowUp" });
+    const last = within(list).getByRole("radio", { name: "Weekly on Monday" });
+    last.focus();
+    fireEvent.click(last, { detail: 0 });
+    await act(async () => {});
+    expect(shownRepeat()).toBe("Weekly on Monday");
+    expect(onMore).not.toHaveBeenCalled();
+    // Tab reaches Custom…, and Enter (its click) hands over.
+    fireEvent.keyDown(last, { key: "Tab" });
+    const custom = within(list).getByRole("button", { name: "Custom…" });
+    expect(document.activeElement).toBe(custom);
+    expect(fireEvent.keyDown(custom, { key: "Enter" })).toBe(true);
+    fireEvent.click(custom, { detail: 0 });
+    expect(onMore).toHaveBeenCalledTimes(1);
+    expect(onMore.mock.lastCall![0]).toMatchObject({
+      draft: { recurrence: { kind: "rule", rule: weeklyOn("mon") } },
+      openCustom: true,
+    });
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("Custom… hands over to the full editor with the custom dialog open, sending nothing", async () => {
+    const { onMore, onClose } = open();
+    fireEvent.change(title(), { target: { value: "Standup" } });
+    await pickRepeat("Weekly on Monday");
+    const list = await openRepeat();
+    fireEvent.click(within(list).getByRole("button", { name: "Custom…" }), { detail: 1 });
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(onMore).toHaveBeenCalledWith({
+      draft: { ...seed, summary: "Standup", recurrence: { kind: "rule", rule: weeklyOn("mon") } },
+      calendarId: PERSONAL,
+      held: null,
+      unproven: null,
+      showAsTouched: false,
+      timeTouched: false,
+      badDate: null,
+      openCustom: true,
+    });
+  });
 });
diff --git a/src/components/calendar/edit/QuickCreatePopover.tsx b/src/components/calendar/edit/QuickCreatePopover.tsx
index 4cb1f55e..53af9c1b 100644
--- a/src/components/calendar/edit/QuickCreatePopover.tsx
+++ b/src/components/calendar/edit/QuickCreatePopover.tsx
@@ -27,6 +27,11 @@
 // goes, or go on to the full editor with More options, until a save that's made. A date the field
 // couldn't read refuses every save until that field is given a date: its line names the field, a
 // save it stops puts focus there, and it goes on refusing in the full editor with More options.
+//
+// It can repeat (C11): a compact Repeat row offers Google's ready-made rules in place, and says where
+// the event really starts or why its rule can't be saved, which stops every save as in the full
+// editor. Custom… carries on in the full editor with its dialog open, sending nothing: a modal
+// dialog over this box would fight its click-outside rule.
 
 import {
   useCallback,
@@ -48,11 +53,13 @@ import {
   dateFieldId,
   endAfterStart,
   endTimeChoices,
+  followStart,
   halfInstant,
   switchNewKind,
   toNewEvent,
   type EditorFields,
 } from "../../../lib/calendarEdit/eventDraft";
+import { repeatStartOf } from "../../../lib/calendarEdit/recurrenceDraft";
 import {
   ambiguousText,
   badDateText,
@@ -76,9 +83,10 @@ import { Button, Callout, IconButton, Input, Toggle } from "../../ui";
 import { DateField } from "../../DateField";
 import { TimeField } from "../../TimeField";
 import { CalendarPicker } from "./CalendarPicker";
-import { NO_ZONE_CREATE, type Timed } from "./EventFields";
+import { NO_ZONE_CREATE, RepeatRow, type Timed } from "./EventFields";
 import type { CreateHandover, Unproven } from "./NewEventEditor";
 import { createEvent, noteCreateResult, noteHeldCreate, type CreateSent } from "./useEventWrites";
+import { useRepeatView } from "./useRepeat";
 
 interface Props {
   /** The "+ New event" button's rect: the box opens under it. */
@@ -218,6 +226,8 @@ export function QuickCreatePopover({
   const handedOver = useRef(false);
   // Closed from inside (saved, ✕, a click outside or Escape): nothing to hand back.
   const closed = useRef(false);
+  // What the backend says of the repeat at this start; until it says it can be saved, nothing saves.
+  const repeat = useRepeatView(draft.recurrence, repeatStartOf(draft.time));
 
   // A dialog layer while open: Ctrl+K, the calendar's keys and its swipe stand down.
   useDialogLayer(true, panelRef);
@@ -424,10 +434,11 @@ export function QuickCreatePopover({
   const moveStart = (t: Timed, date: string, time: string): Timed =>
     endAfterStart(NEW_EVENT_BASE, { ...t, start_date: date, start_time: time }, lengthOf(t));
 
-  /** A time change by the user: from now on the time is theirs, whatever the calendar. */
+  /** A time change by the user: from now on the time is theirs, whatever the calendar. A rule whose
+   *  day came from the start date follows it. */
   function changeTime(time: TimeDraft) {
     timeTouched.current = true;
-    setDraft({ ...draftRef.current, time });
+    setDraft(followStart(draftRef.current, { ...draftRef.current, time }));
   }
 
   /** Another calendar. While the time is still the seed's, the end follows that account's length. */
@@ -449,9 +460,10 @@ export function QuickCreatePopover({
     setDraft(switchNewKind(draftRef.current, seed, deviceZone, lengthRef.current, false));
   }
 
-  /** More options: the full editor carries on with this draft. Never while a save is out: the
-   *  editor would start a second event under a new id while the first may still land. */
-  function more() {
+  /** More options: the full editor carries on with this draft (with the Custom dialog open, for the
+   *  Repeat row's Custom…). Never while a save is out: the editor would start a second event under
+   *  a new id while the first may still land. */
+  function more(openCustom = false) {
     if (savingRef.current) return;
     commitFocused();
     handedOver.current = true;
@@ -467,9 +479,15 @@ export function QuickCreatePopover({
       // Read after the blur above, so a date typed and not yet read is refused there too: the field
       // put back the date it had, which the full editor must not save in its place.
       badDate: badDateRef.current,
+      openCustom,
     });
   }
 
+  /** Whether the backend has said `fields`' repeat can be saved, for exactly its rule and start (a
+   *  date the blur before a save just committed is a new start, not yet asked about). */
+  const repeatReady = (fields: EditorFields) =>
+    repeat.saveable(fields.recurrence, repeatStartOf(fields.time));
+
   async function save() {
     // Refused before anything is blurred: focus stays put.
     if (savingRef.current) return;
@@ -495,7 +513,8 @@ export function QuickCreatePopover({
         refocus(document.getElementById(dateId));
         return;
       }
-      if (checkDraft(NEW_EVENT_BASE, current).problems.length > 0) {
+      // A repeat the backend refused, or hasn't answered for yet, is said under the Repeat row too.
+      if (checkDraft(NEW_EVENT_BASE, current).problems.length > 0 || !repeatReady(current)) {
         setBanner(null);
         refocus(focused);
         return;
@@ -568,11 +587,12 @@ export function QuickCreatePopover({
   const endChoices = useMemo(() => (timed ? endTimeChoices(NEW_EVENT_BASE, timed) : []), [timed]);
   // The one date field's name, on screen and in its refusal.
   const dateName = timed ? "Date" : "Day";
+  const repeatHolds = repeat.state.state === "loading" || repeat.state.state === "refused";
   // A date the field couldn't read is said under the times, naming the field.
   const lines = [...new Set(check.problems.map(problemText))];
   const notes = [
     ...(timeOff ? [NO_ZONE_CREATE] : []),
-    ...createNotes(t, overview, hidden, calendarId),
+    ...createNotes(t, draft.recurrence.kind === "rule", overview, hidden, calendarId),
   ];
 
   return (
@@ -691,6 +711,17 @@ export function QuickCreatePopover({
           />
           All day
         </label>
+        <RepeatRow
+          compact
+          value={draft.recurrence}
+          view={repeat.state}
+          time={t}
+          deviceZone={deviceZone}
+          skippedTime={check.problems.some((p) => p.kind === "gap")}
+          disabled={!timeEditable}
+          onChange={(recurrence) => setDraft({ ...draftRef.current, recurrence })}
+          onCustom={() => more(true)}
+        />
         {/* A date the field couldn't read, said as it happens and naming the field it points at. */}
         {badDate !== null && (
           <p id={refusedLineId} role="alert" className="text-xs text-st-due">
@@ -729,7 +760,7 @@ export function QuickCreatePopover({
           disabled={locked}
         />
         <div className="ml-auto flex items-center gap-2">
-          <Button variant="tertiary" size="sm" onClick={more} disabled={saving}>
+          <Button variant="tertiary" size="sm" onClick={() => more()} disabled={saving}>
             More options
           </Button>
           <Button
@@ -741,7 +772,7 @@ export function QuickCreatePopover({
             onKeyDown={(e) => {
               if (e.key === "Enter" && e.repeat) e.preventDefault();
             }}
-            disabled={saving || timeOff}
+            disabled={saving || timeOff || repeatHolds}
           >
             {saving ? (held ? "Checking…" : "Saving…") : held ? "Check again" : "Save"}
           </Button>
diff --git a/src/components/calendar/edit/RecurrenceSelect.test.tsx b/src/components/calendar/edit/RecurrenceSelect.test.tsx
new file mode 100644
index 00000000..6241ba15
--- /dev/null
+++ b/src/components/calendar/edit/RecurrenceSelect.test.tsx
@@ -0,0 +1,474 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Repeat menu (#884, C11 §6): Google's order, a rule that is none of the ready-made ones shown as
+// its own row in the backend's words, the button always naming the rule held, the arrow keys moving
+// the choice (the button following) and never opening Custom…, which opens on a click, Enter or
+// Space and leaves the value as it was, the keyboard getting in and out of the list (Escape closing
+// only it), the list inside the dialog around it, and a rule PM can only show kept until it's
+// replaced.
+
+import { useState } from "react";
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RepeatPreset, RepeatRule } from "../../../lib/types";
+import type { RepeatValue } from "../../../lib/calendarEdit/recurrenceDraft";
+
+const recurrencePresets = vi.fn<(day: string) => Promise<RepeatPreset[]>>();
+
+vi.mock("../../../lib/ipc", () => ({
+  recurrencePresets: (day: string) => recurrencePresets(day),
+}));
+
+vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth: "standard" }),
+}));
+
+import { RecurrenceSelect } from "./RecurrenceSelect";
+
+const rule = (pattern: RepeatRule["pattern"]): RepeatRule => ({
+  pattern,
+  interval: 1,
+  ends: { kind: "never" },
+});
+
+/** The five ready-made rules for Tue 13-10-2026, as the backend gives them. */
+const PRESETS: RepeatPreset[] = [
+  { label: "Daily", rule: rule({ kind: "daily" }) },
+  { label: "Weekly on Tuesday", rule: rule({ kind: "weekly", days: ["tue"] }) },
+  {
+    label: "Monthly on the second Tuesday",
+    rule: rule({ kind: "monthly_weekday", nth: "second", weekday: "tue" }),
+  },
+  { label: "Annually on 13 October", rule: rule({ kind: "yearly_date" }) },
+  {
+    label: "Every weekday (Monday to Friday)",
+    rule: rule({ kind: "weekly", days: ["mon", "tue", "wed", "thu", "fri"] }),
+  },
+];
+
+const monWed: RepeatValue = { kind: "rule", rule: rule({ kind: "weekly", days: ["mon", "wed"] }) };
+const MON_WED = "Weekly on Monday and Wednesday";
+
+// jsdom ships no ResizeObserver, and the list's popover (escapeClipping) builds one to re-place
+// itself; placement isn't what these assert.
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+});
+
+beforeEach(() => {
+  recurrencePresets.mockResolvedValue(PRESETS);
+});
+
+afterEach(() => {
+  cleanup();
+  vi.resetAllMocks();
+});
+
+interface Opts {
+  /** The backend's words for the rule held, if any. */
+  words?: (value: RepeatValue) => string | null;
+  /** The parent takes every change, as the editors do; otherwise it keeps its value. */
+  follow?: boolean;
+}
+
+/** The menu inside a dialog, as both editors hold it, with the value it's given. */
+function mount(start: RepeatValue, { words = () => null, follow = true }: Opts = {}) {
+  const onChange = vi.fn();
+  const onCustom = vi.fn();
+  let setValue: (v: RepeatValue) => void = () => {};
+  function Harness({ disabled }: { disabled: boolean }) {
+    const [value, set] = useState(start);
+    setValue = set;
+    return (
+      <div role="dialog" aria-label="Editor">
+        <RecurrenceSelect
+          value={value}
+          startDate="2026-10-13"
+          disabled={disabled}
+          ruleWords={words(value)}
+          onChange={(v) => {
+            onChange(v);
+            if (follow) set(v);
+          }}
+          onCustom={onCustom}
+        />
+      </div>
+    );
+  }
+  const view = render(<Harness disabled={false} />);
+  return {
+    onChange,
+    onCustom,
+    /** The parent's value changed by something else (a moved start, the Custom dialog). */
+    give: (v: RepeatValue) => act(() => setValue(v)),
+    disable: (disabled: boolean) => view.rerender(<Harness disabled={disabled} />),
+  };
+}
+
+const trigger = () => screen.getByRole<HTMLButtonElement>("button", { name: /^Repeat: / });
+/** What the button names. */
+const shown = () =>
+  trigger()
+    .getAttribute("aria-label")!
+    .replace(/^Repeat: /, "");
+const list = () => screen.queryByRole("group", { name: "Repeat" });
+const rows = () =>
+  within(list()!)
+    .getAllByRole<HTMLInputElement>("radio")
+    .map((r) => r.closest("label")!.textContent);
+const radio = (name: string) => within(list()!).getByRole<HTMLInputElement>("radio", { name });
+const checked = () =>
+  within(list()!)
+    .getAllByRole<HTMLInputElement>("radio")
+    .find((r) => r.checked);
+const customRow = () => within(list()!).getByRole("button", { name: "Custom…" });
+
+/** Open the list (the ready-made rules in), focus on the rule picked as it opens. */
+async function openList() {
+  await act(async () => {});
+  fireEvent.click(trigger());
+  await waitFor(() => expect(document.activeElement).toBe(checked()));
+}
+
+/** An arrow key in the list, as the browser takes it: focus and the choice move to `name`, with a
+ *  click no pointer made. */
+function arrowTo(name: string, key = "ArrowDown") {
+  fireEvent.keyDown(document.activeElement!, { key });
+  const next = radio(name);
+  next.focus();
+  fireEvent.click(next, { detail: 0 });
+}
+
+describe("RecurrenceSelect", () => {
+  it("lists Does not repeat, the presets and Custom… in Google's order", async () => {
+    mount({ kind: "once" });
+    await openList();
+    expect(rows()).toEqual([
+      "Does not repeat",
+      "Daily",
+      "Weekly on Tuesday",
+      "Monthly on the second Tuesday",
+      "Annually on 13 October",
+      "Every weekday (Monday to Friday)",
+    ]);
+    // Custom… after them, an action of its own rather than one of the choices.
+    const all = list()!.querySelectorAll("input, button");
+    expect(all[all.length - 1]).toBe(customRow());
+    expect(checked()).toBe(radio("Does not repeat"));
+    expect(recurrencePresets).toHaveBeenCalledWith("2026-10-13");
+  });
+
+  it("the button always names the rule held, in words", async () => {
+    const { give } = mount({ kind: "once" }, { words: (v) => (v === monWed ? MON_WED : null) });
+    await act(async () => {});
+    expect(shown()).toBe("Does not repeat");
+    expect(trigger().textContent).toBe("Does not repeat▾");
+    expect(trigger().getAttribute("aria-expanded")).toBe("false");
+    await give({ kind: "rule", rule: PRESETS[1].rule });
+    expect(shown()).toBe("Weekly on Tuesday");
+    await give(monWed);
+    expect(shown()).toBe(MON_WED);
+    expect(trigger().textContent).toBe(`${MON_WED}▾`);
+    await give({ kind: "kept", words: "Repeats (custom rule)" });
+    expect(shown()).toBe("Repeats (custom rule)");
+    await give({ kind: "once" });
+    expect(shown()).toBe("Does not repeat");
+  });
+
+  it("a preset clicked is the value, and the list closes with focus on the button", async () => {
+    const { onChange } = mount({ kind: "once" });
+    await openList();
+    expect(trigger().getAttribute("aria-expanded")).toBe("true");
+    fireEvent.click(radio("Weekly on Tuesday"), { detail: 1 });
+    expect(onChange).toHaveBeenCalledWith({ kind: "rule", rule: PRESETS[1].rule });
+    expect(list()).toBeNull();
+    expect(shown()).toBe("Weekly on Tuesday");
+    expect(document.activeElement).toBe(trigger());
+  });
+
+  it("a rule outside the presets shows as its own row, picked", async () => {
+    mount(monWed, { words: () => MON_WED });
+    await openList();
+    expect(rows()).toEqual([
+      "Does not repeat",
+      "Daily",
+      "Weekly on Tuesday",
+      "Monthly on the second Tuesday",
+      "Annually on 13 October",
+      "Every weekday (Monday to Friday)",
+      MON_WED,
+    ]);
+    expect(checked()).toBe(radio(MON_WED));
+    expect(shown()).toBe(MON_WED);
+  });
+
+  it("a rule equal to a preset, its days in another order, picks that preset", async () => {
+    mount({
+      kind: "rule",
+      rule: rule({ kind: "weekly", days: ["fri", "thu", "wed", "tue", "mon"] }),
+    });
+    await openList();
+    expect(checked()).toBe(radio("Every weekday (Monday to Friday)"));
+    expect(shown()).toBe("Every weekday (Monday to Friday)");
+    expect(rows()).toHaveLength(6);
+  });
+
+  it("the arrow keys change the rule and the button, the list staying open", async () => {
+    const { onChange, onCustom } = mount({ kind: "once" });
+    await openList();
+    arrowTo("Daily");
+    expect(onChange).toHaveBeenLastCalledWith({ kind: "rule", rule: PRESETS[0].rule });
+    expect(shown()).toBe("Daily");
+    arrowTo("Weekly on Tuesday");
+    expect(shown()).toBe("Weekly on Tuesday");
+    expect(checked()).toBe(radio("Weekly on Tuesday"));
+    expect(list()).not.toBeNull();
+    expect(onCustom).not.toHaveBeenCalled();
+  });
+
+  // The button is worked out from the value, never from the list: a change the parent doesn't take
+  // leaves both naming the rule it holds.
+  it("never names a rule the value doesn't hold", async () => {
+    const { onChange } = mount({ kind: "once" }, { follow: false });
+    await openList();
+    arrowTo("Daily");
+    expect(onChange).toHaveBeenCalledWith({ kind: "rule", rule: PRESETS[0].rule });
+    expect(shown()).toBe("Does not repeat");
+    expect(checked()).toBe(radio("Does not repeat"));
+  });
+
+  // Custom… isn't one of the radios, so the arrow keys go round the rules and never reach it (C11
+  // critique 2 M9).
+  it("the arrow keys never open Custom…", async () => {
+    const { onChange, onCustom } = mount({ kind: "once" });
+    await openList();
+    const names = rows() as string[];
+    for (const n of [...names.slice(1), ...names]) arrowTo(n);
+    for (const n of [...names].reverse()) arrowTo(n, "ArrowUp");
+    expect(onChange).toHaveBeenCalled();
+    // On Custom… itself, an arrow key does nothing.
+    customRow().focus();
+    for (const key of ["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight", "Home", "End"]) {
+      fireEvent.keyDown(customRow(), { key });
+    }
+    expect(onCustom).not.toHaveBeenCalled();
+    expect(list()).not.toBeNull();
+  });
+
+  // Moved off a rule of its own, the rule held keeps its row while the list is open, so an arrow
+  // key passing over it doesn't lose it.
+  it("the rule held when the list opened can be arrowed back to", async () => {
+    let answer: string | null = MON_WED;
+    const { onChange } = mount(monWed, { words: (v) => (v === monWed ? answer : null) });
+    await openList();
+    arrowTo("Does not repeat");
+    expect(shown()).toBe("Does not repeat");
+    expect(rows()).toContain(MON_WED);
+    // Picked again, its words are the ones it had while the backend says them again.
+    answer = null;
+    arrowTo(MON_WED, "ArrowUp");
+    expect(onChange).toHaveBeenLastCalledWith(monWed);
+    expect(shown()).toBe(MON_WED);
+    expect(checked()).toBe(radio(MON_WED));
+    // Closed on another rule, it's gone.
+    arrowTo("Daily");
+    fireEvent.keyDown(radio("Daily"), { key: "Enter" });
+    await openList();
+    expect(rows()).not.toContain(MON_WED);
+  });
+
+  it("Enter picks the rule the arrow keys moved to and closes, focus on the button", async () => {
+    const { onChange } = mount({ kind: "once" });
+    await openList();
+    arrowTo("Daily");
+    expect(fireEvent.keyDown(radio("Daily"), { key: "Enter" })).toBe(false);
+    expect(list()).toBeNull();
+    expect(document.activeElement).toBe(trigger());
+    expect(onChange).toHaveBeenCalledTimes(1);
+    expect(shown()).toBe("Daily");
+  });
+
+  it("Enter and Space on Custom… open it, the value left as it was", async () => {
+    const { onChange, onCustom } = mount({ kind: "once" });
+    await openList();
+    fireEvent.keyDown(checked()!, { key: "Tab" });
+    expect(document.activeElement).toBe(customRow());
+    // Enter on a button is its click: nothing in the list may take the key first.
+    expect(fireEvent.keyDown(customRow(), { key: "Enter" })).toBe(true);
+    expect(list()).not.toBeNull();
+    fireEvent.click(customRow(), { detail: 0 });
+    expect(onCustom).toHaveBeenCalledTimes(1);
+    expect(list()).toBeNull();
+    // Focus is on the button, which the dialog Custom… opens hands it back to.
+    expect(document.activeElement).toBe(trigger());
+    // Space too: its click comes as the key goes up.
+    await openList();
+    fireEvent.keyDown(checked()!, { key: "Tab" });
+    expect(fireEvent.keyDown(customRow(), { key: " " })).toBe(true);
+    fireEvent.keyUp(customRow(), { key: " " });
+    fireEvent.click(customRow(), { detail: 0 });
+    expect(onCustom).toHaveBeenCalledTimes(2);
+    expect(onChange).not.toHaveBeenCalled();
+    expect(shown()).toBe("Does not repeat");
+  });
+
+  it("a click on Custom… opens it and keeps the value", async () => {
+    const { onChange, onCustom } = mount(monWed, { words: () => MON_WED });
+    await openList();
+    fireEvent.click(customRow(), { detail: 1 });
+    expect(onCustom).toHaveBeenCalledTimes(1);
+    expect(onChange).not.toHaveBeenCalled();
+    expect(list()).toBeNull();
+    expect(shown()).toBe(MON_WED);
+    expect(document.activeElement).toBe(trigger());
+  });
+
+  it("Tab goes from the rules to Custom… and back; out of the list, to the button", async () => {
+    mount({ kind: "rule", rule: PRESETS[1].rule });
+    await openList();
+    // Moved here, so the browser's own Tab mustn't move it again.
+    expect(fireEvent.keyDown(checked()!, { key: "Tab" })).toBe(false);
+    expect(document.activeElement).toBe(customRow());
+    fireEvent.keyDown(customRow(), { key: "Tab", shiftKey: true });
+    expect(document.activeElement).toBe(radio("Weekly on Tuesday"));
+    // Shift+Tab out of the rules.
+    fireEvent.keyDown(radio("Weekly on Tuesday"), { key: "Tab", shiftKey: true });
+    expect(list()).toBeNull();
+    expect(document.activeElement).toBe(trigger());
+    // Tab out of Custom….
+    await openList();
+    fireEvent.keyDown(checked()!, { key: "Tab" });
+    fireEvent.keyDown(customRow(), { key: "Tab" });
+    expect(list()).toBeNull();
+    expect(document.activeElement).toBe(trigger());
+  });
+
+  // A click on the words reaches the radio forwarded by its label, with `detail` 0 in every engine PM
+  // runs on, as an arrow key's click has: the pointer going down on the row is what tells.
+  it("a click on a row's words picks and closes, as one on its radio does", async () => {
+    const { onChange } = mount({ kind: "once" });
+    await openList();
+    fireEvent.pointerDown(within(list()!).getByText("Daily"));
+    fireEvent.click(radio("Daily"), { detail: 0 });
+    expect(onChange).toHaveBeenLastCalledWith({ kind: "rule", rule: PRESETS[0].rule });
+    expect(list()).toBeNull();
+    expect(document.activeElement).toBe(trigger());
+  });
+
+  it("a key after a pointer went down on a row is the keyboard's again", async () => {
+    mount({ kind: "once" });
+    await openList();
+    // Pressed on a row and let go off it: no click. Then an arrow key moves the choice.
+    fireEvent.pointerDown(within(list()!).getByText("Daily"));
+    arrowTo("Weekly on Tuesday");
+    expect(shown()).toBe("Weekly on Tuesday");
+    expect(list()).not.toBeNull();
+  });
+
+  // A click on a Mac leaves focus where it was (jsdom's click does the same).
+  it("Escape closes only the list, focus on the button, even after a click that didn't focus it", async () => {
+    const outer = vi.fn();
+    window.addEventListener("keydown", outer);
+    try {
+      mount({ kind: "once" });
+      await openList();
+      fireEvent.keyDown(checked()!, { key: "Escape" });
+      expect(list()).toBeNull();
+      expect(document.activeElement).toBe(trigger());
+      // The dialog around it never hears it.
+      expect(outer).not.toHaveBeenCalled();
+    } finally {
+      window.removeEventListener("keydown", outer);
+    }
+  });
+
+  // Mounted in the dialog itself, not inside the button's box, and placed against the window: an
+  // absolute list would be cut off by the dialog's scrolling body.
+  it("the list is inside the dialog around it, never clipped by it", async () => {
+    mount({ kind: "once" });
+    await openList();
+    expect(list()!.parentElement).toBe(screen.getByRole("dialog", { name: "Editor" }));
+    expect(list()!.className.split(" ")).toContain("fixed");
+  });
+
+  it("closes when it's disabled, and doesn't come back by itself", async () => {
+    const { disable } = mount({ kind: "once" });
+    await openList();
+    disable(true);
+    expect(list()).toBeNull();
+    expect(trigger().disabled).toBe(true);
+    disable(false);
+    expect(list()).toBeNull();
+  });
+
+  // A custom rule's words can run long: they wrap on the button, which never grows past its row.
+  it("a long rule's words wrap on the button, never wider than its row", async () => {
+    const LONG = "Weekly on Monday, Wednesday, Thursday and Friday, until 20-12-2026";
+    mount(monWed, { words: () => LONG });
+    await act(async () => {});
+    expect(trigger().className.split(" ")).toContain("max-w-full");
+    const words = within(trigger()).getByText(LONG);
+    expect(words.className).not.toMatch(/truncate|whitespace-nowrap/);
+    expect(shown()).toBe(LONG);
+  });
+
+  it("a kept rule shows its words; picking a preset replaces it", async () => {
+    const { onChange } = mount({ kind: "kept", words: "Repeats (custom rule)" });
+    await openList();
+    expect(shown()).toBe("Repeats (custom rule)");
+    expect(checked()).toBe(radio("Repeats (custom rule)"));
+    // Clicked again, it changes nothing.
+    fireEvent.click(radio("Repeats (custom rule)"), { detail: 1 });
+    expect(onChange).not.toHaveBeenCalled();
+    await openList();
+    fireEvent.click(radio("Daily"), { detail: 1 });
+    expect(onChange).toHaveBeenCalledWith({ kind: "rule", rule: PRESETS[0].rule });
+    expect(shown()).toBe("Daily");
+    await openList();
+    expect(rows()).not.toContain("Repeats (custom rule)");
+  });
+
+  it("presets still loading never show Does not repeat as picked for a rule", async () => {
+    let arrive: (presets: RepeatPreset[]) => void = () => {};
+    recurrencePresets.mockReturnValue(new Promise<RepeatPreset[]>((r) => (arrive = r)));
+    mount({ kind: "rule", rule: PRESETS[1].rule });
+    await openList();
+    expect(rows()).toEqual(["Does not repeat", "Repeats"]);
+    expect(checked()).toBe(radio("Repeats"));
+    expect(shown()).toBe("Repeats");
+    // They come while the list is open: the rule is its preset's row, and has no other.
+    await act(async () => arrive(PRESETS));
+    expect(rows()).toHaveLength(6);
+    expect(checked()).toBe(radio("Weekly on Tuesday"));
+    expect(shown()).toBe("Weekly on Tuesday");
+    // The row focus was on went with them: focus is on the rule's new row, still in the list.
+    await waitFor(() => expect(document.activeElement).toBe(radio("Weekly on Tuesday")));
+    expect(list()).not.toBeNull();
+  });
+
+  it("presets arriving leave focus where it was in the list", async () => {
+    let arrive: (presets: RepeatPreset[]) => void = () => {};
+    recurrencePresets.mockReturnValue(new Promise<RepeatPreset[]>((r) => (arrive = r)));
+    mount({ kind: "rule", rule: PRESETS[1].rule });
+    await openList();
+    fireEvent.keyDown(checked()!, { key: "Tab" });
+    expect(document.activeElement).toBe(customRow());
+    await act(async () => arrive(PRESETS));
+    expect(rows()).toHaveLength(6);
+    // Custom… is still there: nothing takes focus off it, however long it waits.
+    await act(async () => {
+      await new Promise((r) => setTimeout(r, 10));
+    });
+    expect(document.activeElement).toBe(customRow());
+  });
+});
diff --git a/src/components/calendar/edit/RecurrenceSelect.tsx b/src/components/calendar/edit/RecurrenceSelect.tsx
new file mode 100644
index 00000000..3e31a00f
--- /dev/null
+++ b/src/components/calendar/edit/RecurrenceSelect.tsx
@@ -0,0 +1,243 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// The Repeat menu (#884, C11): a button naming the rule the Repeat value holds, opening a list in
+// Google Calendar's order: "Does not repeat", the ready-made rules for the event's start date and the
+// current rule when it is none of them (in the backend's words), as radios, then "Custom…", a button
+// of its own. Google's Repeat control is a list of this kind too. A native select can't be trusted
+// here: WebKit and Chromium track its changes differently, so it could show a rule the draft didn't
+// hold, or open Custom… on an arrow key passing over it (C11 critique 2 M9).
+//
+// It works as the calendar list does (CalendarPicker). The list stays inside the editor's dialog,
+// where its focus trap and screen readers reach it, and opening puts focus on the rule picked. The
+// arrow keys move the choice within the radios, and the button follows; a click on a row, or Enter,
+// picks and closes. Tab goes from the rules to Custom… and out of the list to the button, as Escape
+// does (closing only the list). Custom… opens its dialog (or, in quick create, the full editor) on a
+// click, Enter or Space, never on an arrow key, since it isn't one of the radios. Disabled (a save on
+// its way), the list closes.
+
+import { useEffect, useId, useRef, useState } from "react";
+import { ONCE, sameRule, type RepeatValue } from "../../../lib/calendarEdit/recurrenceDraft";
+import { Button, Popover, cn } from "../../ui";
+import { usePresets } from "./useRepeat";
+
+interface Props {
+  value: RepeatValue;
+  /** The event's start date (YYYY-MM-DD): the ready-made rules follow it. */
+  startDate: string | null;
+  disabled: boolean;
+  compact?: boolean;
+  /** The words for a rule that isn't a ready-made one (the backend's), shown as its own row. */
+  ruleWords: string | null;
+  onChange: (value: RepeatValue) => void;
+  /** "Custom…" was picked: the parent opens the dialog. The value stays as it was. */
+  onCustom: () => void;
+}
+
+/** A row of the list: its words, and the value picking it gives. */
+interface Row {
+  key: string;
+  words: string;
+  value: RepeatValue;
+}
+
+/** Whether two Repeat values are the same choice. A rule PM can only show is the one the event came
+ *  with, never another. */
+function same(a: RepeatValue, b: RepeatValue): boolean {
+  if (a.kind === "rule" && b.kind === "rule") return sameRule(a.rule, b.rule);
+  return a.kind === b.kind;
+}
+
+/** Focus on the rule picked (else the first), so the keyboard is in the list. */
+function focusPicked(list: HTMLElement | null) {
+  const radio =
+    list?.querySelector<HTMLInputElement>("input[type=radio]:checked") ??
+    list?.querySelector<HTMLInputElement>("input[type=radio]");
+  radio?.focus();
+}
+
+export function RecurrenceSelect({
+  value,
+  startDate,
+  disabled,
+  compact = false,
+  ruleWords,
+  onChange,
+  onCustom,
+}: Props) {
+  const presets = usePresets(startDate);
+  const [open, setOpen] = useState(false);
+  // The rule held when the list opened, when it's none of the ready-made ones. Its row stays while
+  // the list is open, so the arrow keys passing over it can come back to it.
+  const [opened, setOpened] = useState<Row | null>(null);
+  const triggerRef = useRef<HTMLButtonElement>(null);
+  const listRef = useRef<HTMLDivElement>(null);
+  const customRef = useRef<HTMLButtonElement>(null);
+  // A pointer went down on a row: the click that follows is a pick, whatever its `detail` (a click
+  // on the words reaches the radio forwarded by its label, with `detail` 0, as an arrow key's does).
+  // Any key clears it.
+  const pointer = useRef(false);
+  const name = useId();
+  const shown = open && !disabled;
+  const held = shown ? opened : null;
+
+  const isPreset = (v: RepeatValue) =>
+    v.kind === "rule" && !!presets?.some((p) => sameRule(p.rule, v.rule));
+  // A rule that is no ready-made one (or whose ready-made ones are still loading, so it never
+  // flickers to "Does not repeat"), or one PM can only show: its own row. Moved off it, the rule held
+  // when the list opened keeps its row until the list closes.
+  const own: Row | null =
+    value.kind === "once" || isPreset(value)
+      ? held && !isPreset(held.value)
+        ? held
+        : null
+      : {
+          key: "own",
+          value,
+          words:
+            value.kind === "kept"
+              ? value.words
+              : (ruleWords ?? (held && same(held.value, value) ? held.words : "Repeats")),
+        };
+  const rows: Row[] = [
+    { key: "once", words: "Does not repeat", value: ONCE },
+    ...(presets ?? []).map((p, i): Row => ({
+      key: `preset:${i}`,
+      words: p.label,
+      value: { kind: "rule", rule: p.rule },
+    })),
+    ...(own ? [own] : []),
+  ];
+  // The button names the rule held, worked out from the value alone, so it can never show another.
+  const picked = rows.find((r) => same(r.value, value));
+  const label = picked?.words ?? "Repeats";
+
+  // Disabled while open (Ctrl+S with the list up): closed for good, not back by itself after.
+  useEffect(() => {
+    if (disabled) setOpen(false);
+  }, [disabled]);
+
+  // Opened, focus goes to the rule picked, so the keyboard is in the list. After the panel's
+  // measuring frame, which hides it, and a hidden radio can't take focus. The ready-made rules
+  // arriving while it's open can take away the row focus was on (the rule's own row, shown while
+  // they loaded): focus goes back to the rule picked. Anywhere else in the list, it stays.
+  useEffect(() => {
+    if (!shown) return;
+    const t = setTimeout(() => {
+      const list = listRef.current;
+      if (list && !list.contains(document.activeElement)) focusPicked(list);
+    }, 0);
+    return () => clearTimeout(t);
+  }, [shown, presets]);
+
+  /** Open or close the list; opening, keep the rule held if it has a row of its own. */
+  const openList = (next: boolean) => {
+    if (next) setOpened(own);
+    setOpen(next);
+  };
+
+  /** Close, with focus back on the button (the popover's own restore is Escape's). */
+  const done = () => {
+    setOpen(false);
+    triggerRef.current?.focus();
+  };
+
+  return (
+    <Popover
+      open={shown}
+      onOpenChange={openList}
+      escapeClipping
+      withinDialog
+      ariaLabel="Repeat"
+      panelClassName="max-w-sm"
+      trigger={({ open: expanded, toggle }) => (
+        <Button
+          ref={triggerRef}
+          variant="secondary"
+          size={compact ? "xs" : "sm"}
+          aria-label={`Repeat: ${label}`}
+          aria-expanded={expanded}
+          disabled={disabled}
+          // Never wider than its row: a long rule's words wrap.
+          className="max-w-full"
+          onClick={() => {
+            // A click on a Mac leaves focus where it was. The button takes it, so the list's Escape
+            // hands it back here.
+            triggerRef.current?.focus();
+            toggle();
+          }}
+        >
+          <span className="text-left">{label}</span>
+          <span aria-hidden>▾</span>
+        </Button>
+      )}
+    >
+      <div
+        ref={listRef}
+        className={cn(
+          "flex flex-col gap-1 overflow-y-auto",
+          compact ? "max-h-[45vh]" : "max-h-[60vh]",
+        )}
+        onKeyDown={(e) => {
+          pointer.current = false;
+          if (e.key !== "Tab") return;
+          // Tab goes from the rules to Custom…, and Shift+Tab back. Out of either end it leaves the
+          // list for the button it hangs from, rather than for wherever the list sits in the dialog.
+          e.preventDefault();
+          const onCustomRow = e.target === customRef.current;
+          if (!onCustomRow && !e.shiftKey) customRef.current?.focus();
+          else if (onCustomRow && e.shiftKey) focusPicked(listRef.current);
+          else done();
+        }}
+      >
+        <div
+          className="flex flex-col"
+          onKeyDown={(e) => {
+            // Enter picks what the arrow keys moved to, as a click does.
+            if (e.key === "Enter") {
+              e.preventDefault();
+              done();
+            }
+          }}
+        >
+          {rows.map((r) => (
+            <label
+              key={r.key}
+              onPointerDown={() => (pointer.current = true)}
+              className="flex cursor-pointer items-center gap-2 rounded-[var(--radius-sm)] px-2 py-1 text-sm text-ink hover:bg-surface"
+            >
+              <input
+                type="radio"
+                name={name}
+                value={r.key}
+                checked={r === picked}
+                onChange={() => onChange(r.value)}
+                // A pointer's click closes the list; one the arrow keys make (no pointer, so
+                // `detail` 0) only moves the choice.
+                onClick={(e) => {
+                  if (e.detail > 0 || pointer.current) done();
+                }}
+                className="accent-[var(--accent)]"
+              />
+              <span>{r.words}</span>
+            </label>
+          ))}
+        </div>
+        <div className="border-t border-rule pt-1">
+          <button
+            ref={customRef}
+            type="button"
+            // Focus goes back on the button first, so the dialog Custom… opens hands it back there.
+            onClick={() => {
+              done();
+              onCustom();
+            }}
+            className="w-full rounded-[var(--radius-sm)] px-2 py-1 text-left text-sm text-ink hover:bg-surface"
+          >
+            Custom…
+          </button>
+        </div>
+      </div>
+    </Popover>
+  );
+}
diff --git a/src/components/calendar/edit/useRepeat.test.ts b/src/components/calendar/edit/useRepeat.test.ts
new file mode 100644
index 00000000..ecc5b97d
--- /dev/null
+++ b/src/components/calendar/edit/useRepeat.test.ts
@@ -0,0 +1,214 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Repeat row's two reads (#884, C11 §5.2): only the newest answer is ever shown (an older one
+// arriving late describes a start or rule the editor no longer holds), no repeat asks nothing, and a
+// read that fails says so in words rather than crashing or looking fine.
+
+import { act, cleanup, renderHook } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RepeatPreset, RepeatRule, RepeatStart, RepeatView } from "../../../lib/types";
+import type { RepeatValue } from "../../../lib/calendarEdit/recurrenceDraft";
+
+const recurrencePresets = vi.fn<(day: string) => Promise<RepeatPreset[]>>();
+const describeRecurrence = vi.fn<(rule: RepeatRule, start: RepeatStart) => Promise<RepeatView>>();
+
+vi.mock("../../../lib/ipc", () => ({
+  recurrencePresets: (day: string) => recurrencePresets(day),
+  describeRecurrence: (rule: RepeatRule, start: RepeatStart) => describeRecurrence(rule, start),
+}));
+
+import { REPEAT_UNCHECKED, usePresets, useRepeatView } from "./useRepeat";
+
+afterEach(() => {
+  cleanup();
+  vi.resetAllMocks();
+});
+
+/** A promise the test answers when it chooses. */
+function later<T>() {
+  let answer: (v: T) => void = () => {};
+  let fail: (e: Error) => void = () => {};
+  const promise = new Promise<T>((resolve, reject) => {
+    answer = resolve;
+    fail = reject;
+  });
+  return { promise, answer, fail };
+}
+
+const weekly = (day: "mon" | "tue" | "wed"): RepeatRule => ({
+  pattern: { kind: "weekly", days: [day] },
+  interval: 1,
+  ends: { kind: "never" },
+});
+const preset = (label: string, rule: RepeatRule): RepeatPreset => ({ label, rule });
+const at = (date: string): RepeatStart => ({
+  kind: "timed",
+  date,
+  time: "09:00",
+  zone: "Europe/London",
+});
+const ruleOf = (rule: RepeatRule): RepeatValue => ({ kind: "rule", rule });
+
+describe("usePresets", () => {
+  it("a stale presets answer never replaces a later one", async () => {
+    const tuesday = later<RepeatPreset[]>();
+    const wednesday = later<RepeatPreset[]>();
+    recurrencePresets.mockImplementation((day) =>
+      day === "2026-10-13" ? tuesday.promise : wednesday.promise,
+    );
+    const { result, rerender } = renderHook(({ day }) => usePresets(day), {
+      initialProps: { day: "2026-10-13" as string | null },
+    });
+    expect(result.current).toBeNull();
+    rerender({ day: "2026-10-14" });
+    await act(async () => wednesday.answer([preset("Weekly on Wednesday", weekly("wed"))]));
+    expect(result.current?.map((p) => p.label)).toEqual(["Weekly on Wednesday"]);
+    // Tuesday's answer, arriving last, is for a day the event no longer starts on.
+    await act(async () => tuesday.answer([preset("Weekly on Tuesday", weekly("tue"))]));
+    expect(result.current?.map((p) => p.label)).toEqual(["Weekly on Wednesday"]);
+    expect(recurrencePresets.mock.calls).toEqual([["2026-10-13"], ["2026-10-14"]]);
+  });
+
+  it("another day's presets are loading until its own come, and no day asks nothing", async () => {
+    recurrencePresets.mockResolvedValueOnce([preset("Daily", weekly("tue"))]);
+    recurrencePresets.mockReturnValueOnce(later<RepeatPreset[]>().promise);
+    const { result, rerender } = renderHook(({ day }) => usePresets(day), {
+      initialProps: { day: "2026-10-13" as string | null },
+    });
+    await act(async () => {});
+    expect(result.current).toHaveLength(1);
+    rerender({ day: "2026-10-14" });
+    expect(result.current).toBeNull();
+    rerender({ day: null });
+    expect(result.current).toBeNull();
+    expect(recurrencePresets).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("useRepeatView", () => {
+  it("a stale view answer never replaces a later one", async () => {
+    const first = later<RepeatView>();
+    const second = later<RepeatView>();
+    describeRecurrence.mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
+    const { result, rerender } = renderHook(
+      ({ value, start }) => useRepeatView(value, start).state,
+      { initialProps: { value: ruleOf(weekly("mon")), start: at("2026-10-13") } },
+    );
+    expect(result.current).toEqual({ state: "loading" });
+    rerender({ value: ruleOf(weekly("wed")), start: at("2026-10-13") });
+    await act(async () =>
+      second.answer({
+        outcome: "ready",
+        summary: "Weekly on Wednesday",
+        starts: "2026-10-14",
+        moved: true,
+      }),
+    );
+    expect(result.current).toEqual({
+      state: "ready",
+      summary: "Weekly on Wednesday",
+      starts: "2026-10-14",
+      moved: true,
+    });
+    await act(async () =>
+      first.answer({
+        outcome: "ready",
+        summary: "Weekly on Monday",
+        starts: "2026-10-19",
+        moved: true,
+      }),
+    );
+    expect(result.current).toMatchObject({ summary: "Weekly on Wednesday" });
+    expect(describeRecurrence.mock.calls).toEqual([
+      [weekly("mon"), at("2026-10-13")],
+      [weekly("wed"), at("2026-10-13")],
+    ]);
+  });
+
+  it("once and kept ask nothing", async () => {
+    const { result, rerender } = renderHook(
+      ({ value }) => useRepeatView(value, at("2026-10-13")).state,
+      { initialProps: { value: { kind: "once" } as RepeatValue } },
+    );
+    expect(result.current).toEqual({ state: "none" });
+    rerender({ value: { kind: "kept", words: "Repeats" } });
+    expect(result.current).toEqual({ state: "none" });
+    await act(async () => {});
+    expect(describeRecurrence).not.toHaveBeenCalled();
+  });
+
+  it("a thrown read is refused in words", async () => {
+    describeRecurrence.mockRejectedValueOnce(new Error("channel closed"));
+    const { result, rerender } = renderHook(
+      ({ value }) => useRepeatView(value, at("2026-10-13")).state,
+      { initialProps: { value: ruleOf(weekly("tue")) } },
+    );
+    await act(async () => {});
+    expect(result.current).toEqual({ state: "refused", message: REPEAT_UNCHECKED });
+    expect(REPEAT_UNCHECKED).toBe("PM couldn't check this repeat. Try again.");
+    // A throw before the read even returns a promise reads the same way.
+    describeRecurrence.mockImplementationOnce(() => {
+      throw new Error("no backend");
+    });
+    rerender({ value: ruleOf(weekly("wed")) });
+    await act(async () => {});
+    expect(result.current).toEqual({ state: "refused", message: REPEAT_UNCHECKED });
+  });
+
+  it("says the backend's refusal as it is", async () => {
+    describeRecurrence.mockResolvedValueOnce({
+      outcome: "refused",
+      message: "Google allows at most 730 occurrences of a repeating event.",
+    });
+    const { result } = renderHook(
+      () => useRepeatView(ruleOf(weekly("tue")), at("2026-10-13")).state,
+    );
+    await act(async () => {});
+    expect(result.current).toEqual({
+      state: "refused",
+      message: "Google allows at most 730 occurrences of a repeating event.",
+    });
+  });
+
+  // A save reads its draft as it is then: a start the blur before it just committed hasn't been asked
+  // about, so the last answer, for the start before, says nothing of it.
+  it("a save may go only on a ready answer for exactly its rule and start", async () => {
+    const pending = later<RepeatView>();
+    describeRecurrence
+      .mockResolvedValueOnce({
+        outcome: "ready",
+        summary: "Weekly on Tuesday",
+        starts: "2026-10-13",
+        moved: false,
+      })
+      .mockReturnValueOnce(pending.promise);
+    const { result, rerender } = renderHook(
+      ({ start }) => useRepeatView(ruleOf(weekly("tue")), start),
+      {
+        initialProps: { start: at("2026-10-13") },
+      },
+    );
+    const { saveable } = result.current;
+    expect(saveable(ruleOf(weekly("tue")), at("2026-10-13"))).toBe(false);
+    await act(async () => {});
+    expect(saveable(ruleOf(weekly("tue")), at("2026-10-13"))).toBe(true);
+    // Another start, or another rule: not asked yet.
+    expect(saveable(ruleOf(weekly("tue")), at("2026-10-20"))).toBe(false);
+    expect(saveable(ruleOf(weekly("wed")), at("2026-10-13"))).toBe(false);
+    // No repeat needs nothing.
+    expect(saveable({ kind: "once" }, at("2026-10-20"))).toBe(true);
+    rerender({ start: at("2026-10-20") });
+    expect(result.current.saveable(ruleOf(weekly("tue")), at("2026-10-20"))).toBe(false);
+    await act(async () =>
+      pending.answer({
+        outcome: "refused",
+        message: "The end date is before the first occurrence.",
+      }),
+    );
+    expect(result.current.saveable(ruleOf(weekly("tue")), at("2026-10-20"))).toBe(false);
+    expect(result.current.saveable).toBe(saveable);
+  });
+});
diff --git a/src/components/calendar/edit/useRepeat.ts b/src/components/calendar/edit/useRepeat.ts
new file mode 100644
index 00000000..0be7d10a
--- /dev/null
+++ b/src/components/calendar/edit/useRepeat.ts
@@ -0,0 +1,106 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// The Repeat row's two reads (#884, C11): the repeat menu's ready-made rules for the event's start
+// date, and what the backend says of the chosen rule at the event's start (its words, the day it
+// really starts on, or why it can't be saved). Both are pure on the backend and cheap, so they're
+// asked on every change, undebounced; only the newest answer is ever shown, since an older one
+// arriving late describes a start or rule the editor no longer holds.
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { describeRecurrence, recurrencePresets } from "../../../lib/ipc";
+import type { RepeatPreset, RepeatRule, RepeatStart } from "../../../lib/types";
+import type { RepeatValue } from "../../../lib/calendarEdit/recurrenceDraft";
+
+/** What the backend says of the Repeat row's rule. `none`: no repeat (or one PM can only show), so
+ *  nothing to ask. */
+export type RepeatState =
+  | { state: "none" }
+  | { state: "loading" }
+  | { state: "ready"; summary: string; starts: string; moved: boolean }
+  | { state: "refused"; message: string };
+
+/** Said when the read itself failed, rather than a crash or a rule that looks fine. */
+export const REPEAT_UNCHECKED = "PM couldn't check this repeat. Try again.";
+
+/** `ask()`, with a throw before it returns a promise read as a failed promise. */
+function attempt<T>(ask: () => Promise<T>): Promise<T> {
+  return new Promise<T>((resolve) => resolve(ask()));
+}
+
+/** What a rule at a start is asked as (the key both the read and a save compare), or null when
+ *  there's nothing to ask: no repeat, one PM can only show, or no start yet. */
+function repeatAsk(value: RepeatValue, start: RepeatStart | null): string | null {
+  return value.kind === "rule" && start ? JSON.stringify([value.rule, start]) : null;
+}
+
+/** The Repeat row's rule as the backend sees it, and a save's way to ask the same. */
+export interface RepeatCheck {
+  state: RepeatState;
+  /** Whether the newest answer says `value` at `start` can be saved: no repeat, or a rule the backend
+   *  called ready at exactly that start. A save reads its draft as it is then (a date the blur before
+   *  it just committed is a start not yet asked about), so it asks this rather than `state`, which
+   *  is the last render's. */
+  saveable: (value: RepeatValue, start: RepeatStart | null) => boolean;
+}
+
+/** The repeat menu's ready-made rules for `day` (YYYY-MM-DD), newest answer only; null while
+ *  loading or with no day. A failed read gives none: the menu still has "Does not repeat" and
+ *  "Custom…". */
+export function usePresets(day: string | null): RepeatPreset[] | null {
+  const [answer, setAnswer] = useState<{ day: string; presets: RepeatPreset[] } | null>(null);
+  const seq = useRef(0);
+  useEffect(() => {
+    const mine = ++seq.current;
+    if (!day) return;
+    const apply = (presets: RepeatPreset[]) => {
+      if (seq.current === mine) setAnswer({ day, presets });
+    };
+    attempt(() => recurrencePresets(day)).then(
+      (presets) => apply(Array.isArray(presets) ? presets : []),
+      () => apply([]),
+    );
+  }, [day]);
+  // Another day's presets aren't this day's: loading until its own answer.
+  return day && answer?.day === day ? answer.presets : null;
+}
+
+/** What the backend says of `value` at `start`: its words, the day it really starts on, or why it
+ *  can't be saved. Loading until the answer for exactly this rule and start arrives. */
+export function useRepeatView(value: RepeatValue, start: RepeatStart | null): RepeatCheck {
+  const ask = repeatAsk(value, start);
+  const [answer, setAnswer] = useState<{ ask: string; state: RepeatState } | null>(null);
+  // The same answer, readable at once by a save in the middle of an event.
+  const answerRef = useRef<{ ask: string; state: RepeatState } | null>(null);
+  const seq = useRef(0);
+  useEffect(() => {
+    const mine = ++seq.current;
+    if (ask === null) return;
+    const [rule, at] = JSON.parse(ask) as [RepeatRule, RepeatStart];
+    const apply = (state: RepeatState) => {
+      if (seq.current !== mine) return;
+      answerRef.current = { ask, state };
+      setAnswer(answerRef.current);
+    };
+    const unchecked: RepeatState = { state: "refused", message: REPEAT_UNCHECKED };
+    attempt(() => describeRecurrence(rule, at)).then(
+      (view) =>
+        apply(
+          view?.outcome === "ready"
+            ? { state: "ready", summary: view.summary, starts: view.starts, moved: view.moved }
+            : view?.outcome === "refused"
+              ? { state: "refused", message: view.message }
+              : unchecked,
+        ),
+      () => apply(unchecked),
+    );
+  }, [ask]);
+  const saveable = useCallback((v: RepeatValue, s: RepeatStart | null) => {
+    const asked = repeatAsk(v, s);
+    const got = answerRef.current;
+    return asked === null || (got !== null && got.ask === asked && got.state.state === "ready");
+  }, []);
+  const state: RepeatState =
+    ask === null ? { state: "none" } : answer?.ask === ask ? answer.state : { state: "loading" };
+  return { state, saveable };
+}
diff --git a/src/lib/calendar-layout.test.ts b/src/lib/calendar-layout.test.ts
index 204d286b..9e002bdb 100644
--- a/src/lib/calendar-layout.test.ts
+++ b/src/lib/calendar-layout.test.ts
@@ -216,6 +216,7 @@ describe("the new event's ghost (C10c)", () => {
       end_time: "10:30",
       end_zone: "America/New_York",
     },
+    recurrence: { kind: "once" },
     show_as: "busy",
     visibility: "default",
   };
diff --git a/src/lib/calendarEdit/createTargets.test.ts b/src/lib/calendarEdit/createTargets.test.ts
index bcbcf681..4780d4af 100644
--- a/src/lib/calendarEdit/createTargets.test.ts
+++ b/src/lib/calendarEdit/createTargets.test.ts
@@ -211,20 +211,20 @@ describe("outsideMirror", () => {
     last_day: last,
   });
 
-  it("outsideMirror reads both edges", () => {
-    // Ends exactly at the window's start: outside. A minute into it: inside.
-    expect(outsideMirror(timed("2026-09-30T23:00", "2026-10-01T00:00"), o)).toBe(true);
-    expect(outsideMirror(timed("2026-09-30T23:00", "2026-10-01T00:01"), o)).toBe(false);
-    // Starts exactly at the window's end: outside. A minute before: inside.
-    expect(outsideMirror(timed("2026-12-01T00:00", "2026-12-01T01:00"), o)).toBe(true);
-    expect(outsideMirror(timed("2026-11-30T23:59", "2026-12-01T01:00"), o)).toBe(false);
+  it("outsideMirror reads both edges, and which side it's on", () => {
+    // Ends exactly at the window's start: outside, before it. A minute into it: inside.
+    expect(outsideMirror(timed("2026-09-30T23:00", "2026-10-01T00:00"), o)).toBe("before");
+    expect(outsideMirror(timed("2026-09-30T23:00", "2026-10-01T00:01"), o)).toBeNull();
+    // Starts exactly at the window's end: outside, after it. A minute before: inside.
+    expect(outsideMirror(timed("2026-12-01T00:00", "2026-12-01T01:00"), o)).toBe("after");
+    expect(outsideMirror(timed("2026-11-30T23:59", "2026-12-01T01:00"), o)).toBeNull();
     // All day: the last day before the end is in; the day the window ends on is out.
-    expect(outsideMirror(allDay("2026-11-30", "2026-11-30"), o)).toBe(false);
-    expect(outsideMirror(allDay("2026-12-01", "2026-12-01"), o)).toBe(true);
-    expect(outsideMirror(allDay("2026-09-30", "2026-09-30"), o)).toBe(true);
-    expect(outsideMirror(allDay("2026-09-30", "2026-10-01"), o)).toBe(false);
+    expect(outsideMirror(allDay("2026-11-30", "2026-11-30"), o)).toBeNull();
+    expect(outsideMirror(allDay("2026-12-01", "2026-12-01"), o)).toBe("after");
+    expect(outsideMirror(allDay("2026-09-30", "2026-09-30"), o)).toBe("before");
+    expect(outsideMirror(allDay("2026-09-30", "2026-10-01"), o)).toBeNull();
     // Far ahead: the probe's 13+ months out.
-    expect(outsideMirror(allDay("2028-01-01", "2028-01-01"), o)).toBe(true);
+    expect(outsideMirror(allDay("2028-01-01", "2028-01-01"), o)).toBe("after");
   });
 
   it("says nothing about a time it can't read", () => {
@@ -233,10 +233,10 @@ describe("outsideMirror", () => {
         { ...timed("2028-01-01T10:00", "2028-01-01T11:00"), start_zone: "Nowhere/Here" },
         o,
       ),
-    ).toBe(false);
+    ).toBeNull();
     expect(
       outsideMirror(timed("2028-01-01T10:00", "2028-01-01T11:00"), { ...o, mirror_end: "" }),
-    ).toBe(false);
+    ).toBeNull();
   });
 });
 
@@ -271,20 +271,41 @@ describe("createNotes", () => {
   it("says before Save when PM won't show the event: outside the months it syncs, or hidden", () => {
     const o = overview();
     const day = (d: string) => ({ kind: "all_day" as const, first_day: d, last_day: d });
-    expect(createNotes(day("2026-10-12"), o, new Set(), `${ME}:alpha`)).toEqual([]);
+    expect(createNotes(day("2026-10-12"), false, o, new Set(), `${ME}:alpha`)).toEqual([]);
     // The window's ends as this computer's dates, DD-MM.
     const range = `${formatDateLocal(new Date(o.mirror_start))} – ${formatDateLocal(new Date(o.mirror_end))}`;
-    expect(createNotes(day("2028-01-01"), o, new Set(), `${ME}:alpha`)).toEqual([
+    expect(createNotes(day("2028-01-01"), false, o, new Set(), `${ME}:alpha`)).toEqual([
       `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
     ]);
-    expect(createNotes(day("2026-10-12"), o, new Set([`${ME}:alpha`]), `${ME}:alpha`)).toEqual([
+    expect(
+      createNotes(day("2026-10-12"), false, o, new Set([`${ME}:alpha`]), `${ME}:alpha`),
+    ).toEqual([
       "Alpha is hidden in your calendar list, so the new event won't show until you show that calendar again.",
     ]);
     // A twin on show will show it, so there's nothing to say.
     const twin = calendar(OFF, "alpha", { name: "Alpha (shared)" });
     const withTwin = overview({ calendars: [...o.calendars, twin] });
     expect(
-      createNotes(day("2026-10-12"), withTwin, new Set([`${ME}:alpha`]), `${ME}:alpha`),
+      createNotes(day("2026-10-12"), false, withTwin, new Set([`${ME}:alpha`]), `${ME}:alpha`),
     ).toEqual([]);
   });
+
+  // The backend lands a repeating event's occurrences inside the months PM syncs, whenever it
+  // starts; only one that starts after them has none there.
+  it("a repeating event from before the months PM syncs shows inside them", () => {
+    const o = overview();
+    const day = (d: string) => ({ kind: "all_day" as const, first_day: d, last_day: d });
+    const range = `${formatDateLocal(new Date(o.mirror_start))} – ${formatDateLocal(new Date(o.mirror_end))}`;
+    expect(createNotes(day("2020-01-06"), true, o, new Set(), `${ME}:alpha`)).toEqual([
+      `This starts before the months PM syncs (${range}), so only its occurrences within them will show here.`,
+    ]);
+    // Once, it won't show at all.
+    expect(createNotes(day("2020-01-06"), false, o, new Set(), `${ME}:alpha`)).toEqual([
+      `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
+    ]);
+    // After them, repeating or not, none of it does.
+    expect(createNotes(day("2028-01-03"), true, o, new Set(), `${ME}:alpha`)).toEqual([
+      `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
+    ]);
+  });
 });
diff --git a/src/lib/calendarEdit/createTargets.ts b/src/lib/calendarEdit/createTargets.ts
index 6604adc2..6c515b7c 100644
--- a/src/lib/calendarEdit/createTargets.ts
+++ b/src/lib/calendarEdit/createTargets.ts
@@ -116,14 +116,18 @@ export function lengthFor(overview: CalendarOverview, target: CreateTarget | nul
 /** `date` (`YYYY-MM-DD`) at UTC midnight, moved by `days`, as ms. */
 const utcDay = (date: string, days = 0) => Date.parse(`${date}T00:00:00Z`) + days * 86_400_000;
 
-/** Whether a new event's time falls wholly outside the months PM mirrors, so it would be saved in
- *  Google but not shown here: the backend's own overlap test (start before the window's end, end
- *  after its start; all-day days as UTC midnights, the last one exclusive). The backend decides; this
- *  is the warning before Save. A time that can't be read says nothing: the problem lines do. */
-export function outsideMirror(time: TimeDraft, overview: CalendarOverview): boolean {
+/** Which side of the months PM mirrors a new event's time falls wholly on, so it would be saved in
+ *  Google but not shown here, or null when it overlaps them: the backend's own overlap test (start
+ *  before the window's end, end after its start; all-day days as UTC midnights, the last one
+ *  exclusive). The backend decides; this is the warning before Save. A time that can't be read says
+ *  nothing: the problem lines do. */
+export function outsideMirror(
+  time: TimeDraft,
+  overview: CalendarOverview,
+): "before" | "after" | null {
   const from = Date.parse(overview.mirror_start);
   const until = Date.parse(overview.mirror_end);
-  if (Number.isNaN(from) || Number.isNaN(until)) return false;
+  if (Number.isNaN(from) || Number.isNaN(until)) return null;
   let start: number;
   let end: number;
   if (time.kind === "all_day") {
@@ -131,12 +135,13 @@ export function outsideMirror(time: TimeDraft, overview: CalendarOverview): bool
     end = utcDay(time.last_day, 1);
   } else {
     const s = wallInstant(time.start_date, time.start_time, time.start_zone);
-    if (s === null) return false;
+    if (s === null) return null;
     start = s.getTime();
     end = wallInstant(time.end_date, time.end_time, time.end_zone)?.getTime() ?? start;
   }
-  if (Number.isNaN(start) || Number.isNaN(end)) return false;
-  return !(start < until && end > from);
+  if (Number.isNaN(start) || Number.isNaN(end)) return null;
+  if (start >= until) return "after";
+  return end <= from ? "before" : null;
 }
 
 /** Where a new event on `calendarId` shows (C10 §15): its name, and whether PM's calendar keeps it
@@ -163,20 +168,26 @@ export function createdWhere(
 }
 
 /** What a new event's surfaces (the full editor and quick create) say before Save (C10 §15): a start
- *  outside the months PM syncs, and a calendar hidden here with no twin showing it. */
+ *  outside the months PM syncs, and a calendar hidden here with no twin showing it. One that
+ *  `repeats` from before those months still shows here wherever it falls inside them, as the backend
+ *  lists and lands those (C11); one that starts after them has none there. */
 export function createNotes(
   time: TimeDraft,
+  repeats: boolean,
   overview: CalendarOverview,
   hidden: ReadonlySet<string>,
   calendarId: string,
 ): string[] {
   const notes: string[] = [];
-  if (outsideMirror(time, overview)) {
+  const side = outsideMirror(time, overview);
+  if (side !== null) {
     const range = `${formatDateLocal(new Date(overview.mirror_start))} – ${formatDateLocal(
       new Date(overview.mirror_end),
     )}`;
     notes.push(
-      `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
+      side === "before" && repeats
+        ? `This starts before the months PM syncs (${range}), so only its occurrences within them will show here.`
+        : `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
     );
   }
   const where = createdWhere(overview, hidden, calendarId);
diff --git a/src/lib/calendarEdit/editReasons.ts b/src/lib/calendarEdit/editReasons.ts
index 18ea548f..8f19ba93 100644
--- a/src/lib/calendarEdit/editReasons.ts
+++ b/src/lib/calendarEdit/editReasons.ts
@@ -57,6 +57,9 @@ export function fieldLabel(field: EditorField): string {
       return "title";
     case "time":
       return "time";
+    // Google's word for it.
+    case "recurrence":
+      return "repeat";
     case "location":
       return "location";
     case "description":
diff --git a/src/lib/calendarEdit/eventDraft.test.ts b/src/lib/calendarEdit/eventDraft.test.ts
index e8b87a6d..4d3ef353 100644
--- a/src/lib/calendarEdit/eventDraft.test.ts
+++ b/src/lib/calendarEdit/eventDraft.test.ts
@@ -5,7 +5,7 @@
 
 import { describe, expect, it } from "vitest";
 
-import type { EventForEdit, FieldPermissions, TimeDraft } from "../types";
+import type { DayCode, EventForEdit, FieldPermissions, RepeatRule, TimeDraft } from "../types";
 import {
   NEW_EVENT_BASE,
   allDayOf,
@@ -17,6 +17,7 @@ import {
   endTimeChoices,
   endsAfterStart,
   firstEndOnItsDate,
+  followStart,
   halfInstant,
   newEventSeed,
   rebaseDraft,
@@ -105,6 +106,9 @@ describe("the event draft", () => {
     };
     expect(canEdit(perms, "summary")).toBe(false);
     expect(canEdit(perms, "show_as")).toBe(true);
+    // How it repeats goes with the time: Google locks both together.
+    expect(canEdit(perms, "recurrence")).toBe(false);
+    expect(canEdit({ ...perms, time: true }, "recurrence")).toBe(true);
   });
 });
 
@@ -457,6 +461,7 @@ describe("a new event's starting fields", () => {
       location: "",
       description: "Bring the form",
       time: timed("2026-10-12", "09:00", "2026-10-12", "10:00"),
+      recurrence: { kind: "once" },
       show_as: "free",
       visibility: "private",
     };
@@ -474,6 +479,60 @@ describe("a new event's starting fields", () => {
     expect(sent.time).not.toBe(draft.time);
   });
 
+  // --- repeating (C11) ---
+
+  const weeklyOn = (...days: DayCode[]): RepeatRule => ({
+    pattern: { kind: "weekly", days },
+    interval: 1,
+    ends: { kind: "never" },
+  });
+
+  it("toNewEvent sends the chosen repeat as a copy, and Does not repeat as null", () => {
+    const days: DayCode[] = ["mon", "wed"];
+    const rule: RepeatRule = { ...weeklyOn(), pattern: { kind: "weekly", days } };
+    const draft: EditorFields = {
+      ...NEW_EVENT_BASE,
+      time: timed("2026-10-13", "09:00", "2026-10-13", "10:00"),
+      recurrence: { kind: "rule", rule },
+    };
+    const sent = toNewEvent(draft);
+    expect(sent.recurrence).toEqual(rule);
+    // What was sent is kept for a retry: nothing the draft holds can change it.
+    days.push("fri");
+    expect(sent.recurrence).toEqual(weeklyOn("mon", "wed"));
+    expect(toNewEvent({ ...draft, recurrence: { kind: "once" } }).recurrence).toBeNull();
+    // A new event's seed doesn't repeat.
+    expect(newEventSeed("2026-10-13", new Date(), "Europe/London", HOUR).recurrence).toEqual({
+      kind: "once",
+    });
+  });
+
+  it("a changed repeat is a change, and a moved start takes the rule's own day with it", () => {
+    const tuesday: EditorFields = {
+      ...NEW_EVENT_BASE,
+      time: timed("2026-10-13", "09:00", "2026-10-13", "10:00"),
+      recurrence: { kind: "rule", rule: weeklyOn("tue") },
+    };
+    expect(changedFields(NEW_EVENT_BASE, tuesday)).toContain("recurrence");
+    // The same rule with its days in another order is no change.
+    const both = {
+      ...tuesday,
+      recurrence: { kind: "rule" as const, rule: weeklyOn("mon", "tue") },
+    };
+    expect(
+      changedFields(both, { ...both, recurrence: { kind: "rule", rule: weeklyOn("tue", "mon") } }),
+    ).toEqual([]);
+    // Weekly on Tuesday, started on a Tuesday, moved to Wednesday: weekly on Wednesday.
+    const moved = followStart(tuesday, {
+      ...tuesday,
+      time: timed("2026-10-14", "09:00", "2026-10-14", "10:00"),
+    });
+    expect(moved.recurrence).toEqual({ kind: "rule", rule: weeklyOn("wed") });
+    // Two days chosen don't come from the start: they stay.
+    const kept = { ...both, time: timed("2026-10-14", "09:00", "2026-10-14", "10:00") };
+    expect(followStart(both, kept)).toBe(kept);
+  });
+
   it("switchNewKind keeps the day and length and follows Google's free/busy until touched", () => {
     const seed = newEventSeed(
       "2026-10-12",
diff --git a/src/lib/calendarEdit/eventDraft.ts b/src/lib/calendarEdit/eventDraft.ts
index 4c432280..4e27abfa 100644
--- a/src/lib/calendarEdit/eventDraft.ts
+++ b/src/lib/calendarEdit/eventDraft.ts
@@ -12,7 +12,8 @@
 // changed the same field, where Google's value wins and the editor says so.
 //
 // Creating an event uses the same fields: `newEventSeed` starts one, it's judged against
-// `NEW_EVENT_BASE` (nothing to keep, so every half is checked), and `toNewEvent` sends all of it.
+// `NEW_EVENT_BASE` (nothing to keep, so every half is checked), and `toNewEvent` sends all of it,
+// its repeat included (C11).
 
 import type {
   EventForEdit,
@@ -24,6 +25,14 @@ import type {
   TimeDraft,
 } from "../types";
 import { resolveWallTime, wallInstant, wallTimeOf } from "../wallTime";
+import {
+  copyRule,
+  followStartDate,
+  ONCE,
+  sameRepeat,
+  startDateOf,
+  type RepeatValue,
+} from "./recurrenceDraft";
 import { durationLabel, timeChoices } from "./timeSlots";
 
 /** What the editor's fields hold. */
@@ -32,6 +41,8 @@ export interface EditorFields {
   location: string;
   description: string;
   time: TimeDraft;
+  /** How it repeats: the Repeat row, which only creating draws so far. */
+  recurrence: RepeatValue;
   show_as: ShowAs;
   visibility: EventVisibility;
 }
@@ -42,19 +53,23 @@ export type EditorField = keyof EditorFields;
 export const EDITOR_FIELDS: readonly EditorField[] = [
   "summary",
   "time",
+  "recurrence",
   "location",
   "description",
   "show_as",
   "visibility",
 ];
 
-/** The editor's starting fields: Google's copy as it is. */
+/** The editor's starting fields: Google's copy as it is. Its repeat starts as "Does not repeat",
+ *  even for an occurrence of a repeating event: the editor has no Repeat row for an existing event
+ *  yet, so nothing reads it and nothing can change it. */
 export function seedDraft(event: EventForEdit): EditorFields {
   return {
     summary: event.summary,
     location: event.location,
     description: event.description,
     time: { ...event.time },
+    recurrence: ONCE,
     show_as: event.show_as,
     visibility: event.visibility,
   };
@@ -91,6 +106,8 @@ export function sameField(field: EditorField, a: EditorFields, b: EditorFields):
       return sameText(a[field], b[field]);
     case "time":
       return sameTime(a.time, b.time);
+    case "recurrence":
+      return sameRepeat(a.recurrence, b.recurrence);
     case "show_as":
     case "visibility":
       return a[field] === b[field];
@@ -115,6 +132,9 @@ export function toChanges(base: EditorFields, draft: EditorFields): EventPatchDr
       case "time":
         changes.time = { ...draft.time };
         break;
+      // An existing event's repeat can't change yet (`seedDraft`), so there is none to send.
+      case "recurrence":
+        break;
       case "show_as":
         changes.show_as = draft.show_as;
         break;
@@ -126,9 +146,10 @@ export function toChanges(base: EditorFields, draft: EditorFields): EventPatchDr
   return changes;
 }
 
-/** Whether the editor may change `field` (the permission names match the fields). */
+/** Whether the editor may change `field` (the permission names match the fields). How it repeats is
+ *  the time's right: Google locks `recurrence` exactly when it locks the start. */
 export function canEdit(permissions: FieldPermissions, field: EditorField): boolean {
-  return permissions[field];
+  return field === "recurrence" ? permissions.time : permissions[field];
 }
 
 /** Something that stops a save before it is sent. */
@@ -445,6 +466,7 @@ export const NEW_EVENT_BASE: EditorFields = {
   location: "",
   description: "",
   time: { kind: "all_day", first_day: "", last_day: "" },
+  recurrence: ONCE,
   show_as: "busy",
   visibility: "default",
 };
@@ -466,15 +488,22 @@ function firstShown(date: string, time: string, zone: string): string | null {
 /** A new event's starting fields, on `day` (`YYYY-MM-DD`, in `zone`): on today the next half hour
  *  strictly after `now` (14:10 → 14:30, 14:30 → 15:00, 23:40 → 00:00 the next day), on any other day
  *  09:00, stepping past a time the clocks skip; `lengthMs` long (`endAfterStart`, so a repeated hour
- *  never gives an end before the start). Busy, the calendar's default visibility. With no zone at all
- *  there's no time to show, so it starts as an all-day event on `day`, free as Google's are. */
+ *  never gives an end before the start). Busy, the calendar's default visibility, not repeating. With
+ *  no zone at all there's no time to show, so it starts as an all-day event on `day`, free as
+ *  Google's are. */
 export function newEventSeed(
   day: string,
   now: Date,
   zone: string | null,
   lengthMs: number,
 ): EditorFields {
-  const fields = { summary: "", location: "", description: "", visibility: "default" as const };
+  const fields = {
+    summary: "",
+    location: "",
+    description: "",
+    recurrence: ONCE,
+    visibility: "default" as const,
+  };
   if (zone === null) {
     return { ...fields, time: { kind: "all_day", first_day: day, last_day: day }, show_as: "free" };
   }
@@ -546,8 +575,19 @@ export function switchNewKind(
   };
 }
 
-/** What creating an event sends: every field, as the editor holds it. The editor has no repeat menu
- *  yet, so nothing it creates repeats. */
+/** `next`, a draft whose time just changed from `was`'s, with its rule following the start date
+ *  (`followStartDate`): weekly on the old start's weekday becomes weekly on the new one's, and so on
+ *  for a rule whose day came from the start. */
+export function followStart(was: EditorFields, next: EditorFields): EditorFields {
+  const r = next.recurrence;
+  if (r.kind !== "rule") return next;
+  const rule = followStartDate(r.rule, startDateOf(was.time), startDateOf(next.time));
+  return rule === r.rule ? next : { ...next, recurrence: { kind: "rule", rule } };
+}
+
+/** What creating an event sends: every field, as the editor holds it, sharing nothing with the draft
+ *  (what was sent is kept for a retry, and must not change with it). Its repeat is the rule chosen,
+ *  or null for "Does not repeat"; the backend starts it on the first day the rule makes. */
 export function toNewEvent(draft: EditorFields): NewEventDraft {
   return {
     summary: draft.summary,
@@ -556,7 +596,8 @@ export function toNewEvent(draft: EditorFields): NewEventDraft {
     description: draft.description,
     show_as: draft.show_as,
     visibility: draft.visibility,
-    recurrence: null,
+    // A rule PM can only show (`kept`) belongs to an existing event, never a new one.
+    recurrence: draft.recurrence.kind === "rule" ? copyRule(draft.recurrence.rule) : null,
   };
 }
 
@@ -570,6 +611,9 @@ function setField(target: EditorFields, field: EditorField, from: EditorFields)
     case "time":
       target.time = { ...from.time };
       break;
+    case "recurrence":
+      target.recurrence = from.recurrence;
+      break;
     case "show_as":
       target.show_as = from.show_as;
       break;
diff --git a/src/lib/calendarEdit/recurrenceDraft.test.ts b/src/lib/calendarEdit/recurrenceDraft.test.ts
new file mode 100644
index 00000000..6d0bb754
--- /dev/null
+++ b/src/lib/calendarEdit/recurrenceDraft.test.ts
@@ -0,0 +1,321 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// The Repeat row's value and the Custom dialog's fields (#884, C11 §4): every T2 rule (the shared
+// fixture Rust holds to the same table) round-trips through the dialog's fields, the dialog refuses
+// what the backend refuses in the backend's own words, its monthly choices are Google's for the start
+// date, and a rule whose day came from the start date follows the start when it moves.
+
+import { describe, expect, it } from "vitest";
+import fixture from "./repeatRules.fixture.json";
+import type { DayCode, RepeatRule } from "../types";
+import {
+  formatDayMonth,
+  formFromRule,
+  followStartDate,
+  monthlyChoices,
+  monthlyLabel,
+  movedStartText,
+  repeatProblemText,
+  repeatStartOf,
+  ruleFromForm,
+  sameRepeat,
+  sameRule,
+  yearlyLabel,
+  type RepeatForm,
+  type RepeatProblem,
+} from "./recurrenceDraft";
+
+const T2 = "2026-10-13"; // a Tuesday, the second of its month
+const rows = fixture.rows as { rule: string; words: string; spec: RepeatRule }[];
+
+const weekly = (days: DayCode[]): RepeatRule => ({
+  pattern: { kind: "weekly", days },
+  interval: 1,
+  ends: { kind: "never" },
+});
+
+/** The dialog's defaults on 13-10-2026, with `patch` typed over them. */
+const form = (patch: Partial<RepeatForm> = {}): RepeatForm => ({
+  ...formFromRule(null, T2),
+  ...patch,
+});
+
+const problemOf = (f: RepeatForm, start = T2): RepeatProblem | null => {
+  const r = ruleFromForm(f, start);
+  return r.ok ? null : r.problem;
+};
+
+describe("the Custom dialog's fields", () => {
+  it("round trips every T2 rule", () => {
+    expect(rows).toHaveLength(16);
+    for (const row of rows) {
+      const back = ruleFromForm(formFromRule(row.spec, T2), T2);
+      expect(back, row.rule).toEqual({ ok: true, rule: row.spec });
+    }
+  });
+
+  it("opens on Google's defaults: weekly on the start's day, three months, 13 times", () => {
+    expect(formFromRule(null, T2)).toEqual({
+      unit: "week",
+      interval: "1",
+      days: ["tue"],
+      monthly: { by: "day", day: 13 },
+      yearly: { by: "date" },
+      ends: "never",
+      date: "2027-01-13",
+      count: "13",
+    });
+    // Three months from the 31st is the last day of a shorter month.
+    expect(formFromRule(null, "2026-11-30").date).toBe("2027-02-28");
+  });
+
+  it("After 730 is accepted and 731 is refused with Google's words", () => {
+    expect(ruleFromForm(form({ ends: "after", count: "730" }), T2)).toEqual({
+      ok: true,
+      rule: { ...weekly(["tue"]), ends: { kind: "after", count: 730 } },
+    });
+    expect(problemOf(form({ ends: "after", count: "731" }))).toBe("too_many");
+    expect(repeatProblemText("too_many")).toBe(
+      "Google allows at most 730 occurrences of a repeating event.",
+    );
+  });
+
+  it("After 0 is refused", () => {
+    expect(problemOf(form({ ends: "after", count: "0" }))).toBe("count");
+    expect(problemOf(form({ ends: "after", count: "" }))).toBe("count");
+  });
+
+  it("an end date before the start is refused; on the start day it is accepted", () => {
+    expect(problemOf(form({ ends: "on_date", date: "2026-10-12" }))).toBe("ends_before_start");
+    expect(ruleFromForm(form({ ends: "on_date", date: T2 }), T2)).toEqual({
+      ok: true,
+      rule: { ...weekly(["tue"]), ends: { kind: "on_date", date: T2 } },
+    });
+  });
+
+  it("an empty end date asks for one", () => {
+    expect(problemOf(form({ ends: "on_date", date: "" }))).toBe("no_end_date");
+    expect(problemOf(form({ ends: "on_date", date: "2026-02-30" }))).toBe("no_end_date");
+    // Only when it ends on a date: Never doesn't read the field.
+    expect(problemOf(form({ ends: "never", date: "" }))).toBeNull();
+  });
+
+  it("no weekday is refused", () => {
+    expect(problemOf(form({ days: [] }))).toBe("no_weekdays");
+    // Another unit doesn't need any.
+    expect(problemOf(form({ days: [], unit: "day" }))).toBeNull();
+  });
+
+  it("interval 0 and 100 are refused, 1 and 99 accepted", () => {
+    expect(problemOf(form({ interval: "0" }))).toBe("interval");
+    expect(problemOf(form({ interval: "100" }))).toBe("interval");
+    expect(problemOf(form({ interval: "1" }))).toBeNull();
+    expect(problemOf(form({ interval: " 99 " }))).toBeNull();
+  });
+
+  it("a non-number is refused", () => {
+    expect(problemOf(form({ interval: "two" }))).toBe("interval");
+    expect(problemOf(form({ interval: "1.5" }))).toBe("interval");
+    expect(problemOf(form({ ends: "after", count: "ten" }))).toBe("count");
+  });
+
+  it("refuses in the backend's order: the interval first, the end date last", () => {
+    expect(problemOf(form({ interval: "0", days: [], ends: "on_date", date: "2026-01-01" }))).toBe(
+      "interval",
+    );
+    expect(problemOf(form({ days: [], ends: "after", count: "0" }))).toBe("no_weekdays");
+  });
+
+  it("writes weekdays Monday first, each once", () => {
+    expect(ruleFromForm(form({ days: ["fri", "mon", "fri"] }), T2)).toEqual({
+      ok: true,
+      rule: weekly(["mon", "fri"]),
+    });
+  });
+
+  // §1.3's words, literally: the dialog refuses with what the backend says of the same rule.
+  it("the problem words match the backend's", () => {
+    const words: Record<RepeatProblem, string> = {
+      interval: "Repeat every 1 to 99.",
+      no_weekdays: "Pick at least one day of the week.",
+      count: "It has to happen at least once.",
+      too_many: "Google allows at most 730 occurrences of a repeating event.",
+      no_end_date: "Pick an end date.",
+      ends_before_start: "The end date is before the first occurrence.",
+    };
+    for (const [problem, text] of Object.entries(words)) {
+      expect(repeatProblemText(problem as RepeatProblem)).toBe(text);
+    }
+  });
+});
+
+describe("the monthly and yearly choices", () => {
+  it("monthly choices follow the start date", () => {
+    expect(monthlyChoices("2026-10-13").map(monthlyLabel)).toEqual([
+      "Monthly on day 13",
+      "Monthly on the second Tuesday",
+    ]);
+    expect(monthlyChoices("2026-10-27").map(monthlyLabel)).toEqual([
+      "Monthly on day 27",
+      "Monthly on the fourth Tuesday",
+      "Monthly on the last Tuesday",
+    ]);
+    // The 31st is a fifth Saturday, which Google never offers: only the last.
+    expect(monthlyChoices("2026-10-31").map(monthlyLabel)).toEqual([
+      "Monthly on day 31",
+      "Monthly on the last Saturday",
+    ]);
+  });
+
+  it("a rule read from Google keeps its monthly choice", () => {
+    const lastFriday = { by: "weekday" as const, nth: "last" as const, weekday: "fri" as const };
+    expect(monthlyChoices(T2, lastFriday).map(monthlyLabel)).toEqual([
+      "Monthly on day 13",
+      "Monthly on the second Tuesday",
+      "Monthly on the last Friday",
+    ]);
+    // One of the start's own isn't listed twice.
+    expect(monthlyChoices(T2, { by: "day", day: 13 })).toHaveLength(2);
+  });
+
+  it("says the monthly and yearly rules as the backend does", () => {
+    for (const row of rows) {
+      const p = row.spec.pattern;
+      if (row.spec.interval !== 1 || row.spec.ends.kind !== "never") continue;
+      if (p.kind === "monthly_day") expect(monthlyLabel({ by: "day", ...p })).toBe(row.words);
+      if (p.kind === "monthly_weekday") {
+        expect(monthlyLabel({ by: "weekday", nth: p.nth, weekday: p.weekday })).toBe(row.words);
+      }
+      if (p.kind === "yearly_date") expect(yearlyLabel({ by: "date" }, T2)).toBe(row.words);
+      if (p.kind === "yearly_weekday") {
+        expect(yearlyLabel({ by: "weekday", ...p }, T2)).toBe(row.words);
+      }
+    }
+    expect(formatDayMonth(T2)).toBe("13 October");
+    expect(formatDayMonth("2028-02-29")).toBe("29 February");
+  });
+
+  it("a yearly weekday rule is kept while the unit stays year", () => {
+    const rule: RepeatRule = {
+      pattern: { kind: "yearly_weekday", month: 10, nth: "second", weekday: "tue" },
+      interval: 1,
+      ends: { kind: "never" },
+    };
+    const f = formFromRule(rule, T2);
+    expect(f.unit).toBe("year");
+    // Changing the interval keeps it; the unit and back again keeps it too.
+    expect(ruleFromForm({ ...f, interval: "2" }, T2)).toEqual({
+      ok: true,
+      rule: { ...rule, interval: 2 },
+    });
+    expect(ruleFromForm({ ...f, unit: "month" }, T2)).toMatchObject({
+      ok: true,
+      rule: { pattern: { kind: "monthly_day", day: 13 } },
+    });
+    expect(ruleFromForm({ ...f, unit: "year" }, T2)).toEqual({ ok: true, rule });
+  });
+});
+
+describe("comparing rules", () => {
+  it("sameRule ignores weekday order", () => {
+    expect(sameRule(weekly(["wed", "mon"]), weekly(["mon", "wed"]))).toBe(true);
+    expect(sameRule(weekly(["mon"]), weekly(["mon", "wed"]))).toBe(false);
+    expect(sameRule(weekly(["mon"]), { ...weekly(["mon"]), interval: 2 })).toBe(false);
+    expect(
+      sameRule(weekly(["mon"]), { ...weekly(["mon"]), ends: { kind: "after", count: 2 } }),
+    ).toBe(false);
+  });
+
+  it("sameRepeat tells no repeat, a rule and a kept one apart", () => {
+    const rule = { kind: "rule" as const, rule: weekly(["mon"]) };
+    expect(sameRepeat({ kind: "once" }, { kind: "once" })).toBe(true);
+    expect(sameRepeat({ kind: "once" }, rule)).toBe(false);
+    expect(sameRepeat(rule, { kind: "rule", rule: weekly(["mon"]) })).toBe(true);
+    expect(sameRepeat({ kind: "kept", words: "Repeats" }, { kind: "kept", words: "Repeats" })).toBe(
+      true,
+    );
+  });
+});
+
+describe("a rule following its start date", () => {
+  const monthly = (nth: "first" | "second" | "third" | "fourth" | "last", weekday: "tue" | "wed") =>
+    ({
+      pattern: { kind: "monthly_weekday", nth, weekday },
+      interval: 1,
+      ends: { kind: "never" },
+    }) satisfies RepeatRule;
+
+  it("followStartDate moves a one-day weekly rule, not a two-day one", () => {
+    expect(followStartDate(weekly(["tue"]), T2, "2026-10-14")).toEqual(weekly(["wed"]));
+    const two = weekly(["mon", "tue"]);
+    expect(followStartDate(two, T2, "2026-10-14")).toBe(two);
+    // A weekly rule on another day than the start's isn't the start's.
+    const other = weekly(["fri"]);
+    expect(followStartDate(other, T2, "2026-10-14")).toBe(other);
+  });
+
+  it("followStartDate moves the second Tuesday to the second Wednesday", () => {
+    expect(followStartDate(monthly("second", "tue"), T2, "2026-10-14")).toEqual(
+      monthly("second", "wed"),
+    );
+    // A day of the month follows the day.
+    const day13: RepeatRule = { ...weekly([]), pattern: { kind: "monthly_day", day: 13 } };
+    expect(followStartDate(day13, T2, "2026-10-14").pattern).toEqual({
+      kind: "monthly_day",
+      day: 14,
+    });
+    // A fifth has no number: it becomes the last.
+    expect(followStartDate(monthly("second", "tue"), T2, "2026-12-30")).toEqual(
+      monthly("last", "wed"),
+    );
+  });
+
+  it("followStartDate keeps last when both dates are in their month's last week", () => {
+    expect(followStartDate(monthly("last", "tue"), "2026-10-27", "2026-10-28")).toEqual(
+      monthly("last", "wed"),
+    );
+    // Out of the last week, it takes the new day's number.
+    expect(followStartDate(monthly("last", "tue"), "2026-10-27", "2026-10-14")).toEqual(
+      monthly("second", "wed"),
+    );
+  });
+
+  it("leaves an end date before the new start for the Repeat row to say", () => {
+    const ends: RepeatRule = { ...weekly(["mon", "wed"]), ends: { kind: "on_date", date: T2 } };
+    expect(followStartDate(ends, T2, "2026-11-03")).toBe(ends);
+  });
+});
+
+describe("the start a rule is read against", () => {
+  it("is the timed start with its end, or the first day", () => {
+    expect(
+      repeatStartOf({
+        kind: "timed",
+        start_date: T2,
+        start_time: "09:00",
+        start_zone: "Europe/London",
+        end_date: T2,
+        end_time: "10:00",
+        end_zone: "America/New_York",
+      }),
+    ).toEqual({
+      kind: "timed",
+      date: T2,
+      time: "09:00",
+      zone: "Europe/London",
+      end: { date: T2, time: "10:00", zone: "America/New_York" },
+    });
+    expect(repeatStartOf({ kind: "all_day", first_day: T2, last_day: T2 })).toEqual({
+      kind: "all_day",
+      date: T2,
+    });
+    expect(repeatStartOf({ kind: "all_day", first_day: "", last_day: "" })).toBeNull();
+  });
+
+  it("says where a moved start falls", () => {
+    expect(movedStartText("2026-10-14")).toMatch(
+      /^Starts on Wed 14-10(-2026)?, the first day this repeat allows\.$/,
+    );
+  });
+});
diff --git a/src/lib/calendarEdit/recurrenceDraft.ts b/src/lib/calendarEdit/recurrenceDraft.ts
new file mode 100644
index 00000000..f6d26ef0
--- /dev/null
+++ b/src/lib/calendarEdit/recurrenceDraft.ts
@@ -0,0 +1,423 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// A new event's repeat, as pure functions (#884, C11): the Repeat row's value, the Custom dialog's
+// fields and the checks they get before anything is asked of the backend. A rule's words and the
+// ready-made rules come from the backend (the repeat menu's reads), so nothing here says a rule in
+// words except the dialog's own labels: its monthly choices and its yearly line, built from the same
+// English day and month names the backend uses.
+//
+// The checks run in the backend's order and say the backend's words, so the dialog's Done refuses
+// exactly what a save would; the backend still has the final say (a rule with no occurrence before
+// its end date, a first day the clocks skip), said under the Repeat row.
+
+import type { DayCode, NthCode, RepeatRule, RepeatStart, TimeDraft } from "../types";
+import { isoToDate } from "../dateField";
+import { formatDateOnly } from "../format";
+
+/** Every 1 to this many days, weeks, months or years. */
+export const MAX_INTERVAL = 99;
+/** Google allows at most this many occurrences of a repeating event. */
+export const MAX_OCCURRENCES = 730;
+
+/** The Repeat row's value: no repeat, a rule from the editor's set, or a repeating event's rule PM
+ *  can only show, kept unless the user replaces it. */
+export type RepeatValue =
+  { kind: "once" } | { kind: "rule"; rule: RepeatRule } | { kind: "kept"; words: string };
+
+export const ONCE: RepeatValue = { kind: "once" };
+
+export type RepeatUnit = "day" | "week" | "month" | "year";
+export type MonthlyChoice =
+  { by: "day"; day: number } | { by: "weekday"; nth: NthCode; weekday: DayCode };
+export type YearlyChoice =
+  { by: "date" } | { by: "weekday"; month: number; nth: NthCode; weekday: DayCode };
+
+/** What the Custom dialog's fields hold. Numbers stay as typed until checked. */
+export interface RepeatForm {
+  unit: RepeatUnit;
+  interval: string;
+  days: DayCode[];
+  monthly: MonthlyChoice;
+  yearly: YearlyChoice;
+  ends: "never" | "on_date" | "after";
+  /** The end date, YYYY-MM-DD. */
+  date: string;
+  count: string;
+}
+
+export type RepeatProblem =
+  "interval" | "no_weekdays" | "count" | "too_many" | "no_end_date" | "ends_before_start";
+
+/** The days of the week, Monday first (PM's weeks, and the order the backend writes them in). */
+export const WEEKDAYS: readonly { code: DayCode; name: string }[] = [
+  { code: "mon", name: "Monday" },
+  { code: "tue", name: "Tuesday" },
+  { code: "wed", name: "Wednesday" },
+  { code: "thu", name: "Thursday" },
+  { code: "fri", name: "Friday" },
+  { code: "sat", name: "Saturday" },
+  { code: "sun", name: "Sunday" },
+];
+
+const DAY_ORDER: readonly DayCode[] = WEEKDAYS.map((d) => d.code);
+
+const MONTHS = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+];
+
+const NTHS: readonly NthCode[] = ["first", "second", "third", "fourth"];
+
+/** A day's full English name, as the backend's words say it. */
+export const dayName = (code: DayCode) => WEEKDAYS[DAY_ORDER.indexOf(code)].name;
+
+/** `date` (YYYY-MM-DD) as a local calendar day, or null when it isn't a real one. */
+const dayOf = (date: string) => isoToDate(date);
+
+const daysInMonth = (y: number, month0: number) => new Date(y, month0 + 1, 0).getDate();
+
+/** The day of the week `date` (YYYY-MM-DD) falls on. */
+export function dayCodeOf(date: string): DayCode {
+  const d = dayOf(date);
+  // Sunday is 0 to `Date`, last in PM's week.
+  return d ? DAY_ORDER[(d.getDay() + 6) % 7] : "mon";
+}
+
+/** Which of its month's weekdays `date` is: first to fourth, or null for a fifth (Google offers none). */
+export function nthOf(date: string): NthCode | null {
+  const d = dayOf(date);
+  return d ? (NTHS[Math.floor((d.getDate() - 1) / 7)] ?? null) : null;
+}
+
+/** Whether `date` is in its month's last seven days, so it is that month's last of its weekday. */
+export function inLastWeek(date: string): boolean {
+  const d = dayOf(date);
+  return !!d && d.getDate() + 7 > daysInMonth(d.getFullYear(), d.getMonth());
+}
+
+/** `date` (YYYY-MM-DD) three months on, kept to that month's last day (31-01 gives 30-04). */
+function threeMonthsOn(date: string): string {
+  const d = dayOf(date);
+  if (!d) return date;
+  const y = d.getFullYear();
+  const m = d.getMonth() + 3;
+  const day = Math.min(d.getDate(), daysInMonth(y, m));
+  const out = new Date(y, m, day);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${out.getFullYear()}-${pad(out.getMonth() + 1)}-${pad(out.getDate())}`;
+}
+
+/** Days sorted Monday first, each once. */
+const weekOrder = (days: readonly DayCode[]) => DAY_ORDER.filter((code) => days.includes(code));
+
+/** The Custom dialog's fields for `rule`, or Google's defaults with no rule (weekly on the start's
+ *  weekday, ending three months on, or after 13 times: probe P-R4). The fields a rule doesn't set
+ *  keep those defaults, so switching the unit in the dialog offers something sensible. */
+export function formFromRule(rule: RepeatRule | null, startDate: string): RepeatForm {
+  const start = dayOf(startDate);
+  const form: RepeatForm = {
+    unit: "week",
+    interval: "1",
+    days: [dayCodeOf(startDate)],
+    monthly: { by: "day", day: start ? start.getDate() : 1 },
+    yearly: { by: "date" },
+    ends: "never",
+    date: threeMonthsOn(startDate),
+    count: "13",
+  };
+  if (!rule) return form;
+  form.interval = String(rule.interval);
+  const p = rule.pattern;
+  switch (p.kind) {
+    case "daily":
+      form.unit = "day";
+      break;
+    case "weekly":
+      form.unit = "week";
+      form.days = weekOrder(p.days);
+      break;
+    case "monthly_day":
+      form.unit = "month";
+      form.monthly = { by: "day", day: p.day };
+      break;
+    case "monthly_weekday":
+      form.unit = "month";
+      form.monthly = { by: "weekday", nth: p.nth, weekday: p.weekday };
+      break;
+    case "yearly_date":
+      form.unit = "year";
+      break;
+    case "yearly_weekday":
+      form.unit = "year";
+      form.yearly = { by: "weekday", month: p.month, nth: p.nth, weekday: p.weekday };
+      break;
+  }
+  const e = rule.ends;
+  if (e.kind === "on_date") {
+    form.ends = "on_date";
+    form.date = e.date;
+  } else if (e.kind === "after") {
+    form.ends = "after";
+    form.count = String(e.count);
+  }
+  return form;
+}
+
+/** A whole number typed in a field, or null. */
+function wholeNumber(text: string): number | null {
+  const t = text.trim();
+  return /^\d+$/.test(t) ? Number(t) : null;
+}
+
+/** The rule the dialog's fields make, or the first thing wrong with them, in the order the backend
+ *  checks a rule: the interval, the weekdays, the count, then the end date (on the start day is
+ *  fine). */
+export function ruleFromForm(
+  form: RepeatForm,
+  startDate: string,
+): { ok: true; rule: RepeatRule } | { ok: false; problem: RepeatProblem } {
+  const interval = wholeNumber(form.interval);
+  if (interval === null || interval < 1 || interval > MAX_INTERVAL) {
+    return { ok: false, problem: "interval" };
+  }
+  if (form.unit === "week" && form.days.length === 0) return { ok: false, problem: "no_weekdays" };
+  let ends: RepeatRule["ends"] = { kind: "never" };
+  if (form.ends === "after") {
+    const count = wholeNumber(form.count);
+    if (count === null || count < 1) return { ok: false, problem: "count" };
+    if (count > MAX_OCCURRENCES) return { ok: false, problem: "too_many" };
+    ends = { kind: "after", count };
+  } else if (form.ends === "on_date") {
+    if (!dayOf(form.date)) return { ok: false, problem: "no_end_date" };
+    // ISO dates compare as strings.
+    if (form.date < startDate) return { ok: false, problem: "ends_before_start" };
+    ends = { kind: "on_date", date: form.date };
+  }
+  let pattern: RepeatRule["pattern"];
+  switch (form.unit) {
+    case "day":
+      pattern = { kind: "daily" };
+      break;
+    case "week":
+      pattern = { kind: "weekly", days: weekOrder(form.days) };
+      break;
+    case "month":
+      pattern =
+        form.monthly.by === "day"
+          ? { kind: "monthly_day", day: form.monthly.day }
+          : { kind: "monthly_weekday", nth: form.monthly.nth, weekday: form.monthly.weekday };
+      break;
+    case "year":
+      pattern =
+        form.yearly.by === "date"
+          ? { kind: "yearly_date" }
+          : {
+              kind: "yearly_weekday",
+              month: form.yearly.month,
+              nth: form.yearly.nth,
+              weekday: form.yearly.weekday,
+            };
+      break;
+  }
+  return { ok: true, rule: { pattern, interval, ends } };
+}
+
+/** What's wrong with the dialog's fields, in words. The backend's own words for the same limits
+ *  (`SpecError`), which a test pins to these. */
+export function repeatProblemText(problem: RepeatProblem): string {
+  switch (problem) {
+    case "interval":
+      return `Repeat every 1 to ${MAX_INTERVAL}.`;
+    case "no_weekdays":
+      return "Pick at least one day of the week.";
+    case "count":
+      return "It has to happen at least once.";
+    case "too_many":
+      return `Google allows at most ${MAX_OCCURRENCES} occurrences of a repeating event.`;
+    case "no_end_date":
+      return "Pick an end date.";
+    case "ends_before_start":
+      return "The end date is before the first occurrence.";
+  }
+}
+
+const sameMonthly = (a: MonthlyChoice, b: MonthlyChoice) =>
+  a.by === "day"
+    ? b.by === "day" && a.day === b.day
+    : b.by === "weekday" && a.nth === b.nth && a.weekday === b.weekday;
+
+/** The Monthly choices for a start date, Google's way: "on day 13", "on the second Tuesday", and "on
+ *  the last Tuesday" in the month's last seven days; never a fifth. `current` joins them when it
+ *  isn't one (a rule read from Google), so the dialog never drops it. */
+export function monthlyChoices(startDate: string, current?: MonthlyChoice): MonthlyChoice[] {
+  const start = dayOf(startDate);
+  const weekday = dayCodeOf(startDate);
+  const out: MonthlyChoice[] = [{ by: "day", day: start ? start.getDate() : 1 }];
+  const nth = nthOf(startDate);
+  if (nth) out.push({ by: "weekday", nth, weekday });
+  if (inLastWeek(startDate)) out.push({ by: "weekday", nth: "last", weekday });
+  if (current && !out.some((c) => sameMonthly(c, current))) out.push(current);
+  return out;
+}
+
+/** A Monthly choice as Google's dialog says it: "Monthly on day 13", "Monthly on the last Friday". */
+export function monthlyLabel(c: MonthlyChoice): string {
+  return c.by === "day"
+    ? `Monthly on day ${c.day}`
+    : `Monthly on the ${c.nth} ${dayName(c.weekday)}`;
+}
+
+/** `date` (YYYY-MM-DD) as a day and an English month, as the backend says a yearly rule's date:
+ *  "13 October". */
+export function formatDayMonth(date: string): string {
+  const d = dayOf(date);
+  return d ? `${d.getDate()} ${MONTHS[d.getMonth()]}` : date;
+}
+
+/** The Custom dialog's yearly line: "Annually on 13 October" on the start's own date, or a weekday
+ *  rule's own words (Google's dialog offers no yearly choices, so this is text). */
+export function yearlyLabel(c: YearlyChoice, startDate: string): string {
+  return c.by === "date"
+    ? `Annually on ${formatDayMonth(startDate)}`
+    : `Annually on the ${c.nth} ${dayName(c.weekday)} of ${MONTHS[c.month - 1] ?? ""}`;
+}
+
+/** Whether two rules mean the same (weekday order aside). */
+export function sameRule(a: RepeatRule, b: RepeatRule): boolean {
+  if (a.interval !== b.interval) return false;
+  const ea = a.ends;
+  const eb = b.ends;
+  const ends =
+    ea.kind === "never"
+      ? eb.kind === "never"
+      : ea.kind === "on_date"
+        ? eb.kind === "on_date" && ea.date === eb.date
+        : eb.kind === "after" && ea.count === eb.count;
+  if (!ends) return false;
+  const pa = a.pattern;
+  const pb = b.pattern;
+  switch (pa.kind) {
+    case "daily":
+    case "yearly_date":
+      return pb.kind === pa.kind;
+    case "weekly":
+      // A day listed twice is still one day.
+      return pb.kind === "weekly" && weekOrder(pa.days).join() === weekOrder(pb.days).join();
+    case "monthly_day":
+      return pb.kind === "monthly_day" && pa.day === pb.day;
+    case "monthly_weekday":
+      return pb.kind === "monthly_weekday" && pa.nth === pb.nth && pa.weekday === pb.weekday;
+    case "yearly_weekday":
+      return (
+        pb.kind === "yearly_weekday" &&
+        pa.month === pb.month &&
+        pa.nth === pb.nth &&
+        pa.weekday === pb.weekday
+      );
+  }
+}
+
+/** Whether two Repeat row values mean the same. */
+export function sameRepeat(a: RepeatValue, b: RepeatValue): boolean {
+  switch (a.kind) {
+    case "once":
+      return b.kind === "once";
+    case "rule":
+      return b.kind === "rule" && sameRule(a.rule, b.rule);
+    case "kept":
+      return b.kind === "kept" && a.words === b.words;
+  }
+}
+
+/** A copy of `rule` sharing nothing with it, for what a save sends. */
+export function copyRule(rule: RepeatRule): RepeatRule {
+  const p = rule.pattern;
+  return {
+    pattern: p.kind === "weekly" ? { ...p, days: [...p.days] } : { ...p },
+    interval: rule.interval,
+    ends: { ...rule.ends },
+  };
+}
+
+/** A rule after its event's start date moves from `from` to `to`: a rule whose day came from the
+ *  start date follows it (weekly on that one weekday, monthly on its day or its numbered or last
+ *  weekday), as the 10-09 design has it (probe P-R5); any other rule stays as it is, the same object.
+ *  An end date before `to` is left alone: the Repeat row then says so. */
+export function followStartDate(rule: RepeatRule, from: string, to: string): RepeatRule {
+  const fromDay = dayOf(from);
+  const toDay = dayOf(to);
+  if (from === to || !fromDay || !toDay) return rule;
+  const p = rule.pattern;
+  const wdFrom = dayCodeOf(from);
+  const wdTo = dayCodeOf(to);
+  switch (p.kind) {
+    case "weekly":
+      if (p.days.length === 1 && p.days[0] === wdFrom) {
+        return { ...rule, pattern: { kind: "weekly", days: [wdTo] } };
+      }
+      return rule;
+    case "monthly_day":
+      if (p.day === fromDay.getDate()) {
+        return { ...rule, pattern: { kind: "monthly_day", day: toDay.getDate() } };
+      }
+      return rule;
+    case "monthly_weekday": {
+      if (p.weekday !== wdFrom) return rule;
+      const nthFrom = nthOf(from);
+      if (p.nth !== "last" && p.nth === nthFrom) {
+        return {
+          ...rule,
+          pattern: { kind: "monthly_weekday", nth: nthOf(to) ?? "last", weekday: wdTo },
+        };
+      }
+      if (p.nth === "last" && inLastWeek(from)) {
+        // Not in its month's last week, the new day is one of its first four.
+        const nth = inLastWeek(to) ? "last" : (nthOf(to) ?? "last");
+        return { ...rule, pattern: { kind: "monthly_weekday", nth, weekday: wdTo } };
+      }
+      return rule;
+    }
+    default:
+      // "Annually on its own date" follows by itself; the rest name their days outright.
+      return rule;
+  }
+}
+
+/** The start the backend reads a rule against, from the editor's time (with where the first
+ *  occurrence ends, so a moved start whose end the clocks skip is said too); null while a date is
+ *  empty. */
+export function repeatStartOf(time: TimeDraft): RepeatStart | null {
+  if (time.kind === "all_day") {
+    return time.first_day ? { kind: "all_day", date: time.first_day } : null;
+  }
+  if (!time.start_date || !time.end_date) return null;
+  return {
+    kind: "timed",
+    date: time.start_date,
+    time: time.start_time,
+    zone: time.start_zone,
+    end: { date: time.end_date, time: time.end_time, zone: time.end_zone },
+  };
+}
+
+/** The first day an event's time covers (YYYY-MM-DD): where a rule's own days are read from. */
+export const startDateOf = (time: TimeDraft) =>
+  time.kind === "timed" ? time.start_date : time.first_day;
+
+/** The line for a first occurrence the rule moved off the day asked for (A27): "Starts on Wed 14-10,
+ *  the first day this repeat allows." The editor's own date stays as typed; the save moves it. */
+export function movedStartText(starts: string): string {
+  const short = dayName(dayCodeOf(starts)).slice(0, 3);
+  return `Starts on ${short} ${formatDateOnly(starts)}, the first day this repeat allows.`;
+}
diff --git a/src/lib/changelog.ts b/src/lib/changelog.ts
index f0f397f4..3875d6c9 100644
--- a/src/lib/changelog.ts
+++ b/src/lib/changelog.ts
@@ -23,6 +23,14 @@ export interface ChangelogEntry {
 }
 
 export const CHANGELOG: ChangelogEntry[] = [
+  {
+    version: "3.153.0-alpha",
+    date: "2026-10-20",
+    highlights: [
+      "New events can repeat. Under the date and time, in the full editor and in quick create, pick one of Google's choices for that day, like “Weekly on Tuesday” or “Monthly on the second Tuesday”, or set your own with Custom…: every few days, weeks, months or years, on the days you choose, ending on a date or after a number of times.",
+      "If the days you pick don't include the start date, PM starts the event on the first day that fits and tells you which, and an event in another time zone says it repeats in that zone's time. Changing how an existing event repeats comes next.",
+    ],
+  },
   {
     version: "3.152.1-alpha",
     date: "2026-10-20",
diff --git a/src/lib/help.ts b/src/lib/help.ts
index 1ccd1019..b924798c 100644
--- a/src/lib/help.ts
+++ b/src/lib/help.ts
@@ -262,7 +262,7 @@ export const HELP: Record<string, HelpEntry> = {
   // Calendar (unified view, card 8; editing #884)
   "calendar-view": {
     title: "Your calendar",
-    body: "A single view of every calendar you've connected, merged together and colour-coded by source (an event you gave its own colour in Google shows in it, with its calendar's colour down the edge), so you can see your whole schedule in one place; PM uses the same events for your agenda, chat answers and 'Due soon' flags. While PM is open, changes made in Google show within about half a minute. Click an event for its details. On a Google account with editing turned on (Settings → Connectors), Edit and Delete appear there for events you organise without guests. On those accounts, + New event (or press c for the full editor, Shift+C for a quick one) creates an event on a calendar you choose; it goes straight to Google, with the calendar's usual notifications and nobody invited, and PM starts it on the calendar you last created one in. In the quick one, type a title and press Enter; in the day, week, month and agenda views the new event shows as you type (the Year view and the Terminal look show only what's in your calendar), and More options opens the full editor. Clicking elsewhere on the calendar closes the quick one only while it has no title, and a titled one is still there if you switch tabs and come back. For a repeating event PM asks whether you mean this event, this and the following events, or all of them, as Google Calendar does, and says first what that would change. A repeating event's details say how it repeats, as Google Calendar does. After you change “this and the following events”, PM asks whether to move a milestone already linked to it, dated from that day on, to the new part. Changes go straight to Google: a save never overwrites a field someone changed there in the meantime, and a delete waits a few seconds for Undo (or Ctrl+Z, ⌘Z on a Mac) and doesn't happen if the title, time or place changed there. Anything else says why it can't be changed. Connect or choose calendars in Settings → Connectors.",
+    body: "A single view of every calendar you've connected, merged together and colour-coded by source (an event you gave its own colour in Google shows in it, with its calendar's colour down the edge), so you can see your whole schedule in one place; PM uses the same events for your agenda, chat answers and 'Due soon' flags. While PM is open, changes made in Google show within about half a minute. Click an event for its details. On a Google account with editing turned on (Settings → Connectors), Edit and Delete appear there for events you organise without guests. On those accounts, + New event (or press c for the full editor, Shift+C for a quick one) creates an event on a calendar you choose; it goes straight to Google, with the calendar's usual notifications and nobody invited, and PM starts it on the calendar you last created one in. In the quick one, type a title and press Enter; in the day, week, month and agenda views the new event shows as you type (the Year view and the Terminal look show only what's in your calendar), and More options opens the full editor. Clicking elsewhere on the calendar closes the quick one only while it has no title, and a titled one is still there if you switch tabs and come back. When you create an event, Repeat sets how it repeats: Google's choices, or Custom… for your own; if the days you pick don't include the start date, PM starts it on the first day that fits and says so. For a repeating event PM asks whether you mean this event, this and the following events, or all of them, as Google Calendar does, and says first what that would change. A repeating event's details say how it repeats, as Google Calendar does. After you change “this and the following events”, PM asks whether to move a milestone already linked to it, dated from that day on, to the new part. Changes go straight to Google: a save never overwrites a field someone changed there in the meantime, and a delete waits a few seconds for Undo (or Ctrl+Z, ⌘Z on a Mac) and doesn't happen if the title, time or place changed there. Anything else says why it can't be changed. Connect or choose calendars in Settings → Connectors.",
   },
   "calendar-header": {
     title: "Move around & choose a view",
@@ -394,7 +394,7 @@ export const HELP: Record<string, HelpEntry> = {
   },
   "settings-calendar-editing": {
     title: "Calendar editing",
-    body: "Lets PM create events on this Google account's calendars, and change and delete events you organise without guests (repeating ones included), including on calendars shared with you that you can edit. Turning it on asks Google for permission: Google lists two things, seeing your calendars and changing their events, and editing needs both ticked. 'Turn off editing' stops PM using that permission straight away, without asking Google, and turning it back on is just as quick. Google keeps the permission until you disconnect the account here (or, while Drive or backups still use the account, until you remove PM at myaccount.google.com/permissions). Connecting the account again asks for reading only, so it turns editing off.",
+    body: "Lets PM create events on this Google account's calendars, one-off or repeating, and change and delete events you organise without guests (repeating ones included), including on calendars shared with you that you can edit. Turning it on asks Google for permission: Google lists two things, seeing your calendars and changing their events, and editing needs both ticked. 'Turn off editing' stops PM using that permission straight away, without asking Google, and turning it back on is just as quick. Google keeps the permission until you disconnect the account here (or, while Drive or backups still use the account, until you remove PM at myaccount.google.com/permissions). Connecting the account again asks for reading only, so it turns editing off.",
   },
   "settings-calendar-microsoft": {
     title: "Outlook Calendar",
diff --git a/src/lib/zoneLabel.ts b/src/lib/zoneLabel.ts
index f1936e5d..699f0a4e 100644
--- a/src/lib/zoneLabel.ts
+++ b/src/lib/zoneLabel.ts
@@ -63,7 +63,8 @@ function abbreviation(id: string, at: Date): string | null {
 function continentOf(id: string): string {
   return (id.split("/")[0] ?? id).replace(/_/g, " ");
 }
-function cityOf(id: string): string {
+/** A zone's city, as its label ends it: "New York" for America/New_York. */
+export function cityOf(id: string): string {
   return (id.split("/").pop() ?? id).replace(/_/g, " ");
 }