diff --git a/README.md b/README.md
index 9551de69..b6acde8b 100644
--- a/README.md
+++ b/README.md
@@ -78,8 +78,10 @@ not an exhaustive list; the in-app **What's New** is the complete, current recor
   own working hours — with schedule-aware chat answers and an automatic "Due soon" when an
   event names a project. Your milestones and pinboard timelines show alongside as markers you
   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), and change and delete
-  events you organise without guests, repeating ones included. Every change goes straight to
+  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
+  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.
 - **Bring your own model.** Choose your model through OpenRouter — separate chat and
diff --git a/design-system-docs/README.md b/design-system-docs/README.md
index 02d4a573..cc1f8ff1 100644
--- a/design-system-docs/README.md
+++ b/design-system-docs/README.md
@@ -164,7 +164,7 @@ Drive it with a single `depth` value; gate optional blocks on it. Don't fork lay
   Slate = cards; Terminal = table. Depth scales it from name+status only → +meta → full table with cost/active.
 - **Project** — file list beside a project-scoped chat thread (two-pane). Treatment per System.
 - **Documents** — ingestion: a drop zone + recent items with type/date/index-state. Rules / cards / mono table per System.
-- **Calendar** — week/agenda; "+ New event" (or `c`) creates a Google event, and one you organise can be edited from its details. Serif agenda / day cards / mono list per System.
+- **Calendar** — week/agenda; "+ New event" (or `c`) creates a Google event, and one you organise can be edited from its details. Shift+C opens quick create, a small non-modal box under the button whose draft is drawn as a dashed ghost (`DRAFT_EVENT_CLASS`: `outline-ink3`, dashed inside the edge with `-outline-offset-1` so a clipping list can't cut it, never greyed as past; a dashed ring among Minimal's month dots) in the day, week, month and agenda views, except in the Terminal look, which draws only what's in the calendar; its accessible name starts with what it is (`draftNote`). Serif agenda / day cards / mono list per System.
 - **Review** — queue of proposed actions as inline approval cards (Approve / Edit / Dismiss).
 - **Settings** — appearance (System / Accent / Depth / Mode), models & keys (key field → keychain), help-mode toggle. Editorial = ruled sections, Slate = card panel, Terminal = key/value list.
 - **Command palette** (`⌘K`) — overlay with a query line + result rows.
diff --git a/package-lock.json b/package-lock.json
index d27108a3..b81c75e0 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "pm",
-  "version": "3.150.0-alpha",
+  "version": "3.151.0-alpha",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pm",
-      "version": "3.150.0-alpha",
+      "version": "3.151.0-alpha",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "@fontsource/atkinson-hyperlegible": "^5.3.0",
diff --git a/package.json b/package.json
index 4f70c260..5bed7a12 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "pm",
   "private": true,
-  "version": "3.150.0-alpha",
+  "version": "3.151.0-alpha",
   "license": "AGPL-3.0-or-later",
   "type": "module",
   "engines": {
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 0790bea6..0c72d3b6 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -3072,7 +3072,7 @@ dependencies = [
 
 [[package]]
 name = "pm"
-version = "3.150.0-alpha"
+version = "3.151.0-alpha"
 dependencies = [
  "argon2",
  "base64 0.23.1",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 5344c28a..c5f6d832 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pm"
-version = "3.150.0-alpha"
+version = "3.151.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 d1b89227..9fb30896 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.150.0-alpha",
+  "version": "3.151.0-alpha",
   "identifier": "org.itsatlas.pm",
   "build": {
     "beforeDevCommand": "npm run dev",
diff --git a/src/components/ModelPicker.test.tsx b/src/components/ModelPicker.test.tsx
index ada36382..995b8ea4 100644
--- a/src/components/ModelPicker.test.tsx
+++ b/src/components/ModelPicker.test.tsx
@@ -4,10 +4,13 @@
 
 // ModelPicker is a hand-rolled menu inside the Settings dialog (Settings › AI › "Add a model…"). Its
 // Escape listener sits on `document` and the dialog's on `window`, so without stopping the key one
-// Escape closed the menu AND Settings (or raised the unsaved-changes guard).
+// Escape closed the menu AND Settings (or raised the unsaved-changes guard). It follows the Popover
+// primitive's rule: a modal dialog over it owns the key, a non-modal layer only a key pressed in it.
 
+import { useRef } from "react";
 import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { useDialogLayer } from "../lib/useDialogLayer";
 
 vi.mock("../lib/ipc", () => ({
   listModels: () => Promise.resolve([]),
@@ -57,4 +60,54 @@ describe("ModelPicker inside a dialog", () => {
     fireEvent.keyDown(screen.getByText("Add a model…"), { key: "Escape" });
     expect(onDialogClose).toHaveBeenCalledTimes(1);
   });
+
+  // The calendar's quick create stays open through a click in the sidebar, so it can sit behind
+  // Settings: a non-modal layer, which owns only a key pressed inside it.
+  it("closes only itself on Escape beside a non-modal layer", async () => {
+    function Layer() {
+      const ref = useRef<HTMLDivElement>(null);
+      useDialogLayer(true, ref);
+      return <div ref={ref} role="dialog" aria-label="New event" />;
+    }
+    const onDialogClose = vi.fn();
+    render(
+      <>
+        <Layer />
+        <Modal open onClose={onDialogClose} label="Settings">
+          <ModelPicker value="" onChange={() => {}} triggerLabel="Add a model…" />
+        </Modal>
+      </>,
+    );
+    fireEvent.click(screen.getByText("Add a model…"));
+    const search = await screen.findByPlaceholderText("Search models…");
+    fireEvent.keyDown(search, { key: "Escape" });
+    await waitFor(() => expect(screen.queryByPlaceholderText("Search models…")).toBeNull());
+    expect(onDialogClose).not.toHaveBeenCalled();
+    fireEvent.keyDown(screen.getByText("Add a model…"), { key: "Escape" });
+    expect(onDialogClose).toHaveBeenCalledTimes(1);
+  });
+
+  // A modal dialog opened over the open menu (one of Settings' own questions) holds the keyboard.
+  it("leaves Escape to a modal dialog opened over it", async () => {
+    const onDialogClose = vi.fn();
+    const onQuestionClose = vi.fn();
+    const page = (asking: boolean) => (
+      <Modal open onClose={onDialogClose} label="Settings">
+        <ModelPicker value="" onChange={() => {}} triggerLabel="Add a model…" />
+        {asking && (
+          <Modal open onClose={onQuestionClose} label="Reset these settings?">
+            <button type="button">Reset</button>
+          </Modal>
+        )}
+      </Modal>
+    );
+    const { rerender } = render(page(false));
+    fireEvent.click(screen.getByText("Add a model…"));
+    await screen.findByPlaceholderText("Search models…");
+    rerender(page(true));
+    fireEvent.keyDown(screen.getByText("Reset"), { key: "Escape" });
+    expect(onQuestionClose).toHaveBeenCalledTimes(1);
+    expect(screen.queryByPlaceholderText("Search models…")).not.toBeNull();
+    expect(onDialogClose).not.toHaveBeenCalled();
+  });
 });
diff --git a/src/components/ModelPicker.tsx b/src/components/ModelPicker.tsx
index 1dcf1ae4..5fe6bfcd 100644
--- a/src/components/ModelPicker.tsx
+++ b/src/components/ModelPicker.tsx
@@ -3,7 +3,7 @@
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import { listModels } from "../lib/ipc";
-import { isCoveredByDialog } from "../lib/useDialogLayer";
+import { isKeyForDialogOver } from "../lib/useDialogLayer";
 import type { ModelInfo } from "../lib/types";
 import { Button, Input, Skeleton } from "./ui";
 
@@ -52,9 +52,11 @@ export function ModelPicker({ value, onChange, triggerLabel = "Choose a model…
     };
     const onKey = (e: KeyboardEvent) => {
       if (e.key !== "Escape") return;
-      // Same rule as the Popover primitive: a dialog opened over this menu owns the key; otherwise
-      // the menu closes and the key stops here, so the Settings dialog around it stays open.
-      if (isCoveredByDialog(rootRef.current)) return;
+      // Same rule as the Popover primitive: a modal dialog opened over this menu owns the key, and a
+      // non-modal layer beside it (the calendar's quick create, left open behind Settings) only a key
+      // pressed inside it; otherwise the menu closes and the key stops here, so the Settings dialog
+      // around it stays open.
+      if (isKeyForDialogOver(rootRef.current, e.target)) return;
       e.stopPropagation();
       setOpen(false);
     };
diff --git a/src/components/calendar/CalendarHeader.test.tsx b/src/components/calendar/CalendarHeader.test.tsx
index 2c219bbd..2b7dadfa 100644
--- a/src/components/calendar/CalendarHeader.test.tsx
+++ b/src/components/calendar/CalendarHeader.test.tsx
@@ -7,6 +7,7 @@
 // account is connected, and when no calendar can take an event it stays focusable and says why
 // rather than going grey and silent.
 
+import { createRef, type RefObject } from "react";
 import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
@@ -21,11 +22,17 @@ afterEach(cleanup);
 
 const REASON = "None of your calendars can take new events.";
 
-function header(over: { onCreate?: () => void; createReason?: string | null } = {}) {
+interface Over {
+  onCreate?: () => void;
+  createReason?: string | null;
+  createRef?: RefObject<HTMLButtonElement | null>;
+}
+
+function header(over: Over = {}) {
   return render(element(over));
 }
 
-function element(over: { onCreate?: () => void; createReason?: string | null } = {}) {
+function element(over: Over = {}) {
   return (
     <CalendarHeader
       view="week"
@@ -80,7 +87,7 @@ describe("CalendarHeader", () => {
     expect(screen.queryByRole("status")).toBeNull();
   });
 
-  // One primary button on screen: the editor's Save (C1-L5).
+  // One primary button on screen: the editor's or quick create's Save (C1-L5).
   it("New event is a secondary button", () => {
     for (const createReason of [null, REASON]) {
       header({ onCreate: vi.fn(), createReason });
@@ -128,6 +135,12 @@ describe("CalendarHeader", () => {
     expect(screen.getByRole("status").textContent).toBe("");
   });
 
+  it("hands quick create the New event button, to open under and give focus back to", () => {
+    const button = createRef<HTMLButtonElement>();
+    header({ onCreate: vi.fn(), createReason: null, createRef: button });
+    expect(button.current).toBe(screen.getByRole("button", { name: "+ New event" }));
+  });
+
   it("has no New event without a Google account", () => {
     header();
     expect(screen.queryByRole("button", { name: "+ New event" })).toBeNull();
diff --git a/src/components/calendar/CalendarHeader.tsx b/src/components/calendar/CalendarHeader.tsx
index 3d6d6742..7376b1e4 100644
--- a/src/components/calendar/CalendarHeader.tsx
+++ b/src/components/calendar/CalendarHeader.tsx
@@ -5,15 +5,16 @@
 // date-range label, the view switcher (active = accent), and Refresh-now.
 //
 // "+ New event" (#884, C10) is the one control here that changes a calendar: it opens the editor for
-// a new Google event, as `c` does, and sits first, where Google's Create does. It shows once a Google
-// account is connected; when no calendar can take an event it stays focusable and says why (its
-// tooltip, and a click), rather than going grey and silent. It's secondary, so the editor's Save stays
-// the one primary button on screen. Everything else here only changes what you see.
+// a new Google event, as `c` does, and sits first, where Google's Create does; Shift+C's quick create
+// opens under it (`createRef`). It shows once a Google account is connected; when no calendar can
+// take an event it stays focusable and says why (its tooltip, and a click), rather than going grey
+// and silent. It's secondary, so the editor's or quick create's Save stays the one primary button on
+// screen. Everything else here only changes what you see.
 //
 // The last-synced time rides ON the Refresh button rather than beside it: it is the one fact that
 // tells you whether pressing Refresh is worth it.
 
-import { useEffect, useId, useState } from "react";
+import { useEffect, useId, useState, type Ref } from "react";
 import {
   DAY_COUNT_MAX,
   DAY_COUNT_MIN,
@@ -57,6 +58,8 @@ interface Props {
   onCreate?: () => void;
   /** Why no new event can be made now, or null when one can. */
   createReason?: string | null;
+  /** The "+ New event" button: quick create opens under it, and gives focus back to it. */
+  createRef?: Ref<HTMLButtonElement>;
 }
 
 /** How long a click's "why not" stays beside the button. */
@@ -92,6 +95,7 @@ export function CalendarHeader({
   lastSync,
   onCreate,
   createReason = null,
+  createRef,
 }: Props) {
   const { showMeta } = useDepth();
   const { system } = useTheme();
@@ -126,8 +130,9 @@ export function CalendarHeader({
     >
       {onCreate && (
         <div className="flex items-center gap-2">
-          <Tooltip label={createReason ?? "New event · c"}>
+          <Tooltip label={createReason ?? "New event · c, or Shift+C for a quick one"}>
             <Button
+              ref={createRef}
               variant="secondary"
               size="sm"
               aria-disabled={createReason !== null || undefined}
diff --git a/src/components/calendar/CalendarView.test.tsx b/src/components/calendar/CalendarView.test.tsx
new file mode 100644
index 00000000..16c85dbf
--- /dev/null
+++ b/src/components/calendar/CalendarView.test.tsx
@@ -0,0 +1,380 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Calendar tab's wiring for a new event (#884, C10c), over a mocked backend: `c` opens the full
+// editor and Shift+C quick create; while quick create is open a click on any event comes back to it
+// (an overlay's jump would switch tabs, and an event's details would be a second box); More options
+// and then Cancel gives focus back to "+ New event"; a saved event's ghost stays until a read that
+// started after the save lands, and a click on it opens nothing; the ghost shows on a hidden calendar
+// and only in the views that draw it; and a titled draft that went with the tab opens again when the
+// calendar comes back. Each test loads the view afresh: its caches and that draft live in the module.
+
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type {
+  Calendar,
+  CalendarAccount,
+  CalendarEvent,
+  CalendarOverview,
+  Milestone,
+  WriteOutcome,
+} from "../../lib/types";
+import { dayKey, startOfDay } from "../../lib/calendar-layout";
+
+const ipc = vi.hoisted(() => ({
+  calendarOverview: vi.fn(),
+  listAllCalendarEvents: vi.fn(),
+  listAllMilestones: vi.fn(),
+  getPref: vi.fn(),
+  setPref: vi.fn(),
+  getSettings: vi.fn(),
+  onCalendarSynced: vi.fn(),
+  onCalendarWriteLanded: vi.fn(),
+  syncCalendar: vi.fn(),
+  createCalendarEvent: vi.fn(),
+  deleteCalendarEvent: vi.fn(),
+  cancelCalendarDelete: vi.fn(),
+  getCalendarEventForEdit: vi.fn(),
+  listHeldDeletes: vi.fn(),
+  onCalendarDeleteSettled: vi.fn(),
+  seriesChoices: vi.fn(),
+  settleSeriesSplit: vi.fn(),
+  updateCalendarEvent: vi.fn(),
+  eventFlags: vi.fn(),
+  openUrl: 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).
+const env = vi.hoisted(() => ({
+  system: "slate",
+  hidden: new Set<string>(),
+  yearEvents: null as CalendarEvent[] | null,
+}));
+
+vi.mock("../../lib/ipc", () => ipc);
+
+vi.mock("../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: env.system, depth: "standard", accent: "mono", colorblind: false }),
+}));
+
+vi.mock("../../theme/UserTimeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useUserTime: () => ({ timeZone: "Europe/London", coords: null }),
+}));
+
+vi.mock("../../theme/timezones", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  deviceTimeZoneOrNull: () => "Europe/London",
+}));
+
+vi.mock("../../lib/calendarPrefs", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  readHidden: () => new Set(env.hidden),
+}));
+
+vi.mock("./views/YearView", () => ({
+  YearView: ({ events }: { events: CalendarEvent[] }) => {
+    env.yearEvents = events;
+    return null;
+  },
+}));
+
+const ME = "gcal:me@x.com";
+const PERSONAL = `${ME}:me@x.com`;
+const WORK_CAL = `${ME}:work`;
+
+const account: CalendarAccount = {
+  id: ME,
+  provider: "google",
+  email: "me@x.com",
+  label: "me@x.com",
+  state: "ok",
+  last_synced_at: null,
+};
+
+function calendar(remote: string, over: Partial<Calendar>): Calendar {
+  return {
+    id: `${ME}:${remote}`,
+    source_id: ME,
+    provider: "google",
+    remote_id: remote,
+    name: remote,
+    color: null,
+    selected: true,
+    is_primary: false,
+    quiet: false,
+    kind: null,
+    access_role: "owner",
+    time_zone: "Europe/London",
+    default_reminders: [],
+    conference_types: [],
+    data_owner: null,
+    ...over,
+  };
+}
+
+const overview: CalendarOverview = {
+  google_client_configured: true,
+  microsoft_client_configured: false,
+  accounts: [account],
+  calendars: [
+    calendar("me@x.com", { name: "Personal", is_primary: true }),
+    calendar("work", { name: "Work" }),
+  ],
+  last_sync: null,
+  window_days: 7,
+  mirror_start: "2020-01-01T00:00:00Z",
+  mirror_end: "2040-01-01T00:00:00Z",
+  editing: { [ME]: "on" },
+  default_length: {},
+};
+
+const today = dayKey(startOfDay(new Date()));
+
+const row = (over: Partial<CalendarEvent>): CalendarEvent => ({
+  id: "e1",
+  calendar_id: PERSONAL,
+  summary: "Standup",
+  description: null,
+  location: null,
+  start: `${today}T07:00:00`,
+  end: `${today}T07:30:00`,
+  all_day: false,
+  html_link: null,
+  uid: "u1",
+  ...over,
+});
+const standup = row({});
+
+const milestone: Milestone = {
+  id: 1,
+  project_name: "Garden",
+  label: "Plant bulbs",
+  due_date: today,
+  event_uid: null,
+  calendar_linked: false,
+  event_missing: false,
+  state: null,
+  status: null,
+  source_type: null,
+  external_id: null,
+  sort_order: 0,
+};
+
+const saved: WriteOutcome = { outcome: "saved", warnings: [], left_behind: [] };
+
+/** The mirror's reads, each answered when the test says (`reads[n]`), or all at once with `rows`. */
+let reads: ((rows: CalendarEvent[]) => void)[] = [];
+let held = false;
+let rows: CalendarEvent[] = [standup];
+// What the backend's "a write landed" event calls.
+let writeLanded: () => void = () => {};
+
+// jsdom ships no ResizeObserver; the box and the pickers' popovers build one.
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+});
+
+beforeEach(() => {
+  vi.resetModules();
+  localStorage.clear();
+  localStorage.setItem("pm.calendar.view", "agenda");
+  env.system = "slate";
+  env.hidden = new Set();
+  env.yearEvents = null;
+  reads = [];
+  held = false;
+  rows = [standup];
+  ipc.calendarOverview.mockResolvedValue(overview);
+  ipc.listAllCalendarEvents.mockImplementation(() =>
+    held ? new Promise<CalendarEvent[]>((r) => reads.push(r)) : Promise.resolve(rows),
+  );
+  ipc.listAllMilestones.mockResolvedValue([milestone]);
+  ipc.getPref.mockResolvedValue(null);
+  ipc.onCalendarSynced.mockResolvedValue(() => {});
+  ipc.onCalendarWriteLanded.mockImplementation((cb: () => void) => {
+    writeLanded = cb;
+    return Promise.resolve(() => {});
+  });
+  ipc.listHeldDeletes.mockResolvedValue([]);
+  ipc.onCalendarDeleteSettled.mockResolvedValue(() => {});
+  ipc.eventFlags.mockResolvedValue([]);
+});
+
+afterEach(() => {
+  cleanup();
+  vi.resetAllMocks();
+});
+
+/** The Calendar tab, fresh, once its first reads have landed. `Calendar` mounts it again (the same
+ *  module, as switching back to the tab does). The events and the calendars are read side by side:
+ *  the rest of those reads, and the effects that rebind the keys to the calendars, are let finish
+ *  too, since a key pressed before them would reach a handler with no calendars yet and open
+ *  nothing (the source of an occasional failure here). */
+async function mount(Calendar?: typeof import("./CalendarView").CalendarView) {
+  const View = Calendar ?? (await import("./CalendarView")).CalendarView;
+  const onOpenProject = vi.fn();
+  const onOpenPinboard = vi.fn();
+  const view = render(<View onOpenProject={onOpenProject} onOpenPinboard={onOpenPinboard} />);
+  await screen.findByRole("button", { name: /Standup/ });
+  await act(async () => {});
+  return { onOpenProject, onOpenPinboard, unmount: view.unmount, View };
+}
+
+const newEvent = () => screen.getByRole("button", { name: "+ New event" });
+const quick = () => screen.getByRole("dialog", { name: "New event" });
+const title = () => within(quick()).getByLabelText<HTMLInputElement>("Title");
+const ghost = () => document.querySelector<HTMLElement>("[data-draft-event]");
+const press = (key: string, shiftKey = false) =>
+  act(() => void fireEvent.keyDown(document.body, { key, shiftKey }));
+
+/** Shift+C, and a title typed. */
+function quickCreate(summary: string) {
+  press("C", true);
+  fireEvent.change(title(), { target: { value: summary } });
+}
+
+describe("CalendarView: a new event", () => {
+  it("Shift+C opens quick create, non-modal, under + New event; c the full editor", async () => {
+    await mount();
+    press("C", true);
+    expect(quick().getAttribute("aria-modal")).toBeNull();
+    await waitFor(() => expect(document.activeElement).toBe(title()));
+    fireEvent.click(within(quick()).getByRole("button", { name: "Discard" }));
+    expect(screen.queryByRole("dialog", { name: "New event" })).toBeNull();
+    expect(document.activeElement).toBe(newEvent());
+    press("c");
+    const editor = screen.getByRole("dialog", { name: "New event" });
+    expect(editor.getAttribute("aria-modal")).toBe("true");
+    expect(within(editor).getByRole("button", { name: "Save" })).toBeTruthy();
+  });
+
+  // Quick create's box is non-modal: the grid stays live. A milestone's jump would switch tabs and
+  // take the draft with it, and an event's details would be a second box with a second primary
+  // button, so a click on any event (the ghost too) goes back to the box instead.
+  it("with quick create open, a click on any event comes back to it", async () => {
+    const { onOpenProject } = await mount();
+    quickCreate("Dentist");
+    const drawn = ghost()!;
+    expect(drawn.getAttribute("aria-label")).toMatch(/^New event, not saved yet: .*Dentist$/);
+    for (const name of [/Plant bulbs · Garden/, /Standup/]) {
+      const target = screen.getByRole("button", { name });
+      target.focus();
+      fireEvent.click(target);
+      expect(document.activeElement).toBe(title());
+    }
+    drawn.focus();
+    fireEvent.click(drawn);
+    expect(document.activeElement).toBe(title());
+    expect(onOpenProject).not.toHaveBeenCalled();
+    // No details opened: the one dialog is the box.
+    expect(screen.getAllByRole("dialog")).toEqual([quick()]);
+    // With the box gone, an overlay's jump is back.
+    fireEvent.click(within(quick()).getByRole("button", { name: "Discard" }));
+    fireEvent.click(screen.getByRole("button", { name: /Plant bulbs · Garden/ }));
+    expect(onOpenProject).toHaveBeenCalledWith("Garden");
+  });
+
+  // More options blurs what it reads, so the full editor's focus trap remembers the page, not the
+  // box: closing it puts focus back on "+ New event", as the box's own close would have.
+  it("More options and then Cancel gives focus back to + New event", async () => {
+    await mount();
+    quickCreate("Dentist");
+    fireEvent.click(within(quick()).getByRole("button", { name: "More options" }));
+    const editor = screen.getByRole("dialog", { name: "New event" });
+    expect(editor.getAttribute("aria-modal")).toBe("true");
+    expect(within(editor).getByLabelText<HTMLInputElement>("Title").value).toBe("Dentist");
+    fireEvent.click(within(editor).getByRole("button", { name: "Cancel" }));
+    fireEvent.click(screen.getByRole("button", { name: "Discard" }));
+    await waitFor(() => expect(screen.queryByRole("dialog")).toBeNull());
+    expect(document.activeElement).toBe(newEvent());
+    expect(ipc.createCalendarEvent).not.toHaveBeenCalled();
+  });
+
+  // The save's own read of the mirror (the backend's "a write landed") can begin before its answer,
+  // so it may not hold the new row: the ghost stays for a read begun after the save, which closing
+  // the box starts. A click on the ghost meanwhile opens nothing: it isn't an event in the calendar.
+  it("a saved event's ghost stays until a read begun after the save lands", async () => {
+    const { onOpenProject } = await mount();
+    quickCreate("Dentist");
+    let answer: (o: WriteOutcome) => void = () => {};
+    ipc.createCalendarEvent.mockReturnValue(new Promise<WriteOutcome>((r) => (answer = r)));
+    held = true;
+    fireEvent.keyDown(title(), { key: "Enter" });
+    // While it's out, it may be made: never "not saved".
+    expect(ghost()!.getAttribute("aria-label")).toMatch(/^New event, saving: .*Dentist$/);
+    // The backend's read for the write starts before the answer.
+    act(() => writeLanded());
+    await act(async () => answer(saved));
+    expect(screen.queryByRole("dialog", { name: "New event" })).toBeNull();
+    const drawn = ghost()!;
+    expect(drawn.getAttribute("aria-label")).toMatch(/^New event, saved: .*Dentist$/);
+    // A click on it opens no details, and jumps nowhere.
+    fireEvent.click(drawn);
+    expect(screen.queryByRole("dialog")).toBeNull();
+    expect(onOpenProject).not.toHaveBeenCalled();
+    // Two reads out: the write's, and the one closing started. The first can't clear the ghost.
+    expect(reads).toHaveLength(2);
+    const made = row({ id: "e2", uid: "u2", summary: "Dentist", start: `${today}T23:00:00` });
+    await act(async () => reads[0]([standup, made]));
+    expect(ghost()).not.toBeNull();
+    // The newer read lands: the row is the calendar's own now, and the ghost has gone.
+    await act(async () => reads[1]([standup, made]));
+    expect(ghost()).toBeNull();
+    expect(screen.getByRole("button", { name: /Dentist/ }).hasAttribute("data-draft-event")).toBe(
+      false,
+    );
+  });
+
+  // The ghost joins after the hide filter (the box says the calendar is hidden), and only the views
+  // that draw it get it: the Year overview and the Terminal tables show what's in the calendar.
+  it("the ghost shows on a hidden calendar, and only in the views that draw it", async () => {
+    env.hidden = new Set([WORK_CAL]);
+    await mount();
+    quickCreate("Dentist");
+    fireEvent.click(within(quick()).getByRole("button", { name: "Calendar: Personal" }));
+    fireEvent.click(screen.getByRole("radio", { name: /^Work/ }), { detail: 1 });
+    expect(ghost()?.getAttribute("aria-label")).toMatch(/Dentist$/);
+    fireEvent.click(screen.getByRole("button", { name: "Year" }));
+    expect(env.yearEvents?.map((e) => e.id)).toContain("e1");
+    expect(env.yearEvents?.some((e) => e.summary === "Dentist")).toBe(false);
+    fireEvent.click(screen.getByRole("button", { name: "Agenda" }));
+    expect(ghost()).not.toBeNull();
+  });
+
+  it("the Terminal look draws no ghost", async () => {
+    env.system = "terminal";
+    await mount();
+    quickCreate("Dentist");
+    expect(ghost()).toBeNull();
+    expect(screen.queryByText("Dentist")).toBeNull();
+  });
+
+  // A click in the sidebar switches tabs (a titled box stays through a click), which takes the box
+  // with it: back on the calendar, it opens again on the same draft, nothing having been sent.
+  it("a titled quick create that went with the tab opens again when the calendar comes back", async () => {
+    const first = await mount();
+    quickCreate("Dentist");
+    first.unmount();
+    await act(async () => {});
+    await mount(first.View);
+    await waitFor(() => expect(title().value).toBe("Dentist"));
+    expect(ghost()?.getAttribute("aria-label")).toMatch(/^New event, not saved yet: .*Dentist$/);
+    expect(ipc.createCalendarEvent).not.toHaveBeenCalled();
+    // Once only: closed, it stays closed the next time.
+    fireEvent.click(within(quick()).getByRole("button", { name: "Discard" }));
+    cleanup();
+    await act(async () => {});
+    await mount(first.View);
+    expect(screen.queryByRole("dialog", { name: "New event" })).toBeNull();
+  });
+});
diff --git a/src/components/calendar/CalendarView.tsx b/src/components/calendar/CalendarView.tsx
index 9d9932f3..3cfc4866 100644
--- a/src/components/calendar/CalendarView.tsx
+++ b/src/components/calendar/CalendarView.tsx
@@ -10,7 +10,8 @@
 // on switch (respecting prefers-reduced-motion); ←/→/t drive navigation. A synced event opens its
 // detail popover, where a Google event PM may change offers Edit and Delete (#884; every change goes
 // through `edit/useEventWrites`); "+ New event" and `c` open the editor for a new one, on a calendar
-// the user picks (C10); everything else stays read-only. The two first-party overlays — project
+// the user picks, and Shift+C a quick box under the button, whose draft is drawn on the grid as it's
+// typed (C10); everything else stays read-only. The two first-party overlays — project
 // milestones (click opens their project) and freeform pinboard timeline entries (click opens the
 // Pinboard) — are each an all-day event in its own hue, injected here and never written back to any
 // calendar.
@@ -66,7 +67,10 @@ import { formatDateLocal } from "../../lib/format";
 import {
   addDays,
   dayKey,
+  draftEvent,
   eventDaySpan,
+  ghostAfterRead,
+  isDraftEvent,
   isMilestoneEvent,
   isOverlayEvent,
   isPinboardEvent,
@@ -75,6 +79,8 @@ import {
   PINBOARD_CALENDAR_ID,
   startOfDay,
   startOfWeek,
+  type DraftState,
+  type LandedGhost,
 } from "../../lib/calendar-layout";
 import { pinboardEntries, type PinboardEntry } from "../../lib/pinboard/calendarEntries";
 import { PINBOARD_PREF_KEY } from "../../lib/pinboard/types";
@@ -94,7 +100,8 @@ import { whenText } from "./parts/whenText";
 import { CalendarHeader } from "./CalendarHeader";
 import { DeleteEventDialog } from "./edit/DeleteEventDialog";
 import { EventEditor } from "./edit/EventEditor";
-import { NewEventEditor } from "./edit/NewEventEditor";
+import { NewEventEditor, type CreateHandover } from "./edit/NewEventEditor";
+import { QuickCreatePopover, type LeftDraft } from "./edit/QuickCreatePopover";
 import { WriteNotices } from "./edit/WriteNotices";
 import { undoLatest, useDeleteDialog, useEventWrites, useMirrorReads } from "./edit/useEventWrites";
 import { AgendaView } from "./views/AgendaView";
@@ -117,6 +124,12 @@ let cachedEvents: CalendarEvent[] = [];
 let cachedOverview: CalendarOverview | null = null;
 let cachedMilestones: Milestone[] = [];
 let cachedPinboard: PinboardEntry[] = [];
+// A quick-create draft whose box went with the tab, titled and with nothing sent (a click in the
+// sidebar switches tabs, and a titled box stays through a click): it opens again on return.
+let leftQuick: LeftDraft | null = null;
+const leaveQuick = (left: LeftDraft) => {
+  leftQuick = left;
+};
 
 /** How many days the grid shows for a view. Week is 7 by definition; Day is the user's chosen
  *  width (1-6). Anything else isn't a day grid. */
@@ -260,10 +273,22 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
     };
   }, []);
 
+  // A quick create that saved: its ghost (the new event as it was typed) stays until a read of the
+  // mirror that started after the save has landed, so the event doesn't blink out between the box
+  // closing and its row arriving (`ghostAfterRead`).
+  const [landed, setLanded] = useState<LandedGhost | null>(null);
+  const readsStarted = useRef(0);
+  const readEvents = useCallback(() => {
+    readsStarted.current += 1;
+    return listAllCalendarEvents();
+  }, []);
   const applyEvents = useCallback((evts: CalendarEvent[]) => {
     setEvents(evts);
     cachedEvents = evts;
     setEventsFailed(false);
+    // Only the newest read started is applied, so this is it.
+    const started = readsStarted.current;
+    setLanded((l) => ghostAfterRead(l, started));
   }, []);
   const eventsReadFailed = useCallback(() => {
     // Keep the last-good events; a read failure is transient. Flag it only when we have nothing to
@@ -273,7 +298,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
   // Only the newest read applies (an older in-flight one, e.g. a focus refresh, can't overwrite a
   // newer one that resolved first), and each is marked, so rows a delete hid are shown again only
   // by a read that knows how it ended. A delete that settles reads again.
-  const loadEvents = useMirrorReads(listAllCalendarEvents, applyEvents, eventsReadFailed);
+  const loadEvents = useMirrorReads(readEvents, applyEvents, eventsReadFailed);
 
   const loadMilestones = useCallback(async () => {
     try {
@@ -464,38 +489,116 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
   // The popover's own close, which hands focus back as its Escape does (it fills this in).
   const popoverCloseRef = useRef<(() => void) | null>(null);
 
-  // A new event being made (#884, C10): the editor's starting fields and calendar (null = closed).
-  const [creating, setCreating] = useState<{ seed: EditorFields; calendarId: string } | null>(null);
-  // The open editor's way to bring its title into focus: "+ New event" again focuses it, never
-  // replaces it.
+  // A new event being made (#884, C10): its starting fields and calendar, and where: the full editor,
+  // or quick create under "+ New event" (`anchor`, the button's rect), which More options turns into
+  // the full editor carrying its draft (`handover`), and which opens again on a draft that went with
+  // the tab (`resume`). Null = closed.
+  const [creating, setCreating] = useState<{
+    seed: EditorFields;
+    calendarId: string;
+    mode: "quick" | "full";
+    anchor: DOMRect | null;
+    handover?: CreateHandover;
+    resume?: LeftDraft;
+  } | null>(null);
+  // The open surface's way to bring its title into focus: "+ New event" again, or a click on the
+  // ghost, focuses it, never replaces it.
   const focusCreateRef = useRef<(() => void) | null>(null);
+  // "+ New event": quick create opens under it, and focus goes back to it when that closes.
+  const createButtonRef = useRef<HTMLButtonElement>(null);
+  // Quick create's draft as it's typed, and how far it has got, for the ghost on the grid. The ref is
+  // for its close, which turns the last of it into the ghost that waits for the saved row.
+  const [quickDraft, setQuickDraft] = useState<{
+    draft: EditorFields;
+    calendarId: string;
+    state: DraftState;
+  } | null>(null);
+  const quickDraftRef = useRef(quickDraft);
+  const onQuickDraft = useCallback((draft: EditorFields, calendarId: string, state: DraftState) => {
+    quickDraftRef.current = { draft, calendarId, state };
+    setQuickDraft(quickDraftRef.current);
+  }, []);
   // Where a new event can go. With no Google account there's no button at all; with one but no
   // calendar to take an event, the button says why.
   const targets = useMemo(() => (overview ? createTargets(overview) : null), [overview]);
   const hasGoogle = overview?.accounts.some((a) => a.provider === "google") ?? false;
   const createReason = overview && targets ? createReasonFor(overview, targets) : null;
-  // "+ New event" and `c`: the full editor, on the calendar last created in (else the primary), at
-  // the next half hour today when today is on screen, else at 09:00 on the day the view is on, for
-  // the account's own default length. Times are this computer's; without its zone, the calendar's
-  // (and then nothing can be saved, which the editor says).
-  const openCreate = useCallback(() => {
-    if (creating) {
-      focusCreateRef.current?.();
-      return;
-    }
-    if (!overview || !targets) return;
-    const target = defaultTarget(targets, readLastCreate());
-    if (!target) return;
-    const now = new Date();
-    const { start, end } = visibleRange(view, cursor, dayCount);
-    const today = startOfDay(now).getTime();
-    const day = today >= start.getTime() && today < end.getTime() ? now : cursor;
-    const zone = deviceTimeZoneOrNull() ?? target.calendar.time_zone ?? null;
+  // "+ New event" and `c` open the full editor; Shift+C quick create under the button (as Google's
+  // keys do; without the button on screen, the full editor). Either starts on the calendar last
+  // created in (else the primary), at the next half hour today when today is on screen, else at
+  // 09:00 on the day the view is on, for the account's own default length. Times are this
+  // computer's; without its zone, the calendar's (and then nothing can be saved, which they say).
+  const startCreate = useCallback(
+    (mode: "quick" | "full") => {
+      if (creating) {
+        focusCreateRef.current?.();
+        return;
+      }
+      if (!overview || !targets) return;
+      const target = defaultTarget(targets, readLastCreate());
+      if (!target) return;
+      const anchor =
+        mode === "quick" ? (createButtonRef.current?.getBoundingClientRect() ?? null) : null;
+      const now = new Date();
+      const { start, end } = visibleRange(view, cursor, dayCount);
+      const today = startOfDay(now).getTime();
+      const day = today >= start.getTime() && today < end.getTime() ? now : cursor;
+      const zone = deviceTimeZoneOrNull() ?? target.calendar.time_zone ?? null;
+      // A saved event's ghost still waiting for its row gives way to the new one.
+      setLanded(null);
+      setCreating({
+        seed: newEventSeed(dayKey(startOfDay(day)), now, zone, lengthFor(overview, target)),
+        calendarId: target.calendar.id,
+        mode: anchor ? mode : "full",
+        anchor,
+      });
+    },
+    [creating, overview, targets, view, cursor, dayCount],
+  );
+  const openCreate = useCallback(() => startCreate("full"), [startCreate]);
+
+  // Quick create closed: when it saved, its last draft stays drawn until a read that started after
+  // the save lands (one starts now: the read the save itself set off may have begun before it).
+  const onQuickClose = useCallback(
+    (saved: boolean) => {
+      const last = quickDraftRef.current;
+      const ev = saved && last ? draftEvent(last.draft, last.calendarId, "saved") : null;
+      if (ev) {
+        setLanded({ ev, after: readsStarted.current });
+        void loadEvents();
+      }
+      quickDraftRef.current = null;
+      setQuickDraft(null);
+      setCreating(null);
+    },
+    [loadEvents],
+  );
+  // More options: the full editor carries on with quick create's draft; nothing is sent.
+  const onQuickMore = useCallback((handover: CreateHandover) => {
+    quickDraftRef.current = null;
+    setQuickDraft(null);
+    setCreating((c) => (c ? { ...c, mode: "full", anchor: null, handover } : c));
+  }, []);
+
+  // Back on the calendar after a titled quick create went with the tab (`leftQuick`): the box opens
+  // again on that draft, on its calendar while that can still take an event (else the usual one). It
+  // opens with what's known at once (the overview kept from before), as the box did; a calendar on
+  // offer is a Google account's, so "+ New event" is there to open under.
+  useEffect(() => {
+    if (!overview || !targets || leftQuick === null) return;
+    const left = leftQuick;
+    leftQuick = null;
+    const target = defaultTarget(targets, left.calendarId);
+    const anchor = createButtonRef.current?.getBoundingClientRect();
+    if (!target || !anchor) return;
     setCreating({
-      seed: newEventSeed(dayKey(startOfDay(day)), now, zone, lengthFor(overview, target)),
+      seed: left.seed,
       calendarId: target.calendar.id,
+      mode: "quick",
+      anchor,
+      resume: left,
     });
-  }, [creating, overview, targets, view, cursor, dayCount]);
+  }, [overview, targets]);
 
   // One step per swipe, in the direction of travel: a swipe left (positive deltaX) moves forward, by
   // the days Settings chooses (`swipeDays`, read at the swipe). Both gestures move the cursor and
@@ -508,9 +611,10 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
   );
 
   // Keyboard nav while the tab is mounted: ← / → step the period, `t` jumps to today, `c` starts a
-  // new event (Shift+C too, until quick create comes). Ignored while a field is focused, a modifier is
-  // held (so app shortcuts and text entry are untouched), or a dialog or the event popover is open
-  // over the tab (see `calendarNavKey`). Ctrl/Cmd+Z is the delete's Undo (`calendarUndoKey`).
+  // new event in the full editor and Shift+C in quick create. Ignored while a field is focused, a
+  // modifier is held (so app shortcuts and text entry are untouched), or a dialog (quick create
+  // included) or the event popover is open over the tab (see `calendarNavKey`). Ctrl/Cmd+Z is the
+  // delete's Undo (`calendarUndoKey`).
   useEffect(() => {
     const onKey = (e: KeyboardEvent) => {
       // Ctrl/Cmd+Z presses the newest Undo on screen (a delete still waiting). Unlike the arrows it
@@ -533,14 +637,17 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
         onNext();
       } else if (nav === "today") {
         onToday();
-      } else if (nav === "create" || nav === "quick-create") {
+      } else if (nav === "create") {
         e.preventDefault();
-        openCreate();
+        startCreate("full");
+      } else if (nav === "quick-create") {
+        e.preventDefault();
+        startCreate("quick");
       }
     };
     window.addEventListener("keydown", onKey);
     return () => window.removeEventListener("keydown", onKey);
-  }, [onPrev, onNext, onToday, openCreate]);
+  }, [onPrev, onNext, onToday, startCreate]);
 
   const colorOf = useMemo(() => {
     const ids = overview?.calendars.map((c) => c.id) ?? [];
@@ -674,6 +781,24 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
     return out;
   }, [events, hidden, milestoneEvents, pinboardEvents, writes.hiddenIds, editingFor]);
 
+  // The new event's ghost (C10c): quick create's draft in its calendar's colour, saying how far it
+  // has got, or a saved one's waiting for its row. It joins after the hide filter, so it shows on a
+  // hidden calendar too (the box says that calendar is hidden), and in its own memo, so a title
+  // keystroke doesn't run the filter and dedup above again. Not while the full editor is open: that
+  // covers the grid.
+  const ghost = useMemo(() => {
+    if (creating?.mode === "quick") {
+      return quickDraft
+        ? draftEvent(quickDraft.draft, quickDraft.calendarId, quickDraft.state)
+        : null;
+    }
+    return landed?.ev ?? null;
+  }, [creating?.mode, quickDraft, landed]);
+  const shownEvents = useMemo(
+    () => (ghost ? [...visibleEvents, ghost] : visibleEvents),
+    [visibleEvents, ghost],
+  );
+
   // The popover's editing actions for `ev`. Delete closes the popover and asks first.
   // The event open in the editor (null = closed).
   const [editing, setEditing] = useState<CalendarEvent | null>(null);
@@ -700,9 +825,16 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
 
   // Clicking an event: a PM overlay keeps its jump (a milestone opens its project, a freeform pinboard
   // entry opens the Pinboard), while a real synced event opens the in-place detail popup anchored at
-  // the click. Every event is now clickable (was overlay-only).
+  // the click. Every event is now clickable (was overlay-only). While quick create is open, a click
+  // on any event (its own ghost included) goes back to it: an overlay's jump would switch tabs and
+  // lose the draft, and an event's details would be a second box with a second primary button.
+  const quickOpen = creating?.mode === "quick";
   const onEventClick = useCallback(
     (ev: CalendarEvent, anchor: DOMRect) => {
+      if (isDraftEvent(ev) || quickOpen) {
+        focusCreateRef.current?.();
+        return;
+      }
       if (isPinboardEvent(ev)) {
         onOpenPinboard?.();
         return;
@@ -715,7 +847,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
       }
       setEventPopup({ ev, anchor });
     },
-    [milestones, onOpenProject, onOpenPinboard],
+    [quickOpen, milestones, onOpenProject, onOpenPinboard],
   );
 
   // Both day grids are the same thing now — N consecutive days starting at the cursor. Week is
@@ -845,11 +977,13 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
           );
       }
     }
+    // The ghost of a new event joins the pixel views and the Agenda (`shownEvents`); the Year
+    // overview and the Terminal tables show what's in the calendar only.
     switch (view) {
       case "agenda":
         return (
           <AgendaView
-            events={visibleEvents}
+            events={shownEvents}
             fromDay={cursor}
             colorOf={colorOf}
             now={now}
@@ -860,7 +994,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
         return (
           <MonthView
             cursor={cursor}
-            events={visibleEvents}
+            events={shownEvents}
             colorOf={colorOf}
             shapeOf={shapeOf}
             onFocusDate={onFocusDate}
@@ -883,7 +1017,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
         return (
           <TimeGridView
             days={gridDays}
-            events={visibleEvents}
+            events={shownEvents}
             colorOf={colorOf}
             range={range}
             bounds={activeBounds}
@@ -924,6 +1058,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
         lastSync={overview?.last_sync ?? null}
         onCreate={hasGoogle ? openCreate : undefined}
         createReason={createReason}
+        createRef={createButtonRef}
       />
 
       {isTerminal && <TerminalChrome view={view} label={label} count={chromeCount} />}
@@ -1033,7 +1168,7 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
           onClose={() => setEditing(null)}
         />
       )}
-      {creating && overview && targets && (
+      {creating?.mode === "full" && overview && targets && (
         <NewEventEditor
           seed={creating.seed}
           targets={targets}
@@ -1043,7 +1178,33 @@ export function CalendarView({ onOpenProject, onOpenPinboard }: CalendarViewProp
           colorOf={colorOf}
           shapeOf={shapeOf}
           focusRef={focusCreateRef}
-          onClose={() => setCreating(null)}
+          handover={creating.handover}
+          onClose={() => {
+            // From quick create, the editor opened from its More options, which is gone: focus
+            // goes back to "+ New event", as quick create's own close would have sent it.
+            const fromQuick = creating.handover !== undefined;
+            setCreating(null);
+            if (fromQuick) createButtonRef.current?.focus();
+          }}
+        />
+      )}
+      {creating?.mode === "quick" && creating.anchor && overview && targets && (
+        <QuickCreatePopover
+          anchor={creating.anchor}
+          seed={creating.seed}
+          targets={targets}
+          calendarId={creating.calendarId}
+          overview={overview}
+          hidden={hidden}
+          colorOf={colorOf}
+          shapeOf={shapeOf}
+          returnFocusTo={createButtonRef}
+          focusRef={focusCreateRef}
+          resume={creating.resume}
+          onDraft={onQuickDraft}
+          onMore={onQuickMore}
+          onClose={onQuickClose}
+          onLeave={leaveQuick}
         />
       )}
       <DeleteEventDialog
diff --git a/src/components/calendar/edit/CalendarPicker.tsx b/src/components/calendar/edit/CalendarPicker.tsx
index 9f99c7a5..37126063 100644
--- a/src/components/calendar/edit/CalendarPicker.tsx
+++ b/src/components/calendar/edit/CalendarPicker.tsx
@@ -28,6 +28,8 @@ interface Props {
   colorOf: (calendarId: string) => string;
   shapeOf: (calendarId: string) => number | undefined;
   disabled?: boolean;
+  /** Quick create's size: a smaller button with the calendar's name only, and a shorter list. */
+  compact?: boolean;
 }
 
 /** Why an account's calendars aren't on offer, as one line. */
@@ -52,6 +54,7 @@ export function CalendarPicker({
   colorOf,
   shapeOf,
   disabled = false,
+  compact = false,
 }: Props) {
   const { showMeta } = useDepth();
   const [open, setOpen] = useState(false);
@@ -104,7 +107,7 @@ export function CalendarPicker({
         <Button
           ref={triggerRef}
           variant="secondary"
-          size="sm"
+          size={compact ? "xs" : "sm"}
           aria-label={`Calendar: ${label}`}
           aria-expanded={expanded}
           disabled={disabled}
@@ -118,14 +121,17 @@ export function CalendarPicker({
           )}
           <span className="truncate">
             {label}
-            {showMeta && account ? ` · ${account}` : ""}
+            {showMeta && !compact && account ? ` · ${account}` : ""}
           </span>
         </Button>
       )}
     >
       <div
         ref={listRef}
-        className="flex max-h-[60vh] flex-col gap-1 overflow-y-auto"
+        className={cn(
+          "flex flex-col gap-1 overflow-y-auto",
+          compact ? "max-h-[45vh]" : "max-h-[60vh]",
+        )}
         onKeyDown={(e) => {
           pointer.current = false;
           // Enter picks what the arrow keys moved to, as a click does; Tab leaves the list for the
diff --git a/src/components/calendar/edit/EventFields.tsx b/src/components/calendar/edit/EventFields.tsx
index 8a7f2814..cee52eab 100644
--- a/src/components/calendar/edit/EventFields.tsx
+++ b/src/components/calendar/edit/EventFields.tsx
@@ -42,6 +42,10 @@ const VISIBILITY: { value: EventVisibility; label: string }[] = [
 
 export const NO_ZONE =
   "PM couldn't tell which time zone this computer is in, so it can't change times. Set the time zone in your system settings.";
+/** A new event's line (the full editor's and quick create's): there nothing can be saved, which it
+ *  has to say. */
+export const NO_ZONE_CREATE =
+  "PM couldn't tell which time zone this computer is in, so it can't save a new event. Set the time zone in your system settings.";
 
 /** `date` (`YYYY-MM-DD`) moved by `days`. */
 function addDays(date: string, days: number): string {
diff --git a/src/components/calendar/edit/NewEventEditor.test.tsx b/src/components/calendar/edit/NewEventEditor.test.tsx
index 540d02cc..65d0928e 100644
--- a/src/components/calendar/edit/NewEventEditor.test.tsx
+++ b/src/components/calendar/edit/NewEventEditor.test.tsx
@@ -6,11 +6,13 @@
 // The full editor's create mode (#884, C10): one guard for every way to save (Save, Ctrl/Cmd+S,
 // Enter in the title), never on a repeat or while composing text, nothing editable or closable while
 // a save is out, an answer that never arrived shown locked as it was sent with Check again under the
-// same token, a token that ended unproven never called "nothing saved", a failure that keeps the
-// draft, the words that warn before a save PM's calendar won't show, a date it can't read 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.
+// same token, a token that ended unproven never called "nothing saved", what may be in Google left
+// as a notice once, when the editor really goes (under StrictMode too), a failure that keeps the
+// 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.
 
+import { StrictMode } 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 {
@@ -49,7 +51,7 @@ vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
   useTheme: () => ({ system: "slate", depth: "standard" }),
 }));
 
-import { NewEventEditor } from "./NewEventEditor";
+import { NewEventEditor, type CreateHandover } from "./NewEventEditor";
 
 const ME = "gcal:me@x.com";
 const WORK = "gcal:work@x.com";
@@ -164,9 +166,18 @@ afterEach(() => {
   vi.resetAllMocks();
 });
 
-function open(over: { calendarId?: string; hidden?: Set<string>; onClose?: () => void } = {}) {
+function open(
+  over: {
+    calendarId?: string;
+    hidden?: Set<string>;
+    onClose?: () => void;
+    handover?: CreateHandover;
+    /** Inside <StrictMode>, as the app's development build runs: every effect set up twice. */
+    strict?: boolean;
+  } = {},
+) {
   const onClose = over.onClose ?? vi.fn();
-  const view = render(
+  const editor = (
     <NewEventEditor
       seed={seed}
       targets={createTargets(overview)}
@@ -175,12 +186,33 @@ function open(over: { calendarId?: string; hidden?: Set<string>; onClose?: () =>
       hidden={over.hidden ?? new Set()}
       colorOf={() => "var(--accent)"}
       shapeOf={() => undefined}
+      handover={over.handover}
       onClose={onClose}
-    />,
+    />
   );
+  const view = render(over.strict ? <StrictMode>{editor}</StrictMode> : editor);
   return { onClose, unmount: view.unmount };
 }
 
+/** Unmount, and let what the editor leaves as it really goes (after StrictMode's rehearsal of an
+ *  unmount can no longer be the one) be said. */
+async function leave(unmount: () => void) {
+  unmount();
+  await act(async () => {});
+}
+
+/** What quick create hands over for `draft`, with nothing held, unproven or refused. */
+const handed = (draft: EditorFields, over: Partial<CreateHandover> = {}): CreateHandover => ({
+  draft,
+  calendarId: PERSONAL,
+  held: null,
+  unproven: null,
+  showAsTouched: false,
+  timeTouched: false,
+  badDate: null,
+  ...over,
+});
+
 const title = () => screen.getByLabelText<HTMLInputElement>("Title");
 
 /** Type `text` over what `input` shows, and leave it (a change to the same text is no change). */
@@ -395,8 +427,8 @@ describe("NewEventEditor", () => {
     expect(screen.queryByText("Discard this new event?")).toBeNull();
     expect(onClose).toHaveBeenCalled();
     expect(noteHeldCreate).not.toHaveBeenCalled();
-    unmount();
-    expect(noteHeldCreate).toHaveBeenCalledWith(sentFor("Dentist"), "ref-1");
+    await leave(unmount);
+    expect(noteHeldCreate.mock.calls).toEqual([[sentFor("Dentist"), "ref-1"]]);
   });
 
   it("an answer that arrives once the editor has gone is said as a notice", async () => {
@@ -406,7 +438,7 @@ describe("NewEventEditor", () => {
     fireEvent.change(title(), { target: { value: "Dentist" } });
     fireEvent.click(screen.getByRole("button", { name: "Save" }));
     // Gone with its tab while the save is out.
-    unmount();
+    await leave(unmount);
     expect(noteHeldCreate).not.toHaveBeenCalled();
     await act(async () => answer.answer(ambiguous));
     expect(noteCreateResult).toHaveBeenCalledWith(sentFor("Dentist"), null, ambiguous, {
@@ -415,6 +447,26 @@ describe("NewEventEditor", () => {
     });
   });
 
+  it("a first save with no answer at all once the editor has gone says it wasn't created", async () => {
+    const answer = later();
+    createEvent.mockReturnValue(answer.promise);
+    const { unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+    await leave(unmount);
+    // Turned down before it was sent (this window, the owner or the vault), and no token to keep.
+    await act(async () => answer.fail(new Error("The vault is locked.")));
+    expect(noteCreateResult.mock.calls).toEqual([
+      [
+        sentFor("Dentist"),
+        null,
+        { outcome: "failed", message: "The vault is locked." },
+        { name: "Personal", hidden: false },
+      ],
+    ]);
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+  });
+
   it("the notice shows for a start outside the mirror and for a hidden calendar", () => {
     open({ calendarId: WORK_CAL, hidden: new Set([WORK_CAL]) });
     expect(
@@ -461,6 +513,142 @@ describe("NewEventEditor", () => {
     expect(end().value).toBe("11:00");
   });
 
+  it("More options from quick create keeps the title, time and calendar", () => {
+    const draft: EditorFields = {
+      ...seed,
+      summary: "Dentist",
+      time: {
+        kind: "timed",
+        start_date: "2026-10-12",
+        start_time: "11:00",
+        start_zone: "Europe/London",
+        end_date: "2026-10-12",
+        end_time: "11:30",
+        end_zone: "Europe/London",
+      },
+    };
+    const { onClose } = open({
+      handover: handed(draft, { calendarId: WORK_CAL, timeTouched: true }),
+    });
+    expect(title().value).toBe("Dentist");
+    expect(screen.getByLabelText<HTMLSelectElement>("Start time").value).toBe("11:00");
+    expect(screen.getByLabelText<HTMLSelectElement>("End time").value).toBe("11:30");
+    expect(screen.getByRole("button", { name: "Calendar: Work" })).toBeTruthy();
+    // The time was the user's there, so the calendar's length leaves it alone here too.
+    pickCalendar("Work", "Personal");
+    expect(screen.getByLabelText<HTMLSelectElement>("End time").value).toBe("11:30");
+    // What was typed there counts as a change: closing asks first.
+    fireEvent.keyDown(window, { key: "Escape" });
+    expect(screen.getByText("Discard this new event?")).toBeTruthy();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("a retry token handed over opens locked on Check again under the same token", async () => {
+    createEvent.mockResolvedValue(saved);
+    const sent = sentFor("Dentist");
+    const { onClose } = open({
+      handover: handed({ ...seed, summary: "Dentist" }, { held: { token: "ref-1", sent } }),
+    });
+    expect(screen.getByText(/^PM may already have made “Dentist”/)).toBeTruthy();
+    expect(title().disabled).toBe(true);
+    fireEvent.click(screen.getByRole("button", { name: "Check again" }));
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls).toEqual([[PERSONAL, sent.draft, "ref-1"]]);
+  });
+
+  // Quick create's token ended unproven before More options: its words go on here, as they would
+  // have gone on there.
+  it("words handed over from a token that ended unproven are said, asked with, and left on close", async () => {
+    const sent = sentFor("Dentist");
+    const { onClose, unmount } = open({
+      handover: handed({ ...seed, summary: "Dentist" }, { unproven: { sent, outcome: lost } }),
+    });
+    const words =
+      "PM lost touch with Google and can't tell whether “Dentist” was made. Look for it in Google Calendar before creating it again, so it isn't made twice.";
+    expect(screen.getByText(words)).toBeTruthy();
+    expect(title().disabled).toBe(false);
+    fireEvent.keyDown(window, { key: "Escape" });
+    const confirm = screen.getByRole("dialog", { name: "Discard this new event?" });
+    expect(confirm.textContent).not.toContain("Nothing has been saved");
+    expect(within(confirm).getByText(words)).toBeTruthy();
+    fireEvent.click(within(confirm).getByRole("button", { name: "Discard" }));
+    expect(onClose).toHaveBeenCalled();
+    await leave(unmount);
+    expect(noteCreateResult.mock.calls).toEqual([
+      [sent, null, lost, { name: "Personal", hidden: false }],
+    ]);
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  // The app's development build runs every new mount's effects as setup, cleanup, setup. An editor
+  // opened on quick create's token or words holds them from its first render, so only a real unmount
+  // may leave them: once, and not while the editor still says them itself.
+  it("under StrictMode, a handed-over token is left as a notice once, and only when it goes", async () => {
+    const sent = sentFor("Dentist");
+    const { unmount } = open({
+      strict: true,
+      handover: handed({ ...seed, summary: "Dentist" }, { held: { token: "ref-1", sent } }),
+    });
+    await act(async () => {});
+    expect(screen.getByRole("button", { name: "Check again" })).toBeTruthy();
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+    expect(noteCreateResult).not.toHaveBeenCalled();
+    await leave(unmount);
+    expect(noteHeldCreate.mock.calls).toEqual([[sent, "ref-1"]]);
+    expect(noteCreateResult).not.toHaveBeenCalled();
+  });
+
+  it("under StrictMode, handed-over words are left as a notice once, and only when it goes", async () => {
+    const sent = sentFor("Dentist");
+    const { unmount } = open({
+      strict: true,
+      handover: handed({ ...seed, summary: "Dentist" }, { unproven: { sent, outcome: lost } }),
+    });
+    await act(async () => {});
+    expect(screen.getByText(/^PM lost touch with Google/)).toBeTruthy();
+    expect(noteCreateResult).not.toHaveBeenCalled();
+    await leave(unmount);
+    expect(noteCreateResult.mock.calls).toEqual([
+      [sent, null, lost, { name: "Personal", hidden: false }],
+    ]);
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+  });
+
+  // Quick create's date field refused what was typed and put its date back: More options carries the
+  // refusal here, on the start's field, so the date put back is never what's saved.
+  it("a date quick create couldn't read refuses every save here until the start is given one", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open({
+      handover: handed(
+        { ...seed, summary: "Dentist" },
+        { badDate: "31-02-2026", timeTouched: true },
+      ),
+    });
+    const refused = () => screen.queryByText(/^Start date: “31-02-2026” isn't a date PM can read/);
+    expect(refused()).not.toBeNull();
+    const start = screen.getByLabelText<HTMLInputElement>("Start date");
+    expect(start.getAttribute("aria-invalid")).toBe("true");
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    // The save it stopped put focus on the field it names.
+    expect(document.activeElement).toBe(start);
+    // The end's date is the other half: it doesn't end the start's refusal.
+    const end = screen.getByLabelText<HTMLInputElement>("End date");
+    end.focus();
+    fireEvent.change(end, { target: { value: "14-10-2026" } });
+    fireEvent.blur(end);
+    expect(refused()).not.toBeNull();
+    start.focus();
+    fireEvent.change(start, { target: { value: "13-10-2026" } });
+    fireEvent.blur(start);
+    expect(refused()).toBeNull();
+    fireEvent.click(screen.getByRole("button", { name: "Save" }));
+    await waitFor(() => expect(onClose).toHaveBeenCalled());
+    expect(createEvent.mock.calls[0][1].time).toMatchObject({ start_date: "2026-10-13" });
+  });
+
   it("Private is disabled on a no-private calendar", () => {
     open({ calendarId: FAMILY });
     const visibility = screen.getByLabelText<HTMLSelectElement>("Visibility");
@@ -510,7 +698,7 @@ describe("NewEventEditor", () => {
     fireEvent.click(within(confirm).getByRole("button", { name: "Discard" }));
     expect(onClose).toHaveBeenCalled();
     expect(noteCreateResult).not.toHaveBeenCalled();
-    unmount();
+    await leave(unmount);
     expect(noteCreateResult.mock.calls).toEqual([
       [sentFor("Dentist"), null, lost, { name: "Personal", hidden: false }],
     ]);
@@ -528,11 +716,10 @@ describe("NewEventEditor", () => {
     fireEvent.keyDown(window, { key: "Escape" });
     expect(screen.queryByText("Discard this new event?")).toBeNull();
     expect(onClose).toHaveBeenCalled();
-    unmount();
-    expect(noteCreateResult).toHaveBeenCalledWith(sentFor(""), null, gone, {
-      name: "Personal",
-      hidden: false,
-    });
+    await leave(unmount);
+    expect(noteCreateResult.mock.calls).toEqual([
+      [sentFor(""), null, gone, { name: "Personal", hidden: false }],
+    ]);
   });
 
   it("made again after the look-first words, it says Created and nothing more", async () => {
@@ -546,7 +733,7 @@ describe("NewEventEditor", () => {
     fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
     fireEvent.click(await screen.findByRole("button", { name: "Save" }));
     await waitFor(() => expect(onClose).toHaveBeenCalled());
-    unmount();
+    await leave(unmount);
     // A new create, under no token, and only its Created.
     expect(createEvent.mock.calls.map((c) => c[2])).toEqual([null, "ref-1", null]);
     expect(noteCreateResult.mock.calls).toEqual([
@@ -563,7 +750,7 @@ describe("NewEventEditor", () => {
     fireEvent.change(title(), { target: { value: "Dentist" } });
     fireEvent.click(screen.getByRole("button", { name: "Save" }));
     fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
-    unmount();
+    await leave(unmount);
     // The save still out says how it ended, not the close.
     expect(noteHeldCreate).not.toHaveBeenCalled();
     await act(async () => check.answer(busy));
@@ -579,7 +766,7 @@ describe("NewEventEditor", () => {
     fireEvent.change(title(), { target: { value: "Dentist" } });
     fireEvent.click(screen.getByRole("button", { name: "Save" }));
     fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
-    unmount();
+    await leave(unmount);
     await act(async () => check.fail(new Error("The app's channel closed.")));
     expect(noteHeldCreate.mock.calls).toEqual([[sentFor("Dentist"), "ref-1"]]);
     expect(noteCreateResult).not.toHaveBeenCalled();
@@ -848,7 +1035,7 @@ describe("NewEventEditor", () => {
     expect(within(confirm).getByText("Nothing has been saved to Google yet.")).toBeTruthy();
     fireEvent.click(within(confirm).getByRole("button", { name: "Discard" }));
     expect(onClose).toHaveBeenCalled();
-    unmount();
+    await leave(unmount);
     expect(noteCreateResult).not.toHaveBeenCalled();
     expect(noteHeldCreate).not.toHaveBeenCalled();
   });
diff --git a/src/components/calendar/edit/NewEventEditor.tsx b/src/components/calendar/edit/NewEventEditor.tsx
index 4d0d7293..abc6c808 100644
--- a/src/components/calendar/edit/NewEventEditor.tsx
+++ b/src/components/calendar/edit/NewEventEditor.tsx
@@ -5,6 +5,7 @@
 // sibling of `EventEditor` sharing its fields (`EventFields`), with nothing to load, no session, no
 // conflicts and nothing to delete: the same dialog and checks, and a calendar picker where editing
 // names the calendar it saves to. Save, Ctrl+S (⌘S on a Mac) and Enter in the title all save.
+// Quick create's More options opens it on that draft (`handover`), sending nothing on the way.
 //
 // A new event never goes twice by accident. Every way to save passes one guard, set before the
 // request goes; while it's out, every field, the picker and closing are off, and a held key's
@@ -52,23 +53,24 @@ import {
   ambiguousText,
   CALLOUT_TONE,
   createText,
+  heldCreateText,
   problemText,
   retryAfter,
   type Tone,
 } from "../../../lib/calendarEdit/editReasons";
 import {
   createdWhere,
+  createNotes,
   lengthFor,
-  outsideMirror,
   targetById,
   type CreateTargets,
 } from "../../../lib/calendarEdit/createTargets";
 import { isLetterKey } from "../../../lib/letterKey";
-import { formatDateLocal } from "../../../lib/format";
 import { deviceTimeZoneOrNull } from "../../../theme";
 import { Button, Callout, ConfirmDialog, Dialog } from "../../ui";
 import { CalendarPicker } from "./CalendarPicker";
 import {
+  NO_ZONE_CREATE,
   ShowAsControl,
   TextRow,
   VisibilitySelect,
@@ -93,9 +95,30 @@ interface Props {
   /** Filled in with a way to bring this editor's title into focus: a second "+ New event" focuses
    *  the one open rather than replacing it. */
   focusRef?: MutableRefObject<(() => void) | null>;
+  /** Quick create's "More options": its draft and calendar to carry on with (`seed` and
+   *  `calendarId` stay where it started, for "changed?"), an answer that never arrived, which opens
+   *  locked on Check again under the same token, the words of a token that ended unproven, and a
+   *  date its field couldn't read, still refusing. */
+  handover?: CreateHandover;
   onClose: () => void;
 }
 
+/** What quick create hands the full editor (C10c): nothing is sent on the way. */
+export interface CreateHandover {
+  draft: EditorFields;
+  calendarId: string;
+  /** A create PM may already have made: its retry token and exactly what was sent. */
+  held: { token: string; sent: CreateSent } | null;
+  /** A token that ended there without Google showing the event made: its words carry on here. */
+  unproven: Unproven | null;
+  /** Whether the user picked Show as, or changed the time, there. */
+  showAsTouched: boolean;
+  timeTouched: boolean;
+  /** 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;
+}
+
 /** An answer that never arrived: its retry token, exactly what was sent, and the fields that were. */
 interface Held {
   token: string;
@@ -105,15 +128,12 @@ interface Held {
 
 /** A held token that ended without Google showing the event made (PM lost it, the draft differed,
  *  or it was made and since deleted): what was sent, and the answer that ended it. */
-interface Unproven {
+export interface Unproven {
   sent: CreateSent;
   outcome: WriteOutcome;
 }
 
 const PRIVATE_OFF = "This calendar's sharing doesn't let you make private events on it.";
-// The edit mode's line says times can't change; here nothing can be saved, which it has to say.
-const NO_ZONE_CREATE =
-  "PM couldn't tell which time zone this computer is in, so it can't save a new event. Set the time zone in your system settings.";
 
 const message = (e: unknown) => (e instanceof Error ? e.message : String(e));
 
@@ -126,18 +146,23 @@ export function NewEventEditor({
   colorOf,
   shapeOf,
   focusRef,
+  handover,
   onClose,
 }: Props) {
   const deviceZone = useMemo(() => deviceTimeZoneOrNull(), []);
-  const [draft, setDraftState] = useState<EditorFields>(seed);
+  const startDraft = handover?.draft ?? seed;
+  const startCalendar = handover?.calendarId ?? firstCalendar;
+  const [draft, setDraftState] = useState<EditorFields>(startDraft);
   // The latest draft and calendar, readable synchronously: Save blurs the focused field first, and a
   // date typed but not yet committed commits in that blur, before React re-renders.
-  const draftRef = useRef<EditorFields>(seed);
-  const [calendarId, setCalendarIdState] = useState(firstCalendar);
-  const calendarRef = useRef(firstCalendar);
+  const draftRef = useRef<EditorFields>(startDraft);
+  const [calendarId, setCalendarIdState] = useState(startCalendar);
+  const calendarRef = useRef(startCalendar);
   // Text a date field couldn't read, by the half it sets: no save until that field is given a date.
-  const badDatesRef = useRef<BadDates>(NO_BAD_DATES);
-  const [badDates, setBadDatesState] = useState<BadDates>(NO_BAD_DATES);
+  // Quick create's one date field sets the start.
+  const startBad: BadDates = { ...NO_BAD_DATES, start: handover?.badDate ?? null };
+  const badDatesRef = useRef<BadDates>(startBad);
+  const [badDates, setBadDatesState] = useState<BadDates>(startBad);
   const setBadDates = (next: BadDates) => {
     badDatesRef.current = next;
     setBadDatesState(next);
@@ -145,21 +170,31 @@ export function NewEventEditor({
   // The When fields' own, so a save a refusal stops can find the date field it names.
   const whenId = useId();
   // The event's length, kept while its start moves: the account's default to begin with.
-  const lengthRef = useRef(lengthFor(overview, targetById(targets, firstCalendar)));
+  const lengthRef = useRef(lengthFor(overview, targetById(targets, startCalendar)));
   // Whether the user has changed the time: until then, another calendar brings its own length.
-  const timeTouched = useRef(false);
+  const timeTouched = useRef(handover?.timeTouched ?? false);
   // Whether the user has picked Show as: until then, it follows the kind (all day free).
-  const showAsTouched = useRef(false);
-  const [banner, setBanner] = useState<{ tone: Tone; text: string } | null>(null);
+  const showAsTouched = useRef(handover?.showAsTouched ?? false);
+  // Handed over while PM may already have made it: locked on what was sent, saying so; or after a
+  // token ended unproven there, still saying that.
+  const handedHeld: Held | null = handover?.held
+    ? { ...handover.held, fields: handover.draft }
+    : null;
+  const [banner, setBanner] = useState<{ tone: Tone; text: string } | null>(() => {
+    if (handedHeld) return heldCreateText(handedHeld.sent.draft.summary);
+    const u = handover?.unproven;
+    return u ? createText(u.outcome, u.sent.draft.summary, false) : null;
+  });
   // The one guard every way to save passes, set before the request goes (state alone would let a
   // second Enter in the same tick through).
   const savingRef = useRef(false);
   const [saving, setSaving] = useState(false);
-  const heldRef = useRef<Held | null>(null);
-  const [held, setHeldState] = useState<Held | null>(null);
-  // PM may have made an event this editor sent, though no token is held for it any more.
-  const unprovenRef = useRef<Unproven | null>(null);
-  const [unproven, setUnprovenState] = useState<Unproven | null>(null);
+  const heldRef = useRef<Held | null>(handedHeld);
+  const [held, setHeldState] = useState<Held | null>(handedHeld);
+  // PM may have made an event this editor (or quick create, before it) sent, though no token is held
+  // for it any more.
+  const unprovenRef = useRef<Unproven | null>(handover?.unproven ?? null);
+  const [unproven, setUnprovenState] = useState<Unproven | null>(handover?.unproven ?? null);
   const [askDiscard, setAskDiscardState] = useState(false);
   const askDiscardRef = useRef(false);
   const [zonePick, setZonePick] = useState<"both" | "start" | "end" | null>(null);
@@ -222,13 +257,20 @@ export function NewEventEditor({
     alive.current = true;
     return () => {
       alive.current = false;
+      // What the editor held as it went, said only once it has really gone: StrictMode rehearses an
+      // unmount in development (a cleanup straight followed by a setup, which sets `alive` again
+      // before this runs), and an editor opened on quick create's token or words holds them from
+      // its first render, so a rehearsal would say them while it's still open.
       const u = unprovenRef.current;
-      if (u) {
-        const where = createdWhere(overviewRef.current, hiddenRef.current, u.sent.calendarId);
-        noteCreateResult(u.sent, null, u.outcome, where);
-      }
-      const h = heldRef.current;
-      if (h && !savingRef.current) noteHeldCreate(h.sent, h.token);
+      const h = savingRef.current ? null : heldRef.current;
+      queueMicrotask(() => {
+        if (alive.current) return;
+        if (u) {
+          const where = createdWhere(overviewRef.current, hiddenRef.current, u.sent.calendarId);
+          noteCreateResult(u.sent, null, u.outcome, where);
+        }
+        if (h) noteHeldCreate(h.sent, h.token);
+      });
     };
   }, []);
 
@@ -428,25 +470,11 @@ 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 where = createdWhere(overview, hidden, calendarId);
-  const outside = outsideMirror(draft.time, overview);
-  const range = `${formatDateLocal(new Date(overview.mirror_start))} – ${formatDateLocal(
-    new Date(overview.mirror_end),
-  )}`;
   // 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] : []),
-    ...(outside
-      ? [
-          `This starts outside the months PM syncs (${range}), so it'll be saved in Google but won't show here.`,
-        ]
-      : []),
-    ...(hidden.has(calendarId) && where.hidden
-      ? [
-          `${where.name} is hidden in your calendar list, so the new event won't show until you show that calendar again.`,
-        ]
-      : []),
+    ...createNotes(draft.time, overview, hidden, calendarId),
     ...(noPrivate ? [PRIVATE_OFF] : []),
   ];
 
diff --git a/src/components/calendar/edit/QuickCreatePopover.test.tsx b/src/components/calendar/edit/QuickCreatePopover.test.tsx
new file mode 100644
index 00000000..1021a60f
--- /dev/null
+++ b/src/components/calendar/edit/QuickCreatePopover.test.tsx
@@ -0,0 +1,1019 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// Quick create (#884, C10c): Enter saves (never on a repeat or while composing text), More options
+// hands the draft to the full editor without sending anything, a click outside or Escape closes only
+// an empty draft (and Escape only with focus in the box), a click in a picker it opened or on its
+// ghost isn't outside, it registers as a dialog layer without being modal, while a save is out
+// nothing sends, closes or hands over again, a token that ended unproven is never dropped silently,
+// a date it can't read refuses until the field is given one (the field named, marked, and where a
+// 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.
+
+import { createRef, StrictMode } 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 {
+  Calendar,
+  CalendarAccount,
+  CalendarOverview,
+  NewEventDraft,
+  WriteOutcome,
+} from "../../../lib/types";
+import { CREATE_LOST } from "../../../lib/calendarEdit/editReasons";
+import type { EditorFields } from "../../../lib/calendarEdit/eventDraft";
+import { createTargets } from "../../../lib/calendarEdit/createTargets";
+import { isAnyDialogOpen } from "../../../lib/useDialogLayer";
+import { Popover } from "../../ui";
+
+const createEvent =
+  vi.fn<
+    (calendarId: string, draft: NewEventDraft, token: string | null) => Promise<WriteOutcome>
+  >();
+const noteCreateResult = vi.fn();
+const noteHeldCreate = vi.fn();
+let deviceZone: string | null = "Europe/London";
+
+vi.mock("./useEventWrites", async (importOriginal) => ({
+  // The rest as it is, for the write notices drawn beside the box.
+  ...(await importOriginal<object>()),
+  // Every argument passes through, so an extra one, or a dropped token, shows in the calls.
+  createEvent: (...a: [string, NewEventDraft, string | null]) => createEvent(...a),
+  noteCreateResult: (...a: unknown[]) => noteCreateResult(...a),
+  noteHeldCreate: (...a: unknown[]) => noteHeldCreate(...a),
+}));
+
+vi.mock("../../../theme/timezones", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  deviceTimeZoneOrNull: () => deviceZone,
+}));
+
+vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth: "standard" }),
+}));
+
+import { QuickCreatePopover, type LeftDraft } from "./QuickCreatePopover";
+import { WriteNotices } from "./WriteNotices";
+
+const ME = "gcal:me@x.com";
+const WORK = "gcal:work@x.com";
+const PERSONAL = `${ME}:me@x.com`;
+const WORK_CAL = `${WORK}:work@x.com`;
+
+function account(id: string): CalendarAccount {
+  const email = id.slice(id.indexOf(":") + 1);
+  return { id, provider: "google", email, label: email, state: "ok", last_synced_at: null };
+}
+
+function calendar(source: string, remote: string, over: Partial<Calendar> = {}): Calendar {
+  return {
+    id: `${source}:${remote}`,
+    source_id: source,
+    provider: "google",
+    remote_id: remote,
+    name: remote,
+    color: null,
+    selected: true,
+    is_primary: false,
+    quiet: false,
+    kind: null,
+    access_role: "owner",
+    time_zone: "Europe/London",
+    default_reminders: [],
+    conference_types: [],
+    data_owner: null,
+    ...over,
+  };
+}
+
+const overview: CalendarOverview = {
+  google_client_configured: true,
+  microsoft_client_configured: false,
+  accounts: [account(ME), account(WORK)],
+  calendars: [
+    calendar(ME, "me@x.com", { name: "Personal", is_primary: true }),
+    calendar(WORK, "work@x.com", { name: "Work", is_primary: true }),
+  ],
+  last_sync: null,
+  window_days: 7,
+  mirror_start: "2026-09-01T00:00:00Z",
+  mirror_end: "2027-11-01T00:00:00Z",
+  editing: { [ME]: "on", [WORK]: "on" },
+  // Work's account makes half-hour events; Personal's has none read, so an hour.
+  default_length: { [WORK]: 30 },
+};
+
+const seed: EditorFields = {
+  summary: "",
+  location: "",
+  description: "",
+  time: {
+    kind: "timed",
+    start_date: "2026-10-12",
+    start_time: "09:00",
+    start_zone: "Europe/London",
+    end_date: "2026-10-12",
+    end_time: "10:00",
+    end_zone: "Europe/London",
+  },
+  show_as: "busy",
+  visibility: "default",
+};
+
+/** What the box sends for the seed titled `summary`, on Personal. */
+const sentFor = (summary: string) => ({
+  calendarId: PERSONAL,
+  draft: { ...seed, summary } as NewEventDraft,
+});
+
+const saved: WriteOutcome = { outcome: "saved", warnings: [], left_behind: [] };
+const ambiguous: WriteOutcome = { outcome: "ambiguous", retry_token: "ref-1" };
+
+/** The header button's rect, as the calendar hands it over. */
+const rect = (): DOMRect =>
+  ({
+    left: 40,
+    top: 10,
+    right: 140,
+    bottom: 38,
+    width: 100,
+    height: 28,
+    x: 40,
+    y: 10,
+    toJSON: () => ({}),
+  }) as DOMRect;
+
+/** A promise whose answer (or failure) the test gives when it chooses. */
+function later() {
+  let answer: (o: WriteOutcome) => void = () => {};
+  let fail: (e: Error) => void = () => {};
+  const promise = new Promise<WriteOutcome>((resolve, reject) => {
+    answer = resolve;
+    fail = reject;
+  });
+  return { promise, answer, fail };
+}
+
+const lost: WriteOutcome = { outcome: "failed", message: CREATE_LOST };
+const unreachable: WriteOutcome = { outcome: "failed", message: "PM couldn't reach Google." };
+const LIST = { name: "Calendars that can take a new event" };
+const WHERE = { name: "Personal", hidden: false };
+
+// jsdom ships no ResizeObserver; the box and the pickers' popovers build one.
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+});
+
+beforeEach(() => {
+  deviceZone = "Europe/London";
+});
+
+afterEach(() => {
+  cleanup();
+  // Reset, not clear: an answer one test queued and never used must not reach the next.
+  vi.resetAllMocks();
+});
+
+/** The box under a stand-in header button, beside a stand-in grid with the ghost on it, and, when
+ *  asked, another popover open elsewhere on the page, a draft to carry on with, or <StrictMode>
+ *  around it all (as the app's development build runs: every effect set up twice). */
+function open(
+  over: {
+    otherPopover?: boolean;
+    resume?: LeftDraft;
+    calendarId?: string;
+    strict?: boolean;
+  } = {},
+) {
+  const onClose = vi.fn();
+  const onMore = vi.fn();
+  const onDraft = vi.fn();
+  const onLeave = vi.fn();
+  const header = createRef<HTMLButtonElement>();
+  const focusRef: { current: (() => void) | null } = { current: null };
+  const page = (
+    <>
+      <button ref={header} type="button">
+        + New event
+      </button>
+      <div data-testid="grid">
+        <div data-draft-event="" data-testid="ghost">
+          (no title)
+        </div>
+        <button type="button">Synced</button>
+      </div>
+      {over.otherPopover && (
+        <Popover
+          ariaLabel="Another popover"
+          trigger={({ toggle }) => (
+            <button type="button" onClick={toggle}>
+              Other
+            </button>
+          )}
+        >
+          <button type="button">Inside the other</button>
+        </Popover>
+      )}
+      <QuickCreatePopover
+        anchor={rect()}
+        seed={seed}
+        targets={createTargets(overview)}
+        calendarId={over.calendarId ?? PERSONAL}
+        overview={overview}
+        hidden={new Set()}
+        colorOf={() => "var(--accent)"}
+        shapeOf={() => undefined}
+        returnFocusTo={header}
+        focusRef={focusRef}
+        resume={over.resume}
+        onDraft={onDraft}
+        onMore={onMore}
+        onClose={onClose}
+        onLeave={onLeave}
+      />
+    </>
+  );
+  const view = render(over.strict ? <StrictMode>{page}</StrictMode> : page);
+  return { onClose, onMore, onDraft, onLeave, header, focusRef, unmount: view.unmount };
+}
+
+/** Unmount, and let what the box leaves as it really goes (after StrictMode's rehearsal of an
+ *  unmount can no longer be the one) be said. */
+async function leave(unmount: () => void) {
+  unmount();
+  await act(async () => {});
+}
+
+const title = () => screen.getByLabelText<HTMLInputElement>("Title");
+const outside = () => fireEvent.mouseDown(screen.getByTestId("grid"));
+const box = () => screen.getByRole("dialog", { name: "New event" });
+
+/** An element's one z-index utility, as a number (`z-50`, `z-[45]`). jsdom paints nothing, so the
+ *  stacking is read from the classes. */
+function zOf(el: Element | null): number {
+  const z = Array.from(el?.classList ?? [])
+    .map((c) => /^z-\[?(\d+)\]?$/.exec(c))
+    .filter((m) => m !== null);
+  expect(z).toHaveLength(1);
+  return Number(z[0]![1]);
+}
+
+describe("QuickCreatePopover", () => {
+  it("Enter in the title creates with no notify and closes on saved", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose, header } = open();
+    expect(document.activeElement).toBe(title());
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    // The calendar, every field of the draft, and no token: no one to notify, no guests.
+    expect(createEvent.mock.calls).toEqual([[PERSONAL, sentFor("Dentist").draft, null]]);
+    expect(Object.keys(createEvent.mock.calls[0][1]).sort()).toEqual([
+      "description",
+      "location",
+      "show_as",
+      "summary",
+      "time",
+      "visibility",
+    ]);
+    expect(noteCreateResult).toHaveBeenCalledWith(sentFor("Dentist"), null, saved, {
+      name: "Personal",
+      hidden: false,
+    });
+    // Back to "+ New event", which Shift+C never focused.
+    expect(document.activeElement).toBe(header.current);
+  });
+
+  it("Shift+Enter, Ctrl+Enter and Enter while composing don't save", async () => {
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter", shiftKey: true });
+    fireEvent.keyDown(title(), { key: "Enter", ctrlKey: true });
+    fireEvent.keyDown(title(), { key: "Enter", isComposing: true });
+    // WebKit's Enter that ends a composition comes after it, marked only by its key code.
+    fireEvent.keyDown(title(), { key: "Enter", keyCode: 229 });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("More options hands over the draft without saving", () => {
+    const { onMore, onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "11:00" } });
+    fireEvent.click(screen.getByRole("button", { name: "More options" }));
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(onClose).not.toHaveBeenCalled();
+    expect(onMore).toHaveBeenCalledWith({
+      draft: {
+        ...seed,
+        summary: "Dentist",
+        time: { ...seed.time, start_time: "11:00", end_time: "12:00" },
+      },
+      calendarId: PERSONAL,
+      held: null,
+      unproven: null,
+      showAsTouched: false,
+      timeTouched: true,
+      badDate: null,
+    });
+  });
+
+  it("an outside click discards only an empty title", () => {
+    const first = open();
+    outside();
+    expect(first.onClose).toHaveBeenCalledWith(false);
+    // An outside click put focus where it was aimed: it isn't pulled back to the button.
+    expect(document.activeElement).not.toBe(first.header.current);
+    cleanup();
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    outside();
+    expect(onClose).not.toHaveBeenCalled();
+    // Spaces alone aren't a title.
+    fireEvent.change(title(), { target: { value: "   " } });
+    outside();
+    expect(onClose).toHaveBeenCalledWith(false);
+  });
+
+  it("a click on its ghost on the grid isn't outside", () => {
+    const { onClose } = open();
+    fireEvent.mouseDown(screen.getByTestId("ghost"));
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it("a click inside the date picker is not outside, and a picked date keeps the box", () => {
+    const { onClose, onDraft } = open();
+    fireEvent.click(screen.getByLabelText("Date"));
+    const day = screen.getByRole("button", { name: /\b14-10(-2026)?$/ });
+    fireEvent.mouseDown(day);
+    fireEvent.click(day);
+    expect(onClose).not.toHaveBeenCalled();
+    expect(screen.getByRole("dialog", { name: "New event" })).toBeTruthy();
+    // The event moved whole, and the ghost with it.
+    const [draft] = onDraft.mock.lastCall!;
+    expect(draft.time).toEqual({ ...seed.time, start_date: "2026-10-14", end_date: "2026-10-14" });
+  });
+
+  it("Escape keeps a titled draft and closes an empty one; ✕ discards either", () => {
+    const first = open();
+    fireEvent.keyDown(title(), { key: "Escape" });
+    expect(first.onClose).toHaveBeenCalledWith(false);
+    expect(document.activeElement).toBe(first.header.current);
+    cleanup();
+    const second = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Escape" });
+    expect(second.onClose).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole("button", { name: "Discard" }));
+    expect(second.onClose).toHaveBeenCalledWith(false);
+    expect(document.activeElement).toBe(second.header.current);
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  it("Escape in another popover doesn't discard the draft", () => {
+    const { onClose } = open({ otherPopover: true });
+    // Opened with a click (not a press, which would be a click outside the box).
+    fireEvent.click(screen.getByRole("button", { name: "Other" }));
+    // Even an empty draft stays: the key is that popover's, which closes.
+    const inside = screen.getByRole("button", { name: "Inside the other" });
+    inside.focus();
+    fireEvent.keyDown(inside, { key: "Escape" });
+    expect(screen.queryByRole("group", { name: "Another popover" })).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+    // Nor is Escape the box's with focus somewhere else on the page.
+    const elsewhere = screen.getByRole("button", { name: "+ New event" });
+    elsewhere.focus();
+    fireEvent.keyDown(elsewhere, { key: "Escape" });
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it("stays non-modal but registers as a dialog layer", () => {
+    const { unmount } = open();
+    const box = screen.getByRole("dialog", { name: "New event" });
+    expect(box.getAttribute("aria-modal")).toBeNull();
+    // So the calendar's keys and swipe, and Ctrl+K, stand down while it's open.
+    expect(isAnyDialogOpen()).toBe(true);
+    unmount();
+    expect(isAnyDialogOpen()).toBe(false);
+  });
+
+  it("an ambiguous create locks the fields and offers Check again with the same token", async () => {
+    createEvent.mockResolvedValueOnce(ambiguous).mockResolvedValueOnce(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    expect(
+      await screen.findByText(/^PM lost touch with Google while creating “Dentist”/),
+    ).toBeTruthy();
+    expect(title().disabled).toBe(true);
+    expect(screen.getByLabelText<HTMLSelectElement>("Start time").disabled).toBe(true);
+    expect(
+      screen.getByRole<HTMLButtonElement>("button", { name: "Calendar: Personal" }).disabled,
+    ).toBe(true);
+    // A click outside leaves it, title and all.
+    outside();
+    expect(onClose).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole("button", { name: "Check again" }));
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    expect(createEvent.mock.calls).toEqual([
+      [PERSONAL, sentFor("Dentist").draft, null],
+      [PERSONAL, sentFor("Dentist").draft, "ref-1"],
+    ]);
+  });
+
+  it("a held token goes to the full editor with More options, or stays as a notice on ✕", async () => {
+    createEvent.mockResolvedValue(ambiguous);
+    const first = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByRole("button", { name: "Check again" });
+    fireEvent.click(screen.getByRole("button", { name: "More options" }));
+    expect(first.onMore).toHaveBeenCalledWith(
+      expect.objectContaining({ held: { token: "ref-1", sent: sentFor("Dentist") } }),
+    );
+    // The full editor speaks for it now: no notice as the box goes, and nothing handed back.
+    await leave(first.unmount);
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+    expect(first.onLeave).not.toHaveBeenCalled();
+
+    const second = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByRole("button", { name: "Check again" });
+    fireEvent.click(screen.getByRole("button", { name: "Close" }));
+    expect(second.onClose).toHaveBeenCalledWith(false);
+    await leave(second.unmount);
+    expect(noteHeldCreate.mock.calls).toEqual([[sentFor("Dentist"), "ref-1"]]);
+  });
+
+  it("a second Enter while saving sends nothing, and nothing closes or hands over", async () => {
+    const answer = later();
+    createEvent.mockReturnValue(answer.promise);
+    const { onClose, onMore } = open();
+    // No title: a click outside or Escape would close it, if a save weren't out.
+    fireEvent.keyDown(title(), { key: "Enter" });
+    expect(screen.getByRole<HTMLButtonElement>("button", { name: "Saving…" }).disabled).toBe(true);
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(screen.getByRole("button", { name: "Saving…" }));
+    const more = screen.getByRole<HTMLButtonElement>("button", { name: "More options" });
+    const discard = screen.getByRole<HTMLButtonElement>("button", { name: "Discard" });
+    expect(more.disabled).toBe(true);
+    expect(discard.disabled).toBe(true);
+    fireEvent.click(more);
+    fireEvent.click(discard);
+    outside();
+    fireEvent.keyDown(title(), { key: "Escape" });
+    expect(createEvent).toHaveBeenCalledTimes(1);
+    expect(onClose).not.toHaveBeenCalled();
+    expect(onMore).not.toHaveBeenCalled();
+    await act(async () => answer.answer(saved));
+    expect(onClose).toHaveBeenCalledWith(true);
+  });
+
+  it("a no-zone device disables the times and Save, and says nothing can be saved", async () => {
+    deviceZone = null;
+    open();
+    expect(screen.getByLabelText<HTMLSelectElement>("Start time").disabled).toBe(true);
+    expect(screen.getByRole("switch", { name: "All day" }).hasAttribute("disabled")).toBe(true);
+    expect(screen.getByRole<HTMLButtonElement>("button", { name: "Save" }).disabled).toBe(true);
+    expect(
+      screen.getByText(
+        "PM couldn't tell which time zone this computer is in, so it can't save a new event. Set the time zone in your system settings.",
+      ),
+    ).toBeTruthy();
+    // The title can still be typed: only the save waits for a zone.
+    expect(title().disabled).toBe(false);
+    // Enter in the title sends nothing, and leaves the caret where it was.
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    title().focus();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(title());
+  });
+
+  it("the ghost's draft follows the times and the calendar", () => {
+    const { onDraft } = open();
+    expect(onDraft).toHaveBeenLastCalledWith(seed, PERSONAL, "unsaved");
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    expect(onDraft).toHaveBeenLastCalledWith({ ...seed, summary: "Dentist" }, PERSONAL, "unsaved");
+    // Another calendar: its account's half-hour length, while the time is still the seed's.
+    fireEvent.click(screen.getByRole("button", { name: "Calendar: Personal" }));
+    fireEvent.click(screen.getByRole("radio", { name: "Work" }), { detail: 1 });
+    expect(onDraft).toHaveBeenLastCalledWith(
+      { ...seed, summary: "Dentist", time: { ...seed.time, end_time: "09:30" } },
+      WORK_CAL,
+      "unsaved",
+    );
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "14:00" } });
+    expect(onDraft.mock.lastCall![0].time).toEqual({
+      ...seed.time,
+      start_time: "14:00",
+      end_time: "14:30",
+    });
+  });
+
+  it("an end on another day is words, and all day keeps the date", () => {
+    open();
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "23:30" } });
+    expect(screen.queryByLabelText("End time")).toBeNull();
+    expect(screen.getByText(/^ends 13-10(-2026)? · 00:30$/)).toBeTruthy();
+    fireEvent.click(screen.getByRole("switch", { name: "All day" }));
+    expect(screen.getByLabelText<HTMLInputElement>("Day").value).toBe("12-10-2026");
+    expect(screen.queryByLabelText("Start time")).toBeNull();
+  });
+
+  // A token that ended without Google showing the event made (lost after hours held, or made and
+  // since deleted): PM may have made it, so its words outlive the box, whichever way it goes.
+  it("after a token ends unproven, ✕ leaves its words as a notice", async () => {
+    createEvent.mockResolvedValueOnce(ambiguous).mockResolvedValueOnce(lost);
+    const { onClose, unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await screen.findByRole("button", { name: "Save" });
+    const box = screen.getByRole("dialog", { name: "New event" });
+    expect(
+      within(box).getByText(
+        "PM lost touch with Google and can't tell whether “Dentist” was made. Look for it in Google Calendar before creating it again, so it isn't made twice.",
+      ),
+    ).toBeTruthy();
+    expect(box.textContent).not.toContain("Nothing has been saved");
+    // Escape keeps a titled draft; ✕ throws it away, the words staying.
+    fireEvent.keyDown(title(), { key: "Escape" });
+    expect(onClose).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole("button", { name: "Discard" }));
+    expect(onClose).toHaveBeenCalledWith(false);
+    expect(noteCreateResult).not.toHaveBeenCalled();
+    await leave(unmount);
+    expect(noteCreateResult.mock.calls).toEqual([[sentFor("Dentist"), null, lost, WHERE]]);
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+  });
+
+  it("an untitled box a click outside closes after a token ends on gone still leaves the notice", async () => {
+    const gone: WriteOutcome = { outcome: "gone" };
+    createEvent.mockResolvedValueOnce(ambiguous).mockResolvedValueOnce(gone);
+    const { onClose, unmount } = open();
+    // No title: a click outside closes it.
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await screen.findByRole("button", { name: "Save" });
+    outside();
+    expect(onClose).toHaveBeenCalledWith(false);
+    await leave(unmount);
+    expect(noteCreateResult.mock.calls).toEqual([[sentFor(""), null, gone, WHERE]]);
+  });
+
+  it("made again after the look-first words, it says Created and nothing more", async () => {
+    createEvent
+      .mockResolvedValueOnce(ambiguous)
+      .mockResolvedValueOnce(lost)
+      .mockResolvedValueOnce(saved);
+    const { onClose, unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    fireEvent.click(await screen.findByRole("button", { name: "Save" }));
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    await leave(unmount);
+    // A new create, under no token, and only its Created.
+    expect(createEvent.mock.calls.map((c) => c[2])).toEqual([null, "ref-1", null]);
+    expect(noteCreateResult.mock.calls).toEqual([[sentFor("Dentist"), null, saved, WHERE]]);
+  });
+
+  it("More options after a token ends unproven hands its words to the full editor", async () => {
+    createEvent.mockResolvedValueOnce(ambiguous).mockResolvedValueOnce(lost);
+    const { onMore, unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await screen.findByRole("button", { name: "Save" });
+    fireEvent.click(screen.getByRole("button", { name: "More options" }));
+    expect(onMore).toHaveBeenCalledWith(
+      expect.objectContaining({
+        held: null,
+        unproven: { sent: sentFor("Dentist"), outcome: lost },
+      }),
+    );
+    // The full editor speaks for it now: no notice as the box goes.
+    await leave(unmount);
+    expect(noteCreateResult).not.toHaveBeenCalled();
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+  });
+
+  // Check again out when the box goes with its tab: the answer, or its absence, keeps the token.
+  it("a Check again answered once the box has gone passes its token on", async () => {
+    const busy: WriteOutcome = { outcome: "busy" };
+    const check = later();
+    createEvent.mockResolvedValueOnce(ambiguous).mockReturnValueOnce(check.promise);
+    const { unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await leave(unmount);
+    // The save still out says how it ended, not the close.
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+    await act(async () => check.answer(busy));
+    expect(noteCreateResult.mock.calls).toEqual([[sentFor("Dentist"), "ref-1", busy, WHERE]]);
+  });
+
+  it("a Check again with no answer at all once the box has gone keeps Check again", async () => {
+    const check = later();
+    createEvent.mockResolvedValueOnce(ambiguous).mockReturnValueOnce(check.promise);
+    const { unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await leave(unmount);
+    await act(async () => check.fail(new Error("The app's channel closed.")));
+    expect(noteHeldCreate.mock.calls).toEqual([[sentFor("Dentist"), "ref-1"]]);
+    expect(noteCreateResult).not.toHaveBeenCalled();
+  });
+
+  // A first save out when the box goes with its tab, turned down before it was sent (this window,
+  // the owner or the vault): no token to keep, so the notice says it wasn't created.
+  it("a first save with no answer at all once the box has gone says it wasn't created", async () => {
+    const answer = later();
+    createEvent.mockReturnValue(answer.promise);
+    const { unmount, onLeave } = open();
+    // No title, as Enter in an empty box sends.
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await leave(unmount);
+    await act(async () => answer.fail(new Error("The vault is locked.")));
+    expect(noteCreateResult.mock.calls).toEqual([
+      [sentFor(""), null, { outcome: "failed", message: "The vault is locked." }, WHERE],
+    ]);
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it("a Check again with no answer at all keeps the draft locked, with Check again", async () => {
+    createEvent
+      .mockResolvedValueOnce(ambiguous)
+      .mockRejectedValueOnce(new Error("The app's channel closed."));
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    expect(await screen.findByText("The app's channel closed.")).toBeTruthy();
+    expect(title().disabled).toBe(true);
+    expect(screen.getByRole("button", { name: "Check again" })).toBeTruthy();
+    expect(screen.queryByRole("button", { name: "Save" })).toBeNull();
+  });
+
+  it("a held key's repeats send nothing more once an answer unlocks Save", async () => {
+    createEvent.mockResolvedValue(unreachable);
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByText("“Dentist” wasn't created: PM couldn't reach Google.");
+    fireEvent.keyDown(title(), { key: "Enter", repeat: true });
+    await act(async () => {});
+    expect(createEvent).toHaveBeenCalledTimes(1);
+    // A held Enter on Save (where the answer puts focus) would click it on each repeat: the
+    // repeat's default is stopped, a first press's isn't. jsdom clicks nothing for Enter itself.
+    const save = screen.getByRole("button", { name: "Save" });
+    expect(fireEvent.keyDown(save, { key: "Enter", repeat: true })).toBe(false);
+    expect(fireEvent.keyDown(save, { key: "Enter" })).toBe(true);
+  });
+
+  // The line names the field, which is marked wrong and described by it, and a save it stops puts
+  // focus there, where a date typed or picked ends it.
+  it("a date it can't read is named, marked and focused by a save", async () => {
+    open();
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "99-99-2026" } });
+    // Leaving the field commits it, and it's refused.
+    act(() => title().focus());
+    const line = screen.getByText(
+      "Date: “99-99-2026” isn't a date PM can read. Type the date again as dd-mm-yyyy, or pick it from the calendar.",
+    );
+    expect(line.getAttribute("role")).toBe("alert");
+    expect(date.getAttribute("aria-invalid")).toBe("true");
+    expect(date.getAttribute("aria-describedby")).toBe(line.id);
+    expect(line.id).not.toBe("");
+    expect(document.activeElement).toBe(title());
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(date);
+    // All day: the same field is the Day, and the line says so.
+    fireEvent.click(screen.getByRole("switch", { name: "All day" }));
+    expect(screen.getByText(/^Day: “99-99-2026” isn't a date PM can read/)).toBeTruthy();
+    expect(screen.getByLabelText("Day").getAttribute("aria-invalid")).toBe("true");
+    // Given a date, the line and the mark go.
+    fireEvent.click(screen.getByLabelText("Day"));
+    fireEvent.click(screen.getByRole("button", { name: /\b14-10(-2026)?$/ }));
+    expect(screen.queryByRole("alert")).toBeNull();
+    expect(screen.getByLabelText("Day").getAttribute("aria-invalid")).toBeNull();
+    expect(screen.getByLabelText("Day").getAttribute("aria-describedby")).toBeNull();
+  });
+
+  it("a save refused for a time the clocks skip keeps focus where it was", async () => {
+    open();
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "28-03-2027" } });
+    fireEvent.blur(date);
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "01:30" } });
+    expect(screen.getByText(/01:30 doesn't happen in Europe\/London that night/)).toBeTruthy();
+    act(() => title().focus());
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    expect(document.activeElement).toBe(title());
+  });
+
+  // The calendar list stays inside the box, as in the full editor's dialog: opening it puts the
+  // keyboard on the calendar picked, Tab hands focus back to its button, and Escape there closes the
+  // list, never the box (even an empty one, which Escape in the box itself would close).
+  it("the calendar list is inside the box, and the keyboard gets in and out", async () => {
+    const { onClose } = open();
+    const trigger = screen.getByRole("button", { name: "Calendar: Personal" });
+    trigger.focus();
+    // 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);
+    const picked = within(list).getByRole("radio", { name: "Personal" });
+    await waitFor(() => expect(document.activeElement).toBe(picked));
+    fireEvent.keyDown(picked, { key: "Tab" });
+    expect(screen.queryByRole("group", LIST)).toBeNull();
+    expect(document.activeElement).toBe(trigger);
+    fireEvent.click(trigger, { detail: 0 });
+    const again = within(screen.getByRole("group", LIST)).getByRole("radio", { name: "Personal" });
+    await waitFor(() => expect(document.activeElement).toBe(again));
+    fireEvent.keyDown(again, { key: "Escape" });
+    expect(screen.queryByRole("group", LIST)).toBeNull();
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it("a click on a calendar's name picks it and closes the list, the box staying", () => {
+    const { onClose, onDraft } = open();
+    fireEvent.click(screen.getByRole("button", { name: "Calendar: Personal" }));
+    const list = screen.getByRole("group", LIST);
+    const name = within(list).getByText("Work");
+    fireEvent.pointerDown(name);
+    fireEvent.mouseDown(name);
+    // Its label forwards the click to the radio with `detail` 0, as an arrow key's would be.
+    fireEvent.click(within(list).getByRole("radio", { name: "Work" }), { detail: 0 });
+    expect(screen.queryByRole("group", LIST)).toBeNull();
+    expect(onDraft.mock.lastCall![1]).toBe(WORK_CAL);
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
+  it("the calendar list closes for a save and stays closed after its answer", async () => {
+    createEvent.mockResolvedValue(unreachable);
+    open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.click(screen.getByRole("button", { name: "Calendar: Personal" }));
+    expect(screen.queryByRole("group", LIST)).not.toBeNull();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByText("“Dentist” wasn't created: PM couldn't reach Google.");
+    expect(title().disabled).toBe(false);
+    expect(screen.queryByRole("group", LIST)).toBeNull();
+  });
+
+  // A notice that never goes (Check again) sits at the foot of the window, where the box can open
+  // on a short one: the box stacks over the write notices, as a modal's scrim does.
+  it("sits over the calendar's write notices", () => {
+    open();
+    render(
+      <WriteNotices
+        notices={[{ id: 1, tone: "warn", text: "PM may already have made “Gym”." }]}
+        onUndo={vi.fn()}
+        onDismiss={vi.fn()}
+      />,
+    );
+    const stack = screen.getByText("PM may already have made “Gym”.").closest(".fixed");
+    expect(zOf(box())).toBeGreaterThan(zOf(stack));
+  });
+
+  // The date field puts back the date it had when it can't read what was typed: that date was given
+  // by nobody, so the refusal stands until the field is given one, typed or picked.
+  it("a date it can't read stands through a blur, a time and All day, until the field is given one", async () => {
+    createEvent.mockResolvedValue(saved);
+    const { onClose } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    const date = () => screen.getByLabelText<HTMLInputElement>(/^(Date|Day)$/);
+    const refused = () => screen.queryByText(/^Date: “31-11-2026” isn't a date PM can read/);
+    date().focus();
+    fireEvent.change(date(), { target: { value: "31-11-2026" } });
+    fireEvent.blur(date());
+    expect(refused()).not.toBeNull();
+    expect(date().value).toBe("12-10-2026");
+    // Back in the field and out again with nothing typed: the date it put back is no date given.
+    date().focus();
+    fireEvent.blur(date());
+    expect(refused()).not.toBeNull();
+    // A time, and All day there and back, leave it standing.
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "10:00" } });
+    fireEvent.click(screen.getByRole("switch", { name: "All day" }));
+    fireEvent.click(screen.getByRole("switch", { name: "All day" }));
+    expect(refused()).not.toBeNull();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+    // A date picked ends it, and it's the date sent.
+    fireEvent.click(date());
+    fireEvent.click(screen.getByRole("button", { name: /\b14-10(-2026)?$/ }));
+    expect(refused()).toBeNull();
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await waitFor(() => expect(onClose).toHaveBeenCalledWith(true));
+    expect(createEvent.mock.calls[0][1].time).toMatchObject({ start_date: "2026-10-14" });
+  });
+
+  // More options goes on to the full editor, where the date the field put back would otherwise be
+  // saved without a word: the refusal goes with it, even for text typed and not yet left.
+  it("More options carries a date it couldn't read on to the full editor", () => {
+    const { onMore } = open();
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "31-02-2026" } });
+    fireEvent.click(screen.getByRole("button", { name: "More options" }));
+    expect(onMore).toHaveBeenCalledWith(
+      expect.objectContaining({ draft: seed, badDate: "31-02-2026" }),
+    );
+  });
+
+  // A click in the sidebar switches tabs (a titled box stays through a click), and the tab takes the
+  // box with it: with nothing sent, the draft is handed back to open on again.
+  it("a titled draft that goes with the tab is handed back once, as it was", async () => {
+    const { onLeave, unmount } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.change(screen.getByLabelText("Start time"), { target: { value: "11:00" } });
+    const date = screen.getByLabelText<HTMLInputElement>("Date");
+    date.focus();
+    fireEvent.change(date, { target: { value: "31-02-2026" } });
+    fireEvent.blur(date);
+    await act(async () => {});
+    expect(onLeave).not.toHaveBeenCalled();
+    await leave(unmount);
+    expect(onLeave.mock.calls).toEqual([
+      [
+        {
+          seed,
+          draft: {
+            ...seed,
+            summary: "Dentist",
+            time: { ...seed.time, start_time: "11:00", end_time: "12:00" },
+          },
+          calendarId: PERSONAL,
+          timeTouched: true,
+          badDate: "31-02-2026",
+        },
+      ],
+    ]);
+    expect(noteCreateResult).not.toHaveBeenCalled();
+    expect(noteHeldCreate).not.toHaveBeenCalled();
+  });
+
+  // A box opened again on that draft holds a title from its first render. The app's development
+  // build runs every new mount's effects as setup, cleanup, setup: that rehearsal of an unmount must
+  // hand nothing back, or the draft would open yet again after the box was closed.
+  it("under StrictMode, a box opened on a draft hands nothing back until it really goes", async () => {
+    const draft: EditorFields = { ...seed, summary: "Dentist" };
+    const { onLeave, unmount } = open({
+      strict: true,
+      resume: { seed, draft, calendarId: PERSONAL, timeTouched: false, badDate: null },
+    });
+    await act(async () => {});
+    expect(onLeave).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole("button", { name: "Discard" }));
+    await leave(unmount);
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it("nothing is handed back for a box closed from inside, an empty one, or one handed over", async () => {
+    // ✕ throws the draft away.
+    let opened = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.click(screen.getByRole("button", { name: "Discard" }));
+    await leave(opened.unmount);
+    expect(opened.onLeave).not.toHaveBeenCalled();
+    // Spaces alone aren't a title.
+    opened = open();
+    fireEvent.change(title(), { target: { value: "  " } });
+    await leave(opened.unmount);
+    expect(opened.onLeave).not.toHaveBeenCalled();
+    // The full editor carries it on.
+    opened = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.click(screen.getByRole("button", { name: "More options" }));
+    await leave(opened.unmount);
+    expect(opened.onLeave).not.toHaveBeenCalled();
+  });
+
+  it("nothing is handed back for a draft sent: a notice or the answer speaks for it", async () => {
+    // Held: Check again stays as a notice.
+    createEvent.mockResolvedValueOnce(ambiguous);
+    let opened = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByRole("button", { name: "Check again" });
+    await leave(opened.unmount);
+    expect(noteHeldCreate).toHaveBeenCalledTimes(1);
+    expect(opened.onLeave).not.toHaveBeenCalled();
+    // A save still out says how it ended.
+    const answer = later();
+    createEvent.mockReturnValueOnce(answer.promise);
+    opened = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await leave(opened.unmount);
+    await act(async () => answer.answer(saved));
+    expect(opened.onLeave).not.toHaveBeenCalled();
+    // A token that ended unproven leaves its words.
+    createEvent.mockResolvedValueOnce(ambiguous).mockResolvedValueOnce(lost);
+    opened = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    fireEvent.click(await screen.findByRole("button", { name: "Check again" }));
+    await screen.findByRole("button", { name: "Save" });
+    await leave(opened.unmount);
+    expect(opened.onLeave).not.toHaveBeenCalled();
+  });
+
+  it("opens on a draft that went with the tab, its time and refusal as they were", async () => {
+    const draft: EditorFields = {
+      ...seed,
+      summary: "Dentist",
+      time: { ...seed.time, start_time: "11:00", end_time: "12:00" } as EditorFields["time"],
+    };
+    const { onDraft } = open({
+      resume: { seed, draft, calendarId: PERSONAL, timeTouched: true, badDate: "31-02-2026" },
+    });
+    expect(title().value).toBe("Dentist");
+    expect(document.activeElement).toBe(title());
+    expect(onDraft).toHaveBeenLastCalledWith(draft, PERSONAL, "unsaved");
+    expect(screen.getByText(/^Date: “31-02-2026” isn't a date PM can read/)).toBeTruthy();
+    expect(screen.getByLabelText("Date").getAttribute("aria-invalid")).toBe("true");
+    // The time was the user's: another calendar leaves it alone.
+    fireEvent.click(screen.getByRole("button", { name: "Calendar: Personal" }));
+    fireEvent.click(screen.getByRole("radio", { name: "Work" }), { detail: 1 });
+    expect(onDraft.mock.lastCall![0].time).toEqual(draft.time);
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await act(async () => {});
+    expect(createEvent).not.toHaveBeenCalled();
+  });
+
+  // A click on the ghost, an event or "+ New event" comes back to the box. While it's locked, the
+  // title can't take focus, so the keyboard lands on Check again, or the box itself while saving.
+  it("brought back while locked, the keyboard lands in the box", async () => {
+    const answer = later();
+    createEvent.mockReturnValueOnce(answer.promise);
+    const { focusRef } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    const synced = screen.getByRole("button", { name: "Synced" });
+    synced.focus();
+    act(() => focusRef.current!());
+    expect(document.activeElement).toBe(box());
+    await act(async () => answer.answer(ambiguous));
+    const again = screen.getByRole("button", { name: "Check again" });
+    await waitFor(() => expect(document.activeElement).toBe(again));
+    synced.focus();
+    act(() => focusRef.current!());
+    expect(title().disabled).toBe(true);
+    expect(document.activeElement).toBe(again);
+  });
+
+  // What the ghost is announced with: an event PM may already have made is never "not saved".
+  it("tells the ghost how far the event has got", async () => {
+    const answer = later();
+    createEvent.mockReturnValueOnce(answer.promise).mockResolvedValueOnce(lost);
+    const { onDraft } = open();
+    const state = () => onDraft.mock.lastCall![2];
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    expect(state()).toBe("unsaved");
+    fireEvent.keyDown(title(), { key: "Enter" });
+    expect(state()).toBe("saving");
+    await act(async () => answer.answer(ambiguous));
+    expect(state()).toBe("unsure");
+    // A token that ended unproven: it may still be in Google.
+    fireEvent.click(screen.getByRole("button", { name: "Check again" }));
+    await screen.findByRole("button", { name: "Save" });
+    expect(state()).toBe("unsure");
+  });
+
+  it("a fresh save that fails outright leaves the ghost unsaved", async () => {
+    createEvent.mockResolvedValue(unreachable);
+    const { onDraft } = open();
+    fireEvent.change(title(), { target: { value: "Dentist" } });
+    fireEvent.keyDown(title(), { key: "Enter" });
+    await screen.findByText("“Dentist” wasn't created: PM couldn't reach Google.");
+    expect(onDraft.mock.lastCall![2]).toBe("unsaved");
+  });
+});
diff --git a/src/components/calendar/edit/QuickCreatePopover.tsx b/src/components/calendar/edit/QuickCreatePopover.tsx
new file mode 100644
index 00000000..4cb1f55e
--- /dev/null
+++ b/src/components/calendar/edit/QuickCreatePopover.tsx
@@ -0,0 +1,752 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// Quick create (#884, C10c): the small box Shift+C opens under "+ New event", as Google Calendar's
+// quick box. Type a title and press Enter; More options opens the full editor on the same draft,
+// sending nothing on the way. Times are this computer's; an end on another day and other time
+// zones are the full editor's, shown here as words.
+//
+// A non-modal dialog, like an event's details: no focus trap and no scrim, so the grid behind stays
+// in view, with the new event drawn on it as it's typed (the ghost, fed by `onDraft`, which also
+// says how far it has got). It registers as a dialog layer all the same, so the calendar's keys and
+// swipe and the app's Ctrl+K stand down while it's open: the palette would switch tabs.
+//
+// A draft is never lost by accident. A click outside, or Escape, closes the box only while the title
+// is empty; with a title it stays, and ✕ is how to throw it away. A click in a picker the box opened
+// (the date's, portalled, so outside its frame) isn't outside, nor one on the ghost; Escape counts
+// only with focus in the box, so Escape in another popover is that popover's. A titled draft that
+// goes with the Calendar tab, nothing sent (a click in the sidebar), is handed back (`onLeave`), and
+// the box opens on it again when the calendar does (`resume`). The calendar list stays inside the
+// box, as it does in the full editor's dialog.
+//
+// Saving is the full editor's: one guard for every way to save, never on a held key's repeats or the
+// Enter that ends composing text; nothing editable, closable or handed over while a save is out; and
+// an answer that never arrived kept locked as it was sent, with Check again under the same retry
+// token. An answer once the box has gone is said as a notice instead. A token that ended without
+// Google showing the event made is never "nothing saved": its words stay as a notice when the box
+// 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.
+
+import {
+  useCallback,
+  useEffect,
+  useId,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+  type MutableRefObject,
+  type RefObject,
+} from "react";
+import { flushSync } from "react-dom";
+import type { CalendarOverview, TimeDraft, WriteOutcome } from "../../../lib/types";
+import type { DraftState } from "../../../lib/calendar-layout";
+import {
+  NEW_EVENT_BASE,
+  checkDraft,
+  dateFieldId,
+  endAfterStart,
+  endTimeChoices,
+  halfInstant,
+  switchNewKind,
+  toNewEvent,
+  type EditorFields,
+} from "../../../lib/calendarEdit/eventDraft";
+import {
+  ambiguousText,
+  badDateText,
+  CALLOUT_TONE,
+  createText,
+  problemText,
+  retryAfter,
+  type Tone,
+} from "../../../lib/calendarEdit/editReasons";
+import {
+  createdWhere,
+  createNotes,
+  lengthFor,
+  targetById,
+  type CreateTargets,
+} from "../../../lib/calendarEdit/createTargets";
+import { formatDateOnly } from "../../../lib/format";
+import { useDialogLayer } from "../../../lib/useDialogLayer";
+import { deviceTimeZoneOrNull } from "../../../theme";
+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 type { CreateHandover, Unproven } from "./NewEventEditor";
+import { createEvent, noteCreateResult, noteHeldCreate, type CreateSent } from "./useEventWrites";
+
+interface Props {
+  /** The "+ New event" button's rect: the box opens under it. */
+  anchor: DOMRect;
+  /** The fields it starts with (`newEventSeed`). */
+  seed: EditorFields;
+  targets: CreateTargets;
+  /** The calendar it starts on (PM's id). */
+  calendarId: string;
+  /** The mirror's window and each account's default length. */
+  overview: CalendarOverview;
+  /** Calendars hidden in the calendar list. */
+  hidden: ReadonlySet<string>;
+  colorOf: (calendarId: string) => string;
+  shapeOf: (calendarId: string) => number | undefined;
+  /** Where focus goes when the box closes from inside (saved, ✕, Escape): the header button, which
+   *  Shift+C never focused, so remembering the focus at open would hand it to the page. */
+  returnFocusTo: RefObject<HTMLElement | null>;
+  /** Filled in with a way to bring the keyboard back into the box: a click on the ghost, or on "+ New
+   *  event", comes back here rather than starting another. */
+  focusRef?: MutableRefObject<(() => void) | null>;
+  /** A draft that went with the Calendar tab (`onLeave`), to carry on with: its fields, whether its
+   *  time was the user's, and a date it couldn't read. Its calendar is `calendarId`. */
+  resume?: LeftDraft;
+  /** The draft and calendar as they change, and how far the event has got, for the ghost. */
+  onDraft: (draft: EditorFields, calendarId: string, state: DraftState) => void;
+  /** More options: carry on in the full editor. */
+  onMore: (handover: CreateHandover) => void;
+  /** Gone: `saved` when the event was created, so its ghost can stay until the calendar shows it. */
+  onClose: (saved: boolean) => void;
+  /** Gone with the Calendar tab (never closed from inside), titled, with nothing sent: the draft, to
+   *  open the box on again. Called once the box has really gone, and never for a draft that a notice
+   *  or the full editor speaks for. */
+  onLeave?: (left: LeftDraft) => void;
+}
+
+/** A titled draft whose box went with the Calendar tab, nothing sent: what the box opens on again. */
+export interface LeftDraft {
+  /** The fields the box started with, for All day's switch back. */
+  seed: EditorFields;
+  draft: EditorFields;
+  calendarId: string;
+  timeTouched: boolean;
+  /** Text the date field couldn't read, still refusing a save. */
+  badDate: string | null;
+}
+
+/** An answer that never arrived: its retry token, exactly what was sent, and the fields that were. */
+interface Held {
+  token: string;
+  sent: CreateSent;
+  fields: EditorFields;
+}
+
+type AllDay = Extract<TimeDraft, { kind: "all_day" }>;
+
+/** Room kept between the box and the window's edge. */
+const MARGIN = 8;
+
+const message = (e: unknown) => (e instanceof Error ? e.message : String(e));
+
+/** `date` (`YYYY-MM-DD`) as days since 1970, for moving an all-day span whole. */
+const dayNumber = (date: string) => Date.parse(`${date}T00:00:00Z`) / 86_400_000;
+
+/** An all-day span moved to start on `first_day`, keeping how many days it covers. */
+function moveAllDay(t: AllDay, first_day: string): AllDay {
+  const length = dayNumber(t.last_day) - dayNumber(t.first_day);
+  const last = new Date((dayNumber(first_day) + length) * 86_400_000).toISOString().slice(0, 10);
+  return { ...t, first_day, last_day: last };
+}
+
+export function QuickCreatePopover({
+  anchor,
+  seed,
+  targets,
+  calendarId: firstCalendar,
+  overview,
+  hidden,
+  colorOf,
+  shapeOf,
+  returnFocusTo,
+  focusRef,
+  resume,
+  onDraft,
+  onMore,
+  onClose,
+  onLeave,
+}: Props) {
+  const deviceZone = useMemo(() => deviceTimeZoneOrNull(), []);
+  const panelRef = useRef<HTMLDivElement>(null);
+  const titleRef = useRef<HTMLInputElement>(null);
+  const saveButton = useRef<HTMLButtonElement>(null);
+  const [pos, setPos] = useState<{ left: number; top: number } | null>(null);
+  const startDraft = resume?.draft ?? seed;
+  const [draft, setDraftState] = useState<EditorFields>(startDraft);
+  // The latest draft and calendar, readable synchronously: Save blurs the focused field first, and a
+  // date typed but not yet committed commits in that blur, before React re-renders.
+  const draftRef = useRef<EditorFields>(startDraft);
+  const [calendarId, setCalendarIdState] = useState(firstCalendar);
+  const calendarRef = useRef(firstCalendar);
+  // Text the date field couldn't read: no save until that field is given a date, typed or picked (a
+  // blur, a time or All day never ends it), and More options carries it on. The one date field sets
+  // the start (the whole event moves with it), so in the full editor it's the start's refusal.
+  const badDateRef = useRef<string | null>(resume?.badDate ?? null);
+  const [badDate, setBadDateState] = useState<string | null>(resume?.badDate ?? null);
+  // The date field's id, so a save its refusal stops can find it, and the id of the line that says
+  // what's wrong with it.
+  const dateId = dateFieldId(useId(), "start");
+  const refusedLineId = `${dateId}-refused`;
+  // The event's length, kept while its start moves: the account's default to begin with.
+  const lengthRef = useRef(lengthFor(overview, targetById(targets, firstCalendar)));
+  // Whether the user has changed the time: until then, another calendar brings its own length.
+  const timeTouched = useRef(resume?.timeTouched ?? false);
+  const [banner, setBanner] = useState<{ tone: Tone; text: string } | null>(null);
+  // The one guard every way to save passes, set before the request goes.
+  const savingRef = useRef(false);
+  const [saving, setSaving] = useState(false);
+  const heldRef = useRef<Held | null>(null);
+  const [held, setHeldState] = useState<Held | null>(null);
+  // PM may have made an event this box sent, though no token is held for it any more.
+  const unprovenRef = useRef<Unproven | null>(null);
+  const [unproven, setUnprovenState] = useState<Unproven | null>(null);
+  // The latest props, for what's said or handed back after they moved on.
+  const overviewRef = useRef(overview);
+  const hiddenRef = useRef(hidden);
+  const seedRef = useRef(seed);
+  const onLeaveRef = useRef(onLeave);
+  useEffect(() => {
+    overviewRef.current = overview;
+    hiddenRef.current = hidden;
+    seedRef.current = seed;
+    onLeaveRef.current = onLeave;
+  });
+  // Whether the box is still showing: an answer after it has gone is said as a notice instead.
+  const alive = useRef(true);
+  // More options took the draft (and any retry token) to the full editor, which speaks for it now.
+  const handedOver = useRef(false);
+  // Closed from inside (saved, ✕, a click outside or Escape): nothing to hand back.
+  const closed = useRef(false);
+
+  // A dialog layer while open: Ctrl+K, the calendar's keys and its swipe stand down.
+  useDialogLayer(true, panelRef);
+
+  const setDraft = (next: EditorFields) => {
+    draftRef.current = next;
+    setDraftState(next);
+  };
+  const setCalendarId = (id: string) => {
+    calendarRef.current = id;
+    setCalendarIdState(id);
+  };
+  const setBadDate = (text: string | null) => {
+    badDateRef.current = text;
+    setBadDateState(text);
+  };
+  const setHeld = (next: Held | null) => {
+    heldRef.current = next;
+    setHeldState(next);
+  };
+  const setUnproven = (next: Unproven | null) => {
+    unprovenRef.current = next;
+    setUnprovenState(next);
+  };
+  // Into the box: the title, or while it's locked (a save out, or Check again) Check again, else the
+  // box itself, so a click that comes back here never leaves the keyboard outside it.
+  const focusBox = useCallback(() => {
+    const title = titleRef.current;
+    const save = saveButton.current;
+    if (title && !title.disabled) title.focus();
+    else if (save && !save.disabled) save.focus();
+    else panelRef.current?.focus();
+  }, []);
+  const refocusSave = () => setTimeout(() => saveButton.current?.focus(), 0);
+  const whereOf = (id: string) => createdWhere(overviewRef.current, hiddenRef.current, id);
+
+  // Under the button, clamped to the window, above it only when there's no room below; hidden until
+  // placed so it never flashes at the corner. Placed again as it grows (a problem line, the banner).
+  useLayoutEffect(() => {
+    const el = panelRef.current;
+    if (!el) return;
+    const place = () => {
+      const w = el.offsetWidth;
+      const h = el.offsetHeight;
+      const left = Math.max(MARGIN, Math.min(anchor.left, window.innerWidth - w - MARGIN));
+      let top = anchor.bottom + 6;
+      if (top + h + MARGIN > window.innerHeight) {
+        const above = anchor.top - 6 - h;
+        top = above >= MARGIN ? above : Math.max(MARGIN, window.innerHeight - h - MARGIN);
+      }
+      setPos((p) => (p && p.left === left && p.top === top ? p : { left, top }));
+    };
+    place();
+    const ro = typeof ResizeObserver === "undefined" ? null : new ResizeObserver(place);
+    ro?.observe(el);
+    window.addEventListener("resize", place);
+    return () => {
+      ro?.disconnect();
+      window.removeEventListener("resize", place);
+    };
+  }, [anchor]);
+
+  // The title takes focus once the box is placed (a hidden element can't), and only then: placing
+  // it again as it grows must not pull focus back from wherever the user went.
+  const focusedOnce = useRef(false);
+  useEffect(() => {
+    if (!pos || focusedOnce.current) return;
+    focusedOnce.current = true;
+    if (!panelRef.current?.contains(document.activeElement)) focusBox();
+  }, [pos, focusBox]);
+
+  useEffect(() => {
+    if (!focusRef) return;
+    focusRef.current = focusBox;
+    return () => {
+      focusRef.current = null;
+    };
+  }, [focusRef, focusBox]);
+
+  // The ghost follows the draft and the calendar, and says how far the event has got: once anything
+  // was sent, PM may have made it.
+  const ghostState: DraftState = saving ? "saving" : held || unproven ? "unsure" : "unsaved";
+  useEffect(() => {
+    onDraft(draft, calendarId, ghostState);
+  }, [draft, calendarId, ghostState, onDraft]);
+
+  // Going (closed, or with the Calendar tab) while PM may already have made the event leaves a
+  // notice with Check again, unless the full editor took it over. A save still out says how it
+  // ended itself, once it does. One whose token ended unproven leaves its words (look for it before
+  // creating it again), whichever way the box went: ✕, a click outside, Escape or the tab. A titled
+  // draft that went with the tab, nothing sent, is handed back to open on again.
+  useEffect(() => {
+    alive.current = true;
+    return () => {
+      alive.current = false;
+      // What the box held as it went, acted on only once it has really gone: StrictMode rehearses an
+      // unmount in development (a cleanup straight followed by a setup, which sets `alive` again
+      // before this runs), and the notices and the hand-back must happen once, for a real one.
+      const u = unprovenRef.current;
+      const h = savingRef.current ? null : heldRef.current;
+      const d = draftRef.current;
+      const left: LeftDraft | null =
+        closed.current || handedOver.current || savingRef.current || h || u || !d.summary.trim()
+          ? null
+          : {
+              seed: seedRef.current,
+              draft: d,
+              calendarId: calendarRef.current,
+              timeTouched: timeTouched.current,
+              badDate: badDateRef.current,
+            };
+      queueMicrotask(() => {
+        if (alive.current || handedOver.current) return;
+        if (u) {
+          const where = createdWhere(overviewRef.current, hiddenRef.current, u.sent.calendarId);
+          noteCreateResult(u.sent, null, u.outcome, where);
+        }
+        if (h) noteHeldCreate(h.sent, h.token);
+        if (left) onLeaveRef.current?.(left);
+      });
+    };
+  }, []);
+
+  /** Commit whatever the focused field holds, so the draft read next is the one on screen. */
+  function commitFocused() {
+    const active = document.activeElement;
+    if (active instanceof HTMLElement && panelRef.current?.contains(active)) {
+      active.blur();
+      flushSync(() => {});
+    }
+  }
+
+  /** Focus on `el` (what `commitFocused` blurred, or the date field a refusal names) when the save
+   *  it began went no further: never left on the page behind the box. */
+  function refocus(el: Element | null) {
+    if (!(el instanceof HTMLElement) || !panelRef.current?.contains(el)) return;
+    if (el.isConnected && !el.matches(":disabled")) el.focus();
+    else focusBox();
+  }
+
+  /** Closed from inside: focus goes back to "+ New event". */
+  function closeBack(saved: boolean) {
+    closed.current = true;
+    returnFocusTo.current?.focus();
+    onClose(saved);
+  }
+
+  /** ✕: throw the draft away (a retry token held stays as a notice). Never while saving. */
+  function discard() {
+    if (savingRef.current) return;
+    closeBack(false);
+  }
+
+  /** A click outside, or Escape: the box goes only while there's no title to lose, and never
+   *  while saving. Escape hands focus back; a click has already put it where it was aimed. */
+  function dismiss(by: "click" | "escape") {
+    if (savingRef.current || draftRef.current.summary.trim() !== "") return;
+    if (by === "escape") {
+      closeBack(false);
+    } else {
+      closed.current = true;
+      onClose(false);
+    }
+  }
+
+  const dismissNow = useRef(dismiss);
+  useEffect(() => {
+    dismissNow.current = dismiss;
+  });
+  useEffect(() => {
+    const onDown = (e: MouseEvent) => {
+      const t = e.target;
+      if (!(t instanceof Element) || panelRef.current?.contains(t)) return;
+      // A picker this box opened is portalled outside it, and the ghost on the grid is this event.
+      if (t.closest("[data-popover-panel], [data-draft-event]")) return;
+      dismissNow.current("click");
+    };
+    // Escape only with focus in the box itself. A picker it opened closes itself first (a popover
+    // stops the key before it reaches the window), so focus in any popover's panel means a popover
+    // that isn't the box's, and the key is that one's.
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== "Escape") return;
+      if (e.target instanceof Node && panelRef.current?.contains(e.target)) {
+        dismissNow.current("escape");
+      }
+    };
+    window.addEventListener("mousedown", onDown);
+    window.addEventListener("keydown", onKey);
+    return () => {
+      window.removeEventListener("mousedown", onDown);
+      window.removeEventListener("keydown", onKey);
+    };
+  }, []);
+
+  /** The event's length now, kept for the next start move, or the last it had. */
+  function lengthOf(t: Timed): number {
+    const s = halfInstant(NEW_EVENT_BASE, t, "start");
+    const e = halfInstant(NEW_EVENT_BASE, t, "end");
+    if (s !== null && e !== null && e - s >= 60_000) lengthRef.current = e - s;
+    return lengthRef.current;
+  }
+
+  /** Move the start, the end following so the event keeps its length. */
+  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. */
+  function changeTime(time: TimeDraft) {
+    timeTouched.current = true;
+    setDraft({ ...draftRef.current, time });
+  }
+
+  /** Another calendar. While the time is still the seed's, the end follows that account's length. */
+  function pickCalendar(id: string) {
+    setCalendarId(id);
+    if (timeTouched.current) return;
+    const length = lengthFor(overviewRef.current, targetById(targets, id));
+    lengthRef.current = length;
+    const t = draftRef.current.time;
+    if (t.kind === "timed") {
+      setDraft({ ...draftRef.current, time: endAfterStart(NEW_EVENT_BASE, t, length) });
+    }
+  }
+
+  /** All day ↔ timed, as the full editor switches a new event. */
+  function switchKind() {
+    if (deviceZone === null) return;
+    timeTouched.current = true;
+    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() {
+    if (savingRef.current) return;
+    commitFocused();
+    handedOver.current = true;
+    const h = heldRef.current;
+    onMore({
+      draft: draftRef.current,
+      calendarId: calendarRef.current,
+      held: h ? { token: h.token, sent: h.sent } : null,
+      unproven: unprovenRef.current,
+      // Quick create has no Show as: it still follows the kind.
+      showAsTouched: false,
+      timeTouched: timeTouched.current,
+      // 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,
+    });
+  }
+
+  async function save() {
+    // Refused before anything is blurred: focus stays put.
+    if (savingRef.current) return;
+    const h = heldRef.current;
+    // Without a zone a new draft can't go (that's said under the times); a held one goes as sent.
+    if (!h && deviceZone === null) return;
+    const focused = document.activeElement;
+    commitFocused();
+    let sent: CreateSent;
+    let fields: EditorFields;
+    if (h) {
+      // Check again: exactly what was sent, under its token.
+      sent = h.sent;
+      fields = h.fields;
+    } else {
+      const current = draftRef.current;
+      // What stops it is already said under the times, as it happened. A date the field couldn't
+      // read puts focus on that field, which the line names and only a date typed or picked there
+      // clears (a blur gives it nothing, so the refusal stands); anything else puts focus back where
+      // it was.
+      if (badDateRef.current !== null) {
+        setBanner(null);
+        refocus(document.getElementById(dateId));
+        return;
+      }
+      if (checkDraft(NEW_EVENT_BASE, current).problems.length > 0) {
+        setBanner(null);
+        refocus(focused);
+        return;
+      }
+      sent = { calendarId: calendarRef.current, draft: toNewEvent(current) };
+      fields = current;
+    }
+    const token = h?.token ?? null;
+    savingRef.current = true;
+    setSaving(true);
+    setBanner(null);
+    let outcome: WriteOutcome;
+    try {
+      outcome = await createEvent(sent.calendarId, sent.draft, token);
+    } catch (e) {
+      // No answer at all (the app's own channel failed): a held token stays held.
+      savingRef.current = false;
+      if (!alive.current) {
+        if (token) noteHeldCreate(sent, token);
+        else
+          noteCreateResult(
+            sent,
+            null,
+            { outcome: "failed", message: message(e) },
+            whereOf(sent.calendarId),
+          );
+        return;
+      }
+      setSaving(false);
+      setBanner({ tone: "error", text: message(e) });
+      refocusSave();
+      return;
+    }
+    savingRef.current = false;
+    if (!alive.current) {
+      noteCreateResult(sent, token, outcome, whereOf(sent.calendarId));
+      return;
+    }
+    setSaving(false);
+    if (outcome.outcome === "saved") {
+      setHeld(null);
+      // Made again after the look-first words: they've done their job.
+      setUnproven(null);
+      noteCreateResult(sent, token, outcome, whereOf(sent.calendarId));
+      closeBack(true);
+      return;
+    }
+    const next = retryAfter(token, outcome);
+    if (next !== null) {
+      // It may be in Google: show exactly what was sent, locked, for Check again.
+      setHeld({ token: next, sent, fields });
+      setDraft(fields);
+      setCalendarId(sent.calendarId);
+    } else {
+      setHeld(null);
+      // A held token ended without Google showing it made: it may still be there.
+      if (h) setUnproven({ sent, outcome });
+    }
+    setBanner(createText(outcome, fields.summary, next !== null));
+    refocusSave();
+  }
+
+  const locked = saving || held !== null;
+  const timeOff = deviceZone === null;
+  const timeEditable = !locked && !timeOff;
+  const check = checkDraft(NEW_EVENT_BASE, draft);
+  const t = draft.time;
+  const timed = t.kind === "timed" ? t : null;
+  // 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]);
+  // The one date field's name, on screen and in its refusal.
+  const dateName = timed ? "Date" : "Day";
+  // 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),
+  ];
+
+  return (
+    <div
+      ref={panelRef}
+      role="dialog"
+      // No `aria-modal`: the calendar behind stays live, and Tab can leave. Over the calendar's write
+      // notices (z-[48]), as a modal's scrim is: a notice that never goes would cover Save.
+      aria-label="New event"
+      tabIndex={-1}
+      className="fixed z-50 flex w-[22rem] max-w-[calc(100vw-1rem)] flex-col gap-3 rounded-[var(--radius)] border border-border2 bg-panel p-3 shadow-2xl focus:outline-none"
+      style={{
+        left: pos?.left ?? anchor.left,
+        top: pos?.top ?? anchor.bottom + 6,
+        visibility: pos ? "visible" : "hidden",
+      }}
+    >
+      <div className="flex items-center gap-2">
+        <Input
+          ref={titleRef}
+          aria-label="Title"
+          placeholder="Add title"
+          value={draft.summary}
+          disabled={locked}
+          onChange={(e) => setDraft({ ...draftRef.current, summary: e.target.value })}
+          onKeyDown={(e) => {
+            // Enter saves, as in Google's quick box; not with a modifier, nor while composing text
+            // (WebKit sends the Enter that ends a composition after it, as key code 229), nor again
+            // on a held key's repeats.
+            if (e.key !== "Enter" || e.shiftKey || e.ctrlKey || e.metaKey || e.altKey) return;
+            if (e.nativeEvent.isComposing || e.nativeEvent.keyCode === 229) return;
+            e.preventDefault();
+            if (e.repeat) return;
+            void save();
+          }}
+        />
+        <IconButton
+          label={held ? "Close" : "Discard"}
+          onClick={discard}
+          disabled={saving}
+          className="shrink-0"
+        >
+          ×
+        </IconButton>
+      </div>
+
+      {banner && (
+        <Callout tone={CALLOUT_TONE[banner.tone]} live>
+          {banner.text}
+        </Callout>
+      )}
+
+      <fieldset className="flex flex-col gap-2" disabled={!timeEditable}>
+        <legend className="sr-only">When</legend>
+        <div className="flex flex-wrap items-center gap-1.5 text-xs text-ink3">
+          <DateField
+            id={dateId}
+            ariaLabel={dateName}
+            value={timed ? timed.start_date : t.kind === "all_day" ? t.first_day : ""}
+            clearable={false}
+            disabled={!timeEditable}
+            // A refusal it holds marks it wrong and points it at the line that names it.
+            refused={badDate !== null}
+            describedBy={badDate !== null ? refusedLineId : undefined}
+            className="px-2 py-1 text-xs"
+            wrapperClassName="w-28"
+            onReject={setBadDate}
+            onAccept={() => setBadDate(null)}
+            onCommit={(date) => {
+              // The whole event moves, keeping its length.
+              const was = draftRef.current.time;
+              changeTime(
+                was.kind === "timed" ? moveStart(was, date, was.start_time) : moveAllDay(was, date),
+              );
+            }}
+          />
+          {timed ? (
+            <>
+              <TimeField
+                ariaLabel="Start time"
+                compact
+                value={timed.start_time}
+                disabled={!timeEditable}
+                onChange={(hm) => changeTime(moveStart(timed, timed.start_date, hm))}
+              />
+              {timed.end_date === timed.start_date ? (
+                <>
+                  <span aria-hidden>–</span>
+                  <TimeField
+                    ariaLabel="End time"
+                    compact
+                    value={timed.end_time}
+                    choices={endChoices}
+                    disabled={!timeEditable}
+                    onChange={(end_time) => changeTime({ ...timed, end_time })}
+                  />
+                </>
+              ) : (
+                // Another day for the end is the full editor's to change.
+                <span>
+                  ends {formatDateOnly(timed.end_date)} · {timed.end_time}
+                </span>
+              )}
+            </>
+          ) : (
+            t.kind === "all_day" &&
+            t.last_day !== t.first_day && <span>to {formatDateOnly(t.last_day)}</span>
+          )}
+        </div>
+        <label className="flex items-center gap-2 text-xs text-ink3">
+          <Toggle
+            ariaLabel="All day"
+            checked={t.kind === "all_day"}
+            disabled={!timeEditable}
+            onChange={switchKind}
+          />
+          All day
+        </label>
+        {/* 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">
+            {badDateText(dateName, badDate)}
+          </p>
+        )}
+      </fieldset>
+
+      {check.ambiguous.map((half) => (
+        <p key={half} className="text-xs text-ink4">
+          {ambiguousText(half)}
+        </p>
+      ))}
+      {/* What would stop the save, shown as it happens rather than only on Save. */}
+      {lines.map((text) => (
+        <p key={text} className="text-xs text-st-due">
+          {text}
+        </p>
+      ))}
+      {notes.map((n) => (
+        <p key={n} className="font-mono text-[0.6875rem] leading-relaxed text-ink4">
+          {n}
+        </p>
+      ))}
+
+      <div className="flex flex-wrap items-center gap-2">
+        <CalendarPicker
+          compact
+          targets={targets}
+          value={calendarId}
+          onChange={pickCalendar}
+          privateDraft={false}
+          hidden={hidden}
+          colorOf={colorOf}
+          shapeOf={shapeOf}
+          disabled={locked}
+        />
+        <div className="ml-auto flex items-center gap-2">
+          <Button variant="tertiary" size="sm" onClick={more} disabled={saving}>
+            More options
+          </Button>
+          <Button
+            ref={saveButton}
+            variant="primary"
+            size="sm"
+            onClick={() => void save()}
+            // A held Enter here, once an answer put focus on it, clicks it again on every repeat.
+            onKeyDown={(e) => {
+              if (e.key === "Enter" && e.repeat) e.preventDefault();
+            }}
+            disabled={saving || timeOff}
+          >
+            {saving ? (held ? "Checking…" : "Saving…") : held ? "Check again" : "Save"}
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/calendar/parts/AllDayBand.tsx b/src/components/calendar/parts/AllDayBand.tsx
index ad0eb5df..854ac1e9 100644
--- a/src/components/calendar/parts/AllDayBand.tsx
+++ b/src/components/calendar/parts/AllDayBand.tsx
@@ -13,10 +13,13 @@ import type { CalendarEvent } from "../../../lib/types";
 import {
   clampSpanToRange,
   dayDiff,
+  DRAFT_EVENT_CLASS,
+  draftNote,
   eventDaySpan,
   isEventPast,
   packBands,
   PAST_EVENT_CLASS,
+  spokenName,
   type BandInput,
 } from "../../../lib/calendar-layout";
 import { eventColour, eventFill, eventHover, inkOn } from "../../../theme/eventPalette";
@@ -113,14 +116,16 @@ export function AllDayBand({
           const widthPct = ((b.endDay - b.startDay + 1) / ndays) * 100;
           const clickable = !!onEventClick;
           const past = isEventPast(b.ev, nowRef);
+          const ghost = draftNote(b.ev);
           return (
             <div
               key={b.ev.id}
               className={cn(
                 "absolute overflow-hidden px-1.5 text-[0.6875rem] leading-[1.125rem]",
                 clickable && `cursor-pointer ${eventHover(own)}`,
-                past && PAST_EVENT_CLASS,
+                ghost !== null ? DRAFT_EVENT_CLASS : past && PAST_EVENT_CLASS,
               )}
+              data-draft-event={ghost !== null ? "" : undefined}
               style={{
                 top: `${b.lane * LANE_H}px`,
                 left: `${leftPct}%`,
@@ -134,7 +139,7 @@ export function AllDayBand({
                 borderBottomRightRadius: b.continuesRight ? 0 : "var(--radius-sm)",
               }}
               title={b.ev.summary}
-              aria-label={b.ev.summary}
+              aria-label={spokenName(ghost, b.ev.summary)}
               role={clickable ? "button" : undefined}
               tabIndex={clickable ? 0 : undefined}
               onClick={
diff --git a/src/components/calendar/parts/EventCard.tsx b/src/components/calendar/parts/EventCard.tsx
index 9effee97..0861a1a0 100644
--- a/src/components/calendar/parts/EventCard.tsx
+++ b/src/components/calendar/parts/EventCard.tsx
@@ -14,7 +14,7 @@
 
 import type { CSSProperties } from "react";
 import { cn } from "../../ui";
-import { PAST_EVENT_CLASS } from "../../../lib/calendar-layout";
+import { DRAFT_EVENT_CLASS, PAST_EVENT_CLASS, spokenName } from "../../../lib/calendar-layout";
 import { eventFill, eventHover, inkOn, type EventColour } from "../../../theme/eventPalette";
 
 interface Props {
@@ -37,6 +37,9 @@ interface Props {
   showLocation: boolean;
   /** The event has fully passed — grey it back so what's done recedes. */
   isPast?: boolean;
+  /** The new event being made (its ghost): the words its name starts with, saying so (`draftNote`).
+   *  Drawn dashed, never greyed as past. Null for any other event. */
+  ghost?: string | null;
   /** A piece of an event across days: it started on an earlier day (square top) or runs on into
    *  a later one (square bottom). */
   continuesBefore?: boolean;
@@ -66,6 +69,7 @@ export function EventCard({
   showTime,
   showLocation,
   isPast,
+  ghost = null,
   continuesBefore,
   continuesAfter,
   tabStop = true,
@@ -90,16 +94,18 @@ export function EventCard({
   const withTime = showTime && heightPx >= TIME_MIN_H;
   const withLoc = showLocation && !!location && heightPx >= LOC_MIN_H;
 
-  // A full accessible name (summary + time + place) even when the card is too short to show the meta.
-  const ariaLabel = [summary, timeLabel, location].filter(Boolean).join(", ");
+  // A full accessible name (summary + time + place) even when the card is too short to show the meta,
+  // the ghost's saying first that it's the new event.
+  const ariaLabel = spokenName(ghost, [summary, timeLabel, location].filter(Boolean).join(", "));
 
   return (
     <div
       className={cn(
         "absolute overflow-hidden rounded-[var(--radius-sm)] border border-border border-l-[3px] px-1.5 py-0.5",
         onSelect && `cursor-pointer ${eventHover(own)}`,
-        isPast && PAST_EVENT_CLASS,
+        ghost !== null ? DRAFT_EVENT_CLASS : isPast && PAST_EVENT_CLASS,
       )}
+      data-draft-event={ghost !== null ? "" : undefined}
       style={style}
       title={summary}
       aria-label={ariaLabel}
diff --git a/src/components/calendar/parts/EventChip.tsx b/src/components/calendar/parts/EventChip.tsx
index 1d423208..ae9ff6d9 100644
--- a/src/components/calendar/parts/EventChip.tsx
+++ b/src/components/calendar/parts/EventChip.tsx
@@ -9,7 +9,7 @@
 // to dots.
 
 import { cn } from "../../ui";
-import { PAST_EVENT_CLASS } from "../../../lib/calendar-layout";
+import { DRAFT_EVENT_CLASS, PAST_EVENT_CLASS, spokenName } from "../../../lib/calendar-layout";
 import { eventFill, eventHover, inkOn, type EventColour } from "../../../theme/eventPalette";
 
 interface Props {
@@ -23,6 +23,9 @@ interface Props {
   showTime: boolean;
   /** The event has fully passed — grey it back so what's done recedes. */
   isPast?: boolean;
+  /** The new event being made (its ghost): the words its name starts with, saying so (`draftNote`).
+   *  Drawn dashed, never greyed as past. Null for any other event. */
+  ghost?: string | null;
   /** When set, the chip is interactive — click / Enter / Space opens the event's detail popup,
    *  anchored at the chip's on-screen rect. */
   onClick?: (anchor: DOMRect) => void;
@@ -35,6 +38,7 @@ export function EventChip({
   timeLabel,
   showTime,
   isPast,
+  ghost = null,
   onClick,
 }: Props) {
   return (
@@ -42,14 +46,15 @@ export function EventChip({
       className={cn(
         "flex items-center gap-1 overflow-hidden rounded-[var(--radius-sm)] border-l-[2px] px-1 py-px text-[0.6875rem] leading-tight",
         onClick && `cursor-pointer ${eventHover(own)}`,
-        isPast && PAST_EVENT_CLASS,
+        ghost !== null ? DRAFT_EVENT_CLASS : isPast && PAST_EVENT_CLASS,
       )}
+      data-draft-event={ghost !== null ? "" : undefined}
       style={{
         background: eventFill(own, color, 16),
         borderLeftColor: color,
       }}
       title={summary}
-      aria-label={[timeLabel, summary].filter(Boolean).join(", ")}
+      aria-label={spokenName(ghost, [timeLabel, summary].filter(Boolean).join(", "))}
       role={onClick ? "button" : undefined}
       tabIndex={onClick ? 0 : undefined}
       onClick={onClick ? (e) => onClick(e.currentTarget.getBoundingClientRect()) : undefined}
diff --git a/src/components/calendar/parts/SourceDot.test.tsx b/src/components/calendar/parts/SourceDot.test.tsx
index c8952ce9..529c5605 100644
--- a/src/components/calendar/parts/SourceDot.test.tsx
+++ b/src/components/calendar/parts/SourceDot.test.tsx
@@ -16,7 +16,7 @@ import { SourceDot } from "./SourceDot";
 
 afterEach(cleanup);
 
-const dot = (props: { color: string; shapeIndex?: number }) =>
+const dot = (props: { color: string; shapeIndex?: number; ghost?: boolean }) =>
   render(<SourceDot {...props} />).container.querySelector("span")!;
 
 describe("SourceDot shape redundancy", () => {
@@ -40,3 +40,17 @@ describe("SourceDot shape redundancy", () => {
     expect(dot({ color: "#f00" }).className).toContain("rounded-full");
   });
 });
+
+// The new event's ghost (#884, C10c) in the Month view's dots: a ring, dashed, in the colour, never
+// a fill, so it doesn't read as saved; round even under the axis, as a cut shape would cut its ring.
+describe("SourceDot as the new event's ghost", () => {
+  it("is a dashed ring in the colour, not a fill", () => {
+    mockColorblind = true;
+    const span = dot({ color: "#f00", shapeIndex: 2, ghost: true });
+    expect(span.className).toContain("border-dashed");
+    expect(span.className).toContain("rounded-full");
+    expect(span.style.borderColor).toBe("rgb(255, 0, 0)");
+    expect(span.style.backgroundColor).toBe("");
+    expect(span.style.clipPath).toBe("");
+  });
+});
diff --git a/src/components/calendar/parts/SourceDot.tsx b/src/components/calendar/parts/SourceDot.tsx
index 29bdb08c..ddb221ca 100644
--- a/src/components/calendar/parts/SourceDot.tsx
+++ b/src/components/calendar/parts/SourceDot.tsx
@@ -26,20 +26,31 @@ interface Props {
   /** The source's slot (from sourceShapeIndex), used to pick a redundant shape when the colour-blind
    *  axis is on. Omit (overlays, unknowns) to keep the plain circle. */
   shapeIndex?: number;
+  /** The new event's ghost (the Month view's dots): a dashed ring in the colour rather than a fill,
+   *  so it doesn't read as saved. Always round, as a cut shape would cut its ring. */
+  ghost?: boolean;
   className?: string;
 }
 
 /** The small colour dot that identifies a calendar (source) in the dropdown, agenda rows, and legend.
  *  Reserves the accent for chrome, so a source is never confusable with "now". Under the colour-blind
  *  axis it also carries a per-source shape (see {@link SHAPES}). */
-export function SourceDot({ color, shapeIndex, className }: Props) {
+export function SourceDot({ color, shapeIndex, ghost = false, className }: Props) {
   const { colorblind } = useTheme();
-  const clip = colorblind && shapeIndex != null ? SHAPES[shapeIndex % SHAPES.length] : null;
+  const clip =
+    colorblind && shapeIndex != null && !ghost ? SHAPES[shapeIndex % SHAPES.length] : null;
   return (
     <span
       aria-hidden
-      className={cn("inline-block h-2.5 w-2.5 shrink-0", clip == null && "rounded-full", className)}
-      style={{ backgroundColor: color, clipPath: clip ?? undefined }}
+      className={cn(
+        "inline-block h-2.5 w-2.5 shrink-0",
+        clip == null && "rounded-full",
+        ghost && "border border-dashed",
+        className,
+      )}
+      style={
+        ghost ? { borderColor: color } : { backgroundColor: color, clipPath: clip ?? undefined }
+      }
     />
   );
 }
diff --git a/src/components/calendar/parts/useMonthGrid.test.tsx b/src/components/calendar/parts/useMonthGrid.test.tsx
index bcd1c047..2dd579fb 100644
--- a/src/components/calendar/parts/useMonthGrid.test.tsx
+++ b/src/components/calendar/parts/useMonthGrid.test.tsx
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import { describe, it, expect } from "vitest";
-import { buildWeekRows, weekStartMonday } from "./useMonthGrid";
-import { dayKey } from "../../../lib/calendar-layout";
+import { buildWeekRows, chipsShown, MONTH_MAX_BAND_LANES, weekStartMonday } from "./useMonthGrid";
+import { dayKey, DRAFT_EVENT_ID } from "../../../lib/calendar-layout";
 
 describe("weekStartMonday", () => {
   it("returns the Monday of the week the date falls in", () => {
@@ -89,4 +89,113 @@ describe("buildWeekRows (continuous stream)", () => {
     const bar = inside.flatMap((w) => w.bands)[0];
     expect([bar.continuesLeft, bar.continuesRight]).toEqual([false, false]);
   });
+
+  // The new event's ghost (#884, C10c) is never folded into "+N more" as it's typed: past the lane
+  // cap it would only add to the count. It takes the top lane instead.
+  it("gives the new event's ghost band the top lane, under three bands already there", () => {
+    const span = (id: string, start: string, end: string) => ({
+      ...timed(start, end),
+      id,
+      all_day: true,
+    });
+    const weeks = buildWeekRows(start, 1, [
+      span("a", "2026-07-13", "2026-07-18"),
+      span("b", "2026-07-13", "2026-07-18"),
+      span("c", "2026-07-13", "2026-07-18"),
+      span(DRAFT_EVENT_ID, "2026-07-15", "2026-07-17"),
+    ]);
+    const lanes = new Map(weeks[0].bands.map((b) => [b.ev.id, b.lane]));
+    expect(lanes.get(DRAFT_EVENT_ID)).toBe(0);
+    expect(weeks[0].bands).toHaveLength(MONTH_MAX_BAND_LANES);
+    // The band it put out of sight is counted instead.
+    expect(weeks[0].cells[0].hiddenBands).toBe(1);
+  });
+
+  // The stream runs for months: the ghost's top lane is its own weeks', so a week it never touches
+  // keeps its bands where they were, none folded away and no row added.
+  it("leaves a week the ghost band doesn't touch as it was", () => {
+    const span = (id: string, start: string, end: string) => ({
+      ...timed(start, end),
+      id,
+      all_day: true,
+    });
+    const before = [
+      span("a", "2026-07-13", "2026-07-18"),
+      span("b", "2026-07-13", "2026-07-18"),
+      span("c", "2026-07-13", "2026-07-18"),
+    ];
+    const plain = buildWeekRows(start, 3, before);
+    // Two weeks on, timed across midnight: a band, as a start moved to 23:30 makes it.
+    const weeks = buildWeekRows(start, 3, [
+      ...before,
+      { ...timed("2026-07-28T23:30:00", "2026-07-29T00:30:00"), id: DRAFT_EVENT_ID },
+    ]);
+    const lanes = new Map(weeks[0].bands.map((b) => [b.ev.id, b.lane]));
+    expect([lanes.get("a"), lanes.get("b"), lanes.get("c")]).toEqual([0, 1, 2]);
+    expect(weeks[0].cells.map((c) => c.hiddenBands)).toEqual([0, 0, 0, 0, 0, 0, 0]);
+    expect(weeks[0].laneCount).toBe(plain[0].laneCount);
+    // And the ghost has the top lane in its own week.
+    expect(weeks[2].bands.map((b) => [b.ev.id, b.lane])).toEqual([[DRAFT_EVENT_ID, 0]]);
+  });
+
+  // The same for bands that run into the ghost's days: kept out of the top lane for their whole run,
+  // they'd leave it empty and fold one away in every week they cover. They give it up only in the
+  // ghost's own week.
+  it("leaves the weeks the ghost band doesn't touch as they were, for bands that reach its days", () => {
+    const span = (id: string, start: string, end: string) => ({
+      ...timed(start, end),
+      id,
+      all_day: true,
+    });
+    // From two weeks before the ghost's week to the week after it.
+    const through = [
+      span("a", "2026-07-13", "2026-08-06"),
+      span("b", "2026-07-13", "2026-08-06"),
+      span("c", "2026-07-13", "2026-08-06"),
+    ];
+    const plain = buildWeekRows(start, 4, through);
+    const weeks = buildWeekRows(start, 4, [
+      ...through,
+      { ...timed("2026-07-28T23:30:00", "2026-07-29T00:30:00"), id: DRAFT_EVENT_ID },
+    ]);
+    for (const w of [0, 1, 3]) {
+      const lanes = new Map(weeks[w].bands.map((b) => [b.ev.id, b.lane]));
+      expect([lanes.get("a"), lanes.get("b"), lanes.get("c")]).toEqual([0, 1, 2]);
+      expect(weeks[w].cells.map((c) => c.hiddenBands)).toEqual([0, 0, 0, 0, 0, 0, 0]);
+      expect(weeks[w].laneCount).toBe(plain[w].laneCount);
+    }
+    // In its own week the ghost has the top lane, and the band it puts out of sight is counted.
+    expect(weeks[2].bands.find((b) => b.ev.id === DRAFT_EVENT_ID)?.lane).toBe(0);
+    expect(weeks[2].cells[0].hiddenBands).toBe(1);
+  });
+});
+
+describe("chipsShown", () => {
+  const chip = (id: string) => ({
+    id,
+    calendar_id: "c",
+    summary: id,
+    description: null,
+    location: null,
+    start: "2026-07-15T09:00:00",
+    end: "2026-07-15T10:00:00",
+    all_day: false,
+    html_link: null,
+    uid: null,
+  });
+  const ids = (evs: { id: string }[]) => evs.map((e) => e.id);
+
+  it("draws the first that fit, and the ghost in the last place when it would fold away", () => {
+    const day = [chip("a"), chip("b"), chip("c"), chip("d"), chip(DRAFT_EVENT_ID)];
+    expect(ids(chipsShown(day, 3))).toEqual(["a", "b", DRAFT_EVENT_ID]);
+    // Already in reach, it stays where it sorts.
+    expect(ids(chipsShown([chip(DRAFT_EVENT_ID), ...day.slice(0, 3)], 3))).toEqual([
+      DRAFT_EVENT_ID,
+      "a",
+      "b",
+    ]);
+    // Without a ghost, the first that fit.
+    expect(ids(chipsShown(day.slice(0, 4), 3))).toEqual(["a", "b", "c"]);
+    expect(chipsShown(day, 0)).toEqual([]);
+  });
 });
diff --git a/src/components/calendar/parts/useMonthGrid.ts b/src/components/calendar/parts/useMonthGrid.ts
index 9e3eb13f..8ed358ad 100644
--- a/src/components/calendar/parts/useMonthGrid.ts
+++ b/src/components/calendar/parts/useMonthGrid.ts
@@ -5,7 +5,8 @@
 // MonthTable — a Monday-first 6×7 grid with single-day events bucketed as chips and multi-day events
 // packed into stacked bands. Extracted so the two Systems can't drift (a band-lane or overflow fix
 // lands once). Multi-day bands are packed ONCE across the whole grid, so a run keeps the same lane
-// row across week boundaries; bands past the lane cap are counted per covered day so the view can
+// row across week boundaries (while a new event is drafted, the weeks its ghost touches are packed
+// with the ghost on top); bands past the lane cap are counted per covered day so the view can
 // surface a "+N more" instead of silently dropping them.
 
 import { useMemo } from "react";
@@ -16,7 +17,9 @@ import {
   compareEventsForDay,
   dayDiff,
   dayKey,
+  DRAFT_EVENT_ID,
   eventDaySpan,
+  isDraftEvent,
   isMultiDay,
   packBands,
   parseLocal,
@@ -125,8 +128,16 @@ export function buildWeekRows(
       cutRight: clamped.continuesRight,
     });
   }
-  const { bands: globalBands } = packBands(bandInputs);
-  const laneOf = new Map(globalBands.map((b) => [b.id, b.lane]));
+  // The new event's ghost takes the top lane, so it never folds into "+N more" as it's typed. That
+  // packing is used only in the weeks the ghost's own days touch, and the packing without it in every
+  // other: a band that reaches the ghost's days is kept out of the top lane for its whole run, so
+  // weeks the ghost never touches would change as it moved. While the draft is open, a band may
+  // change lane where it runs into or out of the ghost's weeks.
+  const lanesOf = (first?: string) =>
+    new Map(packBands(bandInputs, first).bands.map((b) => [b.id, b.lane]));
+  const plainLanes = lanesOf();
+  const ghost = bandMeta.get(DRAFT_EVENT_ID);
+  const ghostLanes = ghost ? lanesOf(DRAFT_EVENT_ID) : plainLanes;
 
   const weeks: MonthWeekRow[] = [];
   for (let r = 0; r < rows; r++) {
@@ -136,6 +147,8 @@ export function buildWeekRows(
     const hiddenByCol = new Array(7).fill(0);
     const bars: MonthBandBar[] = [];
     let laneCount = 0;
+    const laneOf =
+      ghost && ghost.gEnd >= weekStartIdx && ghost.gStart <= weekEndIdx ? ghostLanes : plainLanes;
 
     for (const [id, { ev, gStart, gEnd, cutLeft, cutRight }] of bandMeta) {
       if (gEnd < weekStartIdx || gStart > weekEndIdx) continue; // band doesn't touch this week
@@ -175,6 +188,16 @@ export function buildWeekRows(
   return weeks;
 }
 
+/** The chips a day draws when it has room for `max`, the rest counted as "+N more": the first `max`,
+ *  except that the new event's ghost is always among them. On a busy day it takes the last place
+ *  shown, so it never vanishes as it's typed, and the count stays the same. */
+export function chipsShown(chips: CalendarEvent[], max: number): CalendarEvent[] {
+  const shown = chips.slice(0, max);
+  const ghost = chips.find(isDraftEvent);
+  if (!ghost || max < 1 || shown.includes(ghost)) return shown;
+  return [...shown.slice(0, max - 1), ghost];
+}
+
 /** Monday-first weekday labels ("Mon"…"Sun"), for the grid/stream header. */
 export function weekdayLabels(): string[] {
   const monday = weekStartMonday(new Date());
diff --git a/src/components/calendar/views/AgendaView.test.tsx b/src/components/calendar/views/AgendaView.test.tsx
new file mode 100644
index 00000000..2f52c6ba
--- /dev/null
+++ b/src/components/calendar/views/AgendaView.test.tsx
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Agenda draws the event being made (#884, C10c) as its ghost: dashed, in its calendar's colour,
+// never greyed as past, named as the new event, and marked so a click on it isn't a click outside
+// quick create; a synced row beside it is drawn and named as ever.
+
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { CalendarEvent } from "../../../lib/types";
+import { DRAFT_EVENT_ID } from "../../../lib/calendar-layout";
+import { formatClock } from "../../../lib/format";
+
+vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth: "standard" }),
+}));
+
+import { AgendaView } from "./AgendaView";
+
+afterEach(cleanup);
+
+const ev = (over: Partial<CalendarEvent>): CalendarEvent => ({
+  id: "e1",
+  calendar_id: "home",
+  summary: "Synced",
+  description: null,
+  location: null,
+  start: "2026-10-12T09:00:00",
+  end: "2026-10-12T10:00:00",
+  all_day: false,
+  html_link: null,
+  uid: null,
+  ...over,
+});
+
+// A row says its time in the reader's own clock (09:00 here, 09:00 AM on CI's runner), so the names
+// are built with the helper the view uses and hold in any locale.
+const clock = (h: number) => formatClock(new Date(2026, 9, 12, h));
+
+function agenda(events: CalendarEvent[]) {
+  render(
+    <AgendaView
+      events={events}
+      fromDay={new Date(2026, 9, 12)}
+      colorOf={(id) => (id === "work" ? "#336699" : "#993366")}
+      // Both rows are over by now: a synced one greys, the ghost doesn't.
+      now={new Date(2026, 9, 20)}
+      onEventClick={vi.fn()}
+    />,
+  );
+}
+
+describe("AgendaView", () => {
+  it("draws the new event's ghost dashed and named as new, beside a synced row as ever", () => {
+    agenda([
+      ev({}),
+      ev({
+        id: DRAFT_EVENT_ID,
+        calendar_id: "work",
+        summary: "Dentist",
+        start: "2026-10-12T11:00:00",
+      }),
+    ]);
+    const ghost = screen.getByRole("button", {
+      name: `New event, not saved yet: ${clock(11)}, Dentist`,
+    });
+    expect(ghost.className).toContain("outline-dashed");
+    expect(ghost.className).toContain("-outline-offset-1");
+    expect(ghost.className).not.toContain("opacity-60");
+    expect(ghost.hasAttribute("data-draft-event")).toBe(true);
+    expect(ghost.style.borderLeftColor).toBe("rgb(51, 102, 153)");
+    const synced = screen.getByRole("button", { name: new RegExp(`^${clock(9)}\\s*Synced$`) });
+    expect(synced.className).not.toContain("outline-dashed");
+    expect(synced.className).toContain("opacity-60");
+    expect(synced.hasAttribute("data-draft-event")).toBe(false);
+    expect(synced.style.borderLeftColor).toBe("rgb(153, 51, 102)");
+  });
+
+  it("names a ghost a save may have made without saying it isn't saved", () => {
+    agenda([
+      {
+        ...ev({ id: DRAFT_EVENT_ID, summary: "Dentist" }),
+        draft_state: "unsure",
+      } as CalendarEvent,
+    ]);
+    expect(
+      screen.getByRole("button", {
+        name: `New event, PM may already have made it: ${clock(9)}, Dentist`,
+      }),
+    ).toBeTruthy();
+  });
+});
diff --git a/src/components/calendar/views/AgendaView.tsx b/src/components/calendar/views/AgendaView.tsx
index cfcb7dd9..2d820c76 100644
--- a/src/components/calendar/views/AgendaView.tsx
+++ b/src/components/calendar/views/AgendaView.tsx
@@ -10,9 +10,12 @@ import type { CalendarEvent } from "../../../lib/types";
 import { formatClockIso, formatDateLocal } from "../../../lib/format";
 import {
   dayKey,
+  DRAFT_EVENT_CLASS,
+  draftNote,
   groupEventsFromDay,
   isEventPast,
   PAST_EVENT_CLASS,
+  spokenName,
   startOfDay,
   weekdayShort,
 } from "../../../lib/calendar-layout";
@@ -82,6 +85,7 @@ export function AgendaView({ events, fromDay, colorOf, now, onEventClick }: Prop
               {g.items.map((ev) => {
                 const clickable = !!onEventClick;
                 const own = eventColour(ev.color_id);
+                const ghost = draftNote(ev);
                 return (
                   <li
                     key={ev.id}
@@ -91,8 +95,22 @@ export function AgendaView({ events, fromDay, colorOf, now, onEventClick }: Prop
                       // A filled row's inline background outranks hover:bg-surface, so its fill
                       // changes brightness instead.
                       clickable && (own ? eventHover(own) : "hover:bg-surface"),
-                      isEventPast(ev, nowDate) && PAST_EVENT_CLASS,
+                      ghost !== null
+                        ? DRAFT_EVENT_CLASS
+                        : isEventPast(ev, nowDate) && PAST_EVENT_CLASS,
                     )}
+                    data-draft-event={ghost !== null ? "" : undefined}
+                    // A row's name is its text; the ghost's says first that it's the new event.
+                    aria-label={
+                      ghost !== null
+                        ? spokenName(
+                            ghost,
+                            [eventTime(ev), ev.summary, showPower && ev.location]
+                              .filter(Boolean)
+                              .join(", "),
+                          )
+                        : undefined
+                    }
                     style={{
                       borderLeftColor: colorOf(ev.calendar_id),
                       // An event given its own colour in Google is filled with it, solid, in its own
diff --git a/src/components/calendar/views/MonthView.test.tsx b/src/components/calendar/views/MonthView.test.tsx
new file mode 100644
index 00000000..11be59bf
--- /dev/null
+++ b/src/components/calendar/views/MonthView.test.tsx
@@ -0,0 +1,178 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// The Month view draws the event being made (#884, C10c) as its ghost: a chip, or a band across days,
+// dashed and in its calendar's colour, never greyed as past, named as the new event, beside synced
+// events drawn as ever; never folded into "+N more" on a busy day; and at Minimal depth, a dashed
+// ring among the dots.
+
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+import type { CalendarEvent } from "../../../lib/types";
+import { DRAFT_EVENT_ID } from "../../../lib/calendar-layout";
+import { formatClock } from "../../../lib/format";
+
+let depth = "standard";
+
+vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth }),
+}));
+
+import { MonthView } from "./MonthView";
+
+// jsdom lays nothing out and ships no ResizeObserver, and the view draws its weeks only once it has
+// measured its pane: give every element a height, and the pane a scrollTo, then put them back.
+let restore: (() => void) | null = null;
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+  const height = Object.getOwnPropertyDescriptor(Element.prototype, "clientHeight");
+  const scrollTo = Object.getOwnPropertyDescriptor(Element.prototype, "scrollTo");
+  Object.defineProperty(Element.prototype, "clientHeight", { configurable: true, get: () => 600 });
+  Object.defineProperty(Element.prototype, "scrollTo", { configurable: true, value: () => {} });
+  restore = () => {
+    if (height) Object.defineProperty(Element.prototype, "clientHeight", height);
+    if (scrollTo) Object.defineProperty(Element.prototype, "scrollTo", scrollTo);
+    else delete (Element.prototype as { scrollTo?: unknown }).scrollTo;
+  };
+});
+afterAll(() => restore?.());
+
+afterEach(cleanup);
+
+const ev = (over: Partial<CalendarEvent>): CalendarEvent => ({
+  id: "e1",
+  calendar_id: "home",
+  summary: "Synced",
+  description: null,
+  location: null,
+  start: "2026-10-12T09:00:00",
+  end: "2026-10-12T10:00:00",
+  all_day: false,
+  html_link: null,
+  uid: null,
+  ...over,
+});
+
+// A chip says its time in the reader's own clock (09:00 here, 09:00 AM on CI's runner), so the names
+// are built with the helper the view uses and hold in any locale.
+const clock = (h: number) => formatClock(new Date(2026, 9, 13, h));
+
+function month(events: CalendarEvent[]) {
+  render(
+    <MonthView
+      cursor={new Date(2026, 9, 1)}
+      events={events}
+      colorOf={(id) => (id === "work" ? "#336699" : "#993366")}
+      onFocusDate={() => {}}
+      // Every event here is over by now: a synced one greys, the ghost doesn't.
+      now={new Date(2026, 9, 20)}
+      onEventClick={vi.fn()}
+    />,
+  );
+}
+
+describe("MonthView", () => {
+  it("draws the new event's ghost dashed in its calendar's colour, as a chip or a band", () => {
+    month([
+      ev({}),
+      ev({
+        id: DRAFT_EVENT_ID,
+        calendar_id: "work",
+        summary: "Dentist",
+        start: "2026-10-13T11:00:00",
+      }),
+    ]);
+    // Named as the new event, not yet saved, so it isn't heard as one that's in the calendar.
+    const chip = screen.getByRole("button", {
+      name: `New event, not saved yet: ${clock(11)}, Dentist`,
+    });
+    // Dashed inside its edge: a cell's list clips its chips, and would take an outer dash away.
+    expect(chip.className).toContain("outline-dashed");
+    expect(chip.className).toContain("-outline-offset-1");
+    expect(chip.className).not.toContain("opacity-60");
+    expect(chip.hasAttribute("data-draft-event")).toBe(true);
+    expect(chip.style.borderLeftColor).toBe("rgb(51, 102, 153)");
+    const synced = screen.getByRole("button", { name: `${clock(9)}, Synced` });
+    expect(synced.className).not.toContain("outline-dashed");
+    expect(synced.className).toContain("opacity-60");
+    cleanup();
+    month([
+      {
+        ...ev({
+          id: DRAFT_EVENT_ID,
+          calendar_id: "work",
+          summary: "Away",
+          start: "2026-10-13",
+          end: "2026-10-16",
+          all_day: true,
+        }),
+        draft_state: "saving",
+      } as CalendarEvent,
+    ]);
+    const band = screen.getByRole("button", { name: "New event, saving: Away" });
+    expect(band.className).toContain("outline-dashed");
+    expect(band.className).toContain("-outline-offset-1");
+    expect(band.className).not.toContain("opacity-60");
+    expect(band.hasAttribute("data-draft-event")).toBe(true);
+  });
+
+  // Three events earlier in the day fill the cell: the ghost, later than all of them, still shows as
+  // it's typed, in the last place, and the count stays honest.
+  it("keeps the ghost on a busy day, in the last place, rather than in +N more", () => {
+    month([
+      ev({ id: "a", summary: "One", start: "2026-10-13T08:00:00" }),
+      ev({ id: "b", summary: "Two", start: "2026-10-13T09:00:00" }),
+      ev({ id: "c", summary: "Three", start: "2026-10-13T10:00:00" }),
+      ev({ id: DRAFT_EVENT_ID, summary: "Dentist", start: "2026-10-13T15:00:00" }),
+    ]);
+    expect(
+      screen.getByRole("button", { name: `New event, not saved yet: ${clock(15)}, Dentist` }),
+    ).toBeTruthy();
+    expect(screen.queryByRole("button", { name: `${clock(10)}, Three` })).toBeNull();
+    expect(screen.getByText("+1 more")).toBeTruthy();
+  });
+
+  // Minimal depth draws dots: the ghost's is a dashed ring, not a fill, carries the mark that keeps a
+  // click on it from closing quick create, and is the one dot with a name. On a day with more dots
+  // than fit, it takes the last place rather than folding into the count.
+  it("draws the ghost as a dashed ring among the dots at Minimal depth", () => {
+    depth = "min";
+    try {
+      month([
+        ...[8, 9, 10, 11, 12].map((h) =>
+          ev({ id: `s${h}`, start: `2026-10-12T${String(h).padStart(2, "0")}:00:00` }),
+        ),
+        ev({
+          id: DRAFT_EVENT_ID,
+          calendar_id: "work",
+          summary: "Dentist",
+          start: "2026-10-12T15:00:00",
+        }),
+      ]);
+      const ghost = document.querySelector("[data-draft-event]");
+      expect(ghost).not.toBeNull();
+      const ring = ghost!.querySelector<HTMLElement>("[aria-hidden]")!;
+      expect(ring.className).toContain("border-dashed");
+      expect(ring.style.borderColor).toBe("rgb(51, 102, 153)");
+      expect(ring.style.backgroundColor).toBe("");
+      expect(ghost!.textContent).toBe("New event, not saved yet: Dentist");
+      // A synced event's dot is filled, as ever, and has no mark: four of five, and one counted.
+      const dots = document.querySelectorAll<HTMLElement>("span[aria-hidden]");
+      const filled = [...dots].filter((d) => d.style.backgroundColor === "rgb(153, 51, 102)");
+      expect(filled).toHaveLength(4);
+      expect(filled.every((d) => d.closest("[data-draft-event]") === null)).toBe(true);
+      expect(screen.getByText("+1")).toBeTruthy();
+    } finally {
+      depth = "standard";
+    }
+  });
+});
diff --git a/src/components/calendar/views/MonthView.tsx b/src/components/calendar/views/MonthView.tsx
index a0461338..64bcd65f 100644
--- a/src/components/calendar/views/MonthView.tsx
+++ b/src/components/calendar/views/MonthView.tsx
@@ -13,8 +13,11 @@ import type { CalendarEvent } from "../../../lib/types";
 import {
   addDays,
   dayKey,
+  DRAFT_EVENT_CLASS,
+  draftNote,
   isEventPast,
   PAST_EVENT_CLASS,
+  spokenName,
   startOfDay,
 } from "../../../lib/calendar-layout";
 import { formatClockIso } from "../../../lib/format";
@@ -25,6 +28,7 @@ import { EventChip } from "../parts/EventChip";
 import { SourceDot } from "../parts/SourceDot";
 import {
   buildWeekRows,
+  chipsShown,
   weekStartMonday,
   weekdayLabels,
   type MonthWeekRow,
@@ -267,15 +271,29 @@ export function MonthView({
 
                     {minimal ? (
                       <div className="flex flex-wrap items-center gap-0.5">
-                        {cell.chips.slice(0, MAX_DOTS).map((ev) => (
-                          <SourceDot
-                            key={ev.id}
-                            // The event's own colour when it has one; the shape stays its calendar's.
-                            color={eventColour(ev.color_id)?.hex ?? colorOf(ev.calendar_id)}
-                            shapeIndex={shapeOf?.(ev.calendar_id)}
-                            className="h-2 w-2"
-                          />
-                        ))}
+                        {chipsShown(cell.chips, MAX_DOTS).map((ev) => {
+                          const note = draftNote(ev);
+                          const dot = (
+                            <SourceDot
+                              key={ev.id}
+                              // The event's own colour when it has one; the shape stays its
+                              // calendar's.
+                              color={eventColour(ev.color_id)?.hex ?? colorOf(ev.calendar_id)}
+                              shapeIndex={shapeOf?.(ev.calendar_id)}
+                              ghost={note !== null}
+                              className="h-2 w-2"
+                            />
+                          );
+                          if (note === null) return dot;
+                          // The ghost's ring keeps a click on it from closing quick create, and is
+                          // the one dot with a name: the others are saved events, this isn't one.
+                          return (
+                            <span key={ev.id} data-draft-event="" className="inline-flex">
+                              {dot}
+                              <span className="sr-only">{spokenName(note, ev.summary)}</span>
+                            </span>
+                          );
+                        })}
                         {dotsHidden > 0 && (
                           <span className="font-mono text-[0.5625rem] text-ink4">
                             +{dotsHidden}
@@ -284,7 +302,7 @@ export function MonthView({
                       </div>
                     ) : (
                       <div className="flex min-h-0 flex-col gap-0.5 overflow-hidden">
-                        {cell.chips.slice(0, maxChips).map((ev) => (
+                        {chipsShown(cell.chips, maxChips).map((ev) => (
                           <EventChip
                             key={ev.id}
                             summary={ev.summary}
@@ -293,6 +311,7 @@ export function MonthView({
                             timeLabel={ev.all_day ? "" : formatClockIso(ev.start)}
                             showTime={showMeta}
                             isPast={isEventPast(ev, nowDate)}
+                            ghost={draftNote(ev)}
                             onClick={onEventClick ? (rect) => onEventClick(ev, rect) : undefined}
                           />
                         ))}
@@ -317,6 +336,7 @@ export function MonthView({
                   const own = eventColour(b.ev.color_id);
                   const leftPct = (b.startIdx / 7) * 100;
                   const widthPct = ((b.endIdx - b.startIdx + 1) / 7) * 100;
+                  const ghost = draftNote(b.ev);
                   return (
                     <div
                       key={b.ev.id}
@@ -325,8 +345,11 @@ export function MonthView({
                         // re-enables its own pointer events to open the event popup.
                         "absolute overflow-hidden px-1.5 text-[0.6875rem] leading-[0.875rem]",
                         onEventClick && `pointer-events-auto cursor-pointer ${eventHover(own)}`,
-                        isEventPast(b.ev, nowDate) && PAST_EVENT_CLASS,
+                        ghost !== null
+                          ? DRAFT_EVENT_CLASS
+                          : isEventPast(b.ev, nowDate) && PAST_EVENT_CLASS,
                       )}
+                      data-draft-event={ghost !== null ? "" : undefined}
                       style={{
                         top: `${b.lane * BAND_H}px`,
                         left: `${leftPct}%`,
@@ -340,6 +363,17 @@ export function MonthView({
                         borderBottomRightRadius: b.continuesRight ? 0 : "var(--radius-sm)",
                       }}
                       title={b.ev.summary}
+                      // A band's name is its text; the ghost's says first that it's the new event.
+                      aria-label={
+                        ghost !== null
+                          ? spokenName(
+                              ghost,
+                              [b.ev.all_day ? "" : formatClockIso(b.ev.start), b.ev.summary]
+                                .filter(Boolean)
+                                .join(", "),
+                            )
+                          : undefined
+                      }
                       role={onEventClick ? "button" : undefined}
                       tabIndex={onEventClick ? 0 : undefined}
                       onClick={
diff --git a/src/components/calendar/views/TimeGridView.test.tsx b/src/components/calendar/views/TimeGridView.test.tsx
index b85b6f8f..7c9aeffc 100644
--- a/src/components/calendar/views/TimeGridView.test.tsx
+++ b/src/components/calendar/views/TimeGridView.test.tsx
@@ -10,6 +10,7 @@
 import { cleanup, fireEvent, render, screen, within } from "@testing-library/react";
 import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import type { CalendarEvent } from "../../../lib/types";
+import { DRAFT_EVENT_ID } from "../../../lib/calendar-layout";
 
 vi.mock("../../../theme/ThemeContext", async (importOriginal) => ({
   ...(await importOriginal<object>()),
@@ -110,6 +111,66 @@ describe("TimeGridView", () => {
     expect(plain.style.background).toContain("#336699 18%");
     expect(within(plain).getByText("Plain").style.color).toBe("");
   });
+
+  // The event being made (#884, C10c): dashed, in its calendar's colour, and never greyed as past
+  // (one opacity utility only: `cn` doesn't resolve two).
+  it("draws the new event's ghost dashed in its calendar's colour, timed or all day", () => {
+    // Both days are over by `now`, so a synced event greys and the ghost doesn't.
+    const draw = (events: CalendarEvent[]) =>
+      render(
+        <TimeGridView
+          days={[new Date(2026, 9, 12), new Date(2026, 9, 13)]}
+          events={events}
+          colorOf={(id) => (id === "work" ? "#336699" : "#993366")}
+          range="day"
+          bounds={{ startHour: 0, endHour: 24 }}
+          zones={[]}
+          onZonesChange={() => {}}
+          allowZones={false}
+          now={new Date(2026, 9, 20)}
+          onEventClick={vi.fn()}
+        />,
+      );
+    draw([
+      ev({ id: DRAFT_EVENT_ID, calendar_id: "work", summary: "Dentist", end: null }),
+      ev({ id: "e2", summary: "Synced", start: "2026-10-12T09:00:00", end: null }),
+    ]);
+    // Named as the new event, not yet saved, so it isn't heard as one that's in the calendar.
+    const ghost = screen.getByRole("button", { name: /^New event, not saved yet: Dentist, / });
+    // Dashed inside its edge, where nothing around it can clip the dash away.
+    expect(ghost.className).toContain("outline-dashed");
+    expect(ghost.className).toContain("-outline-offset-1");
+    expect(ghost.className).not.toContain("opacity-60");
+    expect(ghost.hasAttribute("data-draft-event")).toBe(true);
+    expect(ghost.style.borderLeftColor).toBe("rgb(51, 102, 153)");
+    // A synced event beside it is drawn and named as ever.
+    const synced = screen.getByRole("button", { name: /^Synced, / });
+    expect(synced.className).not.toContain("outline-dashed");
+    expect(synced.className).toContain("opacity-60");
+    expect(synced.hasAttribute("data-draft-event")).toBe(false);
+    cleanup();
+    // Once a save may have made it, never "not saved".
+    draw([
+      {
+        ...ev({
+          id: DRAFT_EVENT_ID,
+          calendar_id: "work",
+          summary: "Away",
+          start: "2026-10-13",
+          end: "2026-10-14",
+          all_day: true,
+        }),
+        draft_state: "unsure",
+      } as CalendarEvent,
+    ]);
+    const band = screen.getByRole("button", {
+      name: "New event, PM may already have made it: Away",
+    });
+    expect(band.className).toContain("outline-dashed");
+    expect(band.className).toContain("-outline-offset-1");
+    expect(band.className).not.toContain("opacity-60");
+    expect(band.hasAttribute("data-draft-event")).toBe(true);
+  });
 });
 
 // A sideways swipe moves the window a day at a time, and every step used to snap the hours back to
diff --git a/src/components/calendar/views/TimeGridView.tsx b/src/components/calendar/views/TimeGridView.tsx
index 10519d89..d086e57b 100644
--- a/src/components/calendar/views/TimeGridView.tsx
+++ b/src/components/calendar/views/TimeGridView.tsx
@@ -19,6 +19,7 @@ import {
   assignColumns,
   dayKey,
   eventDaySpan,
+  draftNote,
   inTimeGridBand,
   isEventPast,
   minutesFromLocalMidnight,
@@ -452,6 +453,7 @@ export function TimeGridView({
                   showTime={!minimal}
                   showLocation={showPower}
                   isPast={isEventPast(card.ev, nowDate)}
+                  ghost={draftNote(card.ev)}
                   continuesBefore={card.continuesBefore}
                   continuesAfter={card.continuesAfter}
                   tabStop={card.tabStop}
diff --git a/src/components/ui/Popover.test.tsx b/src/components/ui/Popover.test.tsx
index 06c380eb..94af2fd7 100644
--- a/src/components/ui/Popover.test.tsx
+++ b/src/components/ui/Popover.test.tsx
@@ -15,9 +15,11 @@
 // generated stylesheet's ordering decide the winner. "Exactly one z-utility" is the property that
 // has to hold, and only a class-level assertion can state it.
 
+import { useRef } from "react";
 import { cleanup, fireEvent, render, screen } from "@testing-library/react";
 import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 
+import { useDialogLayer } from "../../lib/useDialogLayer";
 import { Modal } from "./Modal";
 import { Popover } from "./Popover";
 
@@ -165,6 +167,76 @@ describe("Popover stacking", () => {
     }
   });
 
+  // A non-modal layer (the calendar's quick create) registers as a dialog without taking focus, so a
+  // popover opened beside it is still the one in use: Escape closes it wherever it's pressed, except
+  // in the layer itself. A modal dialog over it holds the keyboard, and the key is the dialog's.
+  function besideLayer(modal: boolean) {
+    function Layer() {
+      const ref = useRef<HTMLDivElement>(null);
+      useDialogLayer(true, ref);
+      return (
+        <div ref={ref} role="dialog" aria-label="Quick create" aria-modal={modal || undefined}>
+          <input aria-label="Title" />
+        </div>
+      );
+    }
+    render(
+      <>
+        <Layer />
+        <Popover
+          ariaLabel="Mini calendar"
+          trigger={({ toggle }) => (
+            <button type="button" onClick={toggle}>
+              Open
+            </button>
+          )}
+        >
+          <button type="button">A day</button>
+        </Popover>
+      </>,
+    );
+    const isOpen = () => screen.queryByRole("group", { name: "Mini calendar" }) !== null;
+    const reopen = () => {
+      if (!isOpen()) fireEvent.click(screen.getByText("Open"));
+    };
+    return { isOpen, reopen };
+  }
+
+  it("closes on Escape on its panel, its trigger or the page, beside a non-modal layer", () => {
+    const { isOpen, reopen } = besideLayer(false);
+    reopen();
+    // Pressed in the layer, the key is the layer's: the popover stays open.
+    fireEvent.keyDown(screen.getByLabelText("Title"), { key: "Escape" });
+    expect(isOpen()).toBe(true);
+    fireEvent.keyDown(screen.getByText("A day"), { key: "Escape" });
+    expect(isOpen()).toBe(false);
+    // Focus left on the trigger by the click that opened it (WebKitGTK, WebView2).
+    reopen();
+    fireEvent.keyDown(screen.getByText("Open"), { key: "Escape" });
+    expect(isOpen()).toBe(false);
+    // Focus on the page (macOS WebKit doesn't focus a clicked button).
+    reopen();
+    fireEvent.keyDown(document.body, { key: "Escape" });
+    expect(isOpen()).toBe(false);
+  });
+
+  it("leaves Escape to a modal dialog over it, wherever it's pressed", () => {
+    const { isOpen, reopen } = besideLayer(true);
+    reopen();
+    fireEvent.keyDown(screen.getByText("Open"), { key: "Escape" });
+    fireEvent.keyDown(document.body, { key: "Escape" });
+    expect(isOpen()).toBe(true);
+  });
+
+  // A surface with its own outside-click rule tells a click in a picker it opened (portalled out of
+  // its box) from a click outside by this attribute.
+  it("marks its panel, portalled or not, as a popover panel", () => {
+    for (const escapeClipping of [true, false]) {
+      expect(open(escapeClipping).hasAttribute("data-popover-panel")).toBe(true);
+      cleanup();
+    }
+  });
+
   it("never emits two z-index utilities", () => {
     // `cn` does not de-conflict. Two z-classes on one element is a silent, stylesheet-ordering-
     // dependent bug, so pin the count directly for both modes.
diff --git a/src/components/ui/Popover.tsx b/src/components/ui/Popover.tsx
index c39309bd..9db3efdc 100644
--- a/src/components/ui/Popover.tsx
+++ b/src/components/ui/Popover.tsx
@@ -10,7 +10,7 @@ import { useCallback, useEffect, useLayoutEffect, useRef, useState, type ReactNo
 import { createPortal } from "react-dom";
 import { cn } from "./cn";
 import { useRestoreFocus } from "../../lib/useRestoreFocus";
-import { isCoveredByDialog } from "../../lib/useDialogLayer";
+import { isKeyForDialogOver } from "../../lib/useDialogLayer";
 
 /** Breathing room kept between a clipping-escaped panel and the window edge. */
 const MARGIN = 8;
@@ -170,7 +170,10 @@ export function Popover({
     const onKey = (e: KeyboardEvent) => {
       if (e.key !== "Escape") return;
       // A dialog opened OVER this popover owns the key: leave it alone (and stay open underneath).
-      if (isCoveredByDialog(rootRef.current)) return;
+      // A non-modal layer (the calendar's quick create) owns only a key pressed inside it: it takes
+      // no focus away, so a popover opened beside it, focus on its trigger, its panel or the page, is
+      // still the one in use.
+      if (isKeyForDialogOver(rootRef.current, e.target)) return;
       // This listens on `document` and a dialog's Escape on `window`, so the key reaches here first.
       // Stop it: one Escape closes the innermost thing open (the picker), not the dialog around it.
       e.stopPropagation();
@@ -189,6 +192,9 @@ export function Popover({
       ref={panelRef}
       role="group"
       aria-label={ariaLabel}
+      // Marks every popover panel, portalled or not, so a surface with its own outside-click rule
+      // (the calendar's quick create) can tell a click in a picker it opened from one outside it.
+      data-popover-panel=""
       className={cn(
         "min-w-[15rem] rounded-[var(--radius-sm)] border border-border2 bg-panel p-1 shadow-lg",
         // The z-index is part of the same conditional as `fixed`/`absolute`, NOT a constant above
diff --git a/src/components/ui/TitleBar.test.tsx b/src/components/ui/TitleBar.test.tsx
new file mode 100644
index 00000000..76fdde26
--- /dev/null
+++ b/src/components/ui/TitleBar.test.tsx
@@ -0,0 +1,123 @@
+// SPDX-FileCopyrightText: 2026 Bobby Yu
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+// @vitest-environment jsdom
+//
+// Escape leaves fullscreen, so a frameless fullscreen never traps the user, and stands down only for
+// a dialog that owns the key: a modal one, one it was pressed inside, or an event's details (which
+// close on Escape pressed anywhere). The calendar's quick create owns only a key pressed inside it
+// and stays open while a title is typed, so beside it Escape still leaves fullscreen.
+
+import { useRef } from "react";
+import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useDialogLayer } from "../../lib/useDialogLayer";
+import { Modal } from "./Modal";
+
+const setFullscreen = vi.fn(() => Promise.resolve());
+
+vi.mock("@tauri-apps/api/window", () => ({
+  getCurrentWindow: () => ({
+    isMaximized: () => Promise.resolve(false),
+    isFullscreen: () => Promise.resolve(true),
+    setFullscreen,
+    onResized: () => Promise.resolve(() => {}),
+  }),
+}));
+
+vi.mock("@tauri-apps/api/app", () => ({
+  getVersion: () => Promise.resolve("3.151.0-alpha"),
+}));
+
+vi.mock("./useEdgeResizeCursor", () => ({
+  useEdgeResizeCursor: () => {},
+}));
+
+vi.mock("../../theme/ThemeContext", async (importOriginal) => ({
+  ...(await importOriginal<object>()),
+  useTheme: () => ({ system: "slate", depth: "standard" }),
+}));
+
+import { TitleBar } from "./TitleBar";
+
+afterEach(() => {
+  cleanup();
+  setFullscreen.mockClear();
+});
+
+/** Quick create's shape: a dialog layer that leaves the page live (no `aria-modal`). */
+function QuickCreate() {
+  const ref = useRef<HTMLDivElement>(null);
+  useDialogLayer(true, ref);
+  return (
+    <div ref={ref} role="dialog" aria-label="New event">
+      <input aria-label="Title" />
+    </div>
+  );
+}
+
+/** Press Escape on `target`, and let the window's fullscreen be read. */
+async function escape(target: Element) {
+  fireEvent.keyDown(target, { key: "Escape" });
+  await act(async () => {});
+}
+
+describe("TitleBar's Escape", () => {
+  it("leaves fullscreen with no dialog open", async () => {
+    render(<TitleBar />);
+    await escape(document.body);
+    expect(setFullscreen.mock.calls).toEqual([[false]]);
+  });
+
+  it("leaves fullscreen beside quick create, with focus on the page", async () => {
+    render(
+      <>
+        <TitleBar />
+        <QuickCreate />
+        <button type="button">A day</button>
+      </>,
+    );
+    await escape(screen.getByRole("button", { name: "A day" }));
+    expect(setFullscreen.mock.calls).toEqual([[false]]);
+  });
+
+  it("stands down for a key pressed inside quick create", async () => {
+    render(
+      <>
+        <TitleBar />
+        <QuickCreate />
+      </>,
+    );
+    await escape(screen.getByLabelText("Title"));
+    expect(setFullscreen).not.toHaveBeenCalled();
+  });
+
+  it("stands down for a modal dialog, wherever the key is pressed", async () => {
+    render(
+      <>
+        <TitleBar />
+        <button type="button">A day</button>
+        <Modal open onClose={() => {}} label="Settings">
+          <button type="button">Save</button>
+        </Modal>
+      </>,
+    );
+    await escape(screen.getByRole("button", { name: "A day" }));
+    await escape(screen.getByRole("button", { name: "Save" }));
+    expect(setFullscreen).not.toHaveBeenCalled();
+  });
+
+  // An event's details aren't a dialog layer, and close on Escape pressed anywhere: the one key does
+  // one thing.
+  it("stands down for an event's details, wherever the key is pressed", async () => {
+    render(
+      <>
+        <TitleBar />
+        <button type="button">A day</button>
+        <div role="dialog" aria-label="Dentist" />
+      </>,
+    );
+    await escape(screen.getByRole("button", { name: "A day" }));
+    expect(setFullscreen).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/components/ui/TitleBar.tsx b/src/components/ui/TitleBar.tsx
index e689ca7c..a070c0eb 100644
--- a/src/components/ui/TitleBar.tsx
+++ b/src/components/ui/TitleBar.tsx
@@ -18,6 +18,7 @@ import { getCurrentWindow } from "@tauri-apps/api/window";
 import { getVersion } from "@tauri-apps/api/app";
 import { useTheme } from "../../theme";
 import { subscribeUntilCleanup } from "../../lib/subscribe";
+import { isKeyForADialog } from "../../lib/useDialogLayer";
 import { cn } from "./cn";
 import { useEdgeResizeCursor } from "./useEdgeResizeCursor";
 
@@ -163,8 +164,10 @@ export function TitleBar() {
       if (e.repeat) return; // holding a key shouldn't interleave async fullscreen toggles
       // Let an open dialog own Escape — Modal has its own window listener, so don't also
       // exit fullscreen on the same keystroke (or yank the user out from under a busy
-      // ConfirmDialog they can't dismiss).
-      if (e.key === "Escape" && document.querySelector('[role="dialog"]')) return;
+      // ConfirmDialog they can't dismiss). The calendar's quick create owns only a key
+      // pressed inside it, and stays open while a title is typed: beside it, Esc still
+      // leaves fullscreen.
+      if (e.key === "Escape" && isKeyForADialog(e.target)) return;
       if (e.key === "F11") {
         e.preventDefault();
         getCurrentWindow()
diff --git a/src/lib/calendar-layout.test.ts b/src/lib/calendar-layout.test.ts
index 7fc452d3..204d286b 100644
--- a/src/lib/calendar-layout.test.ts
+++ b/src/lib/calendar-layout.test.ts
@@ -5,17 +5,26 @@ import { describe, it, expect } from "vitest";
 import {
   dayDiff,
   dayKey,
+  DRAFT_EVENT_ID,
+  draftEvent,
+  draftNote,
+  eventDaySpan,
+  ghostAfterRead,
   inTimeGridBand,
+  isDraftEvent,
   isEventPast,
   isMultiDay,
   minutesFromLocalMidnight,
   occurrenceKey,
+  packBands,
+  spokenName,
   startOfDay,
   startOfWeek,
   timedEndMinutes,
   timedSegments,
 } from "./calendar-layout";
 import type { CalendarEvent } from "./types";
+import type { EditorFields } from "./calendarEdit/eventDraft";
 
 // Local Date constructors (new Date(y, m0, d, h, min)) read the local clock, so these are TZ-agnostic.
 
@@ -192,3 +201,164 @@ describe("isEventPast", () => {
     expect(isEventPast(ev, new Date(2026, 9, 14, 0, 1))).toBe(true);
   });
 });
+
+describe("the new event's ghost (C10c)", () => {
+  const fields: EditorFields = {
+    summary: "Dentist",
+    location: "",
+    description: "",
+    time: {
+      kind: "timed",
+      start_date: "2026-10-12",
+      start_time: "09:00",
+      start_zone: "Europe/London",
+      end_date: "2026-10-12",
+      end_time: "10:30",
+      end_zone: "America/New_York",
+    },
+    show_as: "busy",
+    visibility: "default",
+  };
+  const timed = fields.time as Extract<EditorFields["time"], { kind: "timed" }>;
+
+  it("draftEvent builds a timed and an all-day ghost in mirror shapes", () => {
+    // Each end in its own zone, as a UTC instant with no milliseconds, as the mirror writes it.
+    expect(draftEvent(fields, "cal-1")).toEqual({
+      id: DRAFT_EVENT_ID,
+      calendar_id: "cal-1",
+      summary: "Dentist",
+      description: null,
+      location: null,
+      start: "2026-10-12T08:00:00Z",
+      end: "2026-10-12T14:30:00Z",
+      all_day: false,
+      html_link: null,
+      uid: null,
+      draft_state: "unsaved",
+    });
+    // All day: civil dates, the end exclusive, across a month's end; "(no title)" as the grid says.
+    const allDay = draftEvent(
+      {
+        ...fields,
+        summary: "  ",
+        time: { kind: "all_day", first_day: "2026-10-30", last_day: "2026-10-31" },
+      },
+      "cal-2",
+    );
+    expect(allDay).toMatchObject({
+      summary: "(no title)",
+      start: "2026-10-30",
+      end: "2026-11-01",
+      all_day: true,
+      calendar_id: "cal-2",
+    });
+    expect(eventDaySpan(allDay!)).toEqual({
+      startDay: new Date(2026, 9, 30),
+      endDay: new Date(2026, 9, 31),
+    });
+  });
+
+  it("draftEvent draws nothing for a time that doesn't resolve", () => {
+    // A time the clocks skip (London, 29-03-2026), an end not after the start, an unknown zone,
+    // and a last day before the first.
+    const at = (over: Partial<typeof timed>) => ({ ...fields, time: { ...timed, ...over } });
+    expect(draftEvent(at({ start_date: "2026-03-29", start_time: "01:30" }), "c")).toBeNull();
+    expect(draftEvent(at({ end_time: "04:00" }), "c")).toBeNull();
+    expect(draftEvent(at({ start_zone: "Nowhere/Here" }), "c")).toBeNull();
+    const backwards = { kind: "all_day" as const, first_day: "2026-10-14", last_day: "2026-10-12" };
+    expect(draftEvent({ ...fields, time: backwards }, "c")).toBeNull();
+  });
+
+  it("isDraftEvent finds only the ghost", () => {
+    const ghost = draftEvent(fields, "cal-1")!;
+    expect(isDraftEvent(ghost)).toBe(true);
+    expect(isDraftEvent(timedEv("2026-10-12T09:00:00Z", "2026-10-12T10:00:00Z"))).toBe(false);
+    expect(isDraftEvent({ ...ghost, id: "cal-1:draft:new" })).toBe(false);
+  });
+
+  // The dashed edge says "new" to the eye; the name says it to a screen reader, and how far the save
+  // got. Once anything was sent, never "not saved": PM may already have made it.
+  it("draftNote names the ghost, by how far it has got, and nothing else", () => {
+    const at = (state: Parameters<typeof draftEvent>[2]) =>
+      draftNote(draftEvent(fields, "c", state)!);
+    expect(at("unsaved")).toBe("New event, not saved yet");
+    expect(at("saving")).toBe("New event, saving");
+    expect(at("unsure")).toBe("New event, PM may already have made it");
+    expect(at("saved")).toBe("New event, saved");
+    // A row carrying the ghost's id but no state (as the views' tests draw one) is a draft.
+    expect(draftNote(timedEv("2026-10-12T09:00:00Z", "2026-10-12T10:00:00Z"))).toBeNull();
+    expect(draftNote({ ...timedEv("2026-10-12T09:00:00Z", null), id: DRAFT_EVENT_ID })).toBe(
+      "New event, not saved yet",
+    );
+    expect(spokenName("New event, saving", "Dentist, 09:00")).toBe(
+      "New event, saving: Dentist, 09:00",
+    );
+    expect(spokenName(null, "Dentist, 09:00")).toBe("Dentist, 09:00");
+  });
+
+  // A saved quick create's ghost waits for its row: a read begun after the save brings it, and the
+  // ghost goes; one begun before may not have it, and the ghost stays.
+  it("ghostAfterRead keeps the ghost until a read that started after the save lands", () => {
+    const landed = { ev: draftEvent(fields, "c", "saved")!, after: 4 };
+    expect(ghostAfterRead(landed, 4)).toBe(landed);
+    expect(ghostAfterRead(landed, 3)).toBe(landed);
+    expect(ghostAfterRead(landed, 5)).toBeNull();
+    expect(ghostAfterRead(null, 9)).toBeNull();
+  });
+});
+
+describe("packBands", () => {
+  it("packs by start, longest first, each in the lowest lane free", () => {
+    const { bands, laneCount } = packBands([
+      { id: "late", startDay: 3, endDay: 4 },
+      { id: "long", startDay: 0, endDay: 5 },
+      { id: "short", startDay: 0, endDay: 1 },
+      { id: "after", startDay: 2, endDay: 2 },
+    ]);
+    const lane = new Map(bands.map((b) => [b.id, b.lane]));
+    expect([lane.get("long"), lane.get("short"), lane.get("after"), lane.get("late")]).toEqual([
+      0, 1, 1, 1,
+    ]);
+    expect(laneCount).toBe(2);
+  });
+
+  // `first` (Month's ghost) is placed before the rest: the top lane, wherever it starts, and nothing
+  // packed after it overlaps it. It holds that lane over its own days only.
+  it("places `first` in the top lane, the rest around it", () => {
+    const { bands, laneCount } = packBands(
+      [
+        { id: "a", startDay: 0, endDay: 6 },
+        { id: "b", startDay: 0, endDay: 1 },
+        { id: "ghost", startDay: 3, endDay: 4 },
+        { id: "d", startDay: 2, endDay: 3 },
+        { id: "c", startDay: 5, endDay: 6 },
+      ],
+      "ghost",
+    );
+    const lane = new Map(bands.map((b) => [b.id, b.lane]));
+    expect(lane.get("ghost")).toBe(0);
+    expect(lane.get("a")).toBe(1);
+    // "b" ends before the ghost starts: it keeps the top lane it has without one.
+    expect(lane.get("b")).toBe(0);
+    // "d" starts after "b" ends but runs into the ghost's days: not the top lane.
+    expect(lane.get("d")).toBe(2);
+    // "c" starts after the ghost ends: the top lane is free again.
+    expect(lane.get("c")).toBe(0);
+    expect(laneCount).toBe(3);
+  });
+
+  // A ghost months on leaves the bands that end before it in the lanes they have without it.
+  it("leaves bands clear of `first` in the lanes they have without it", () => {
+    const spans = [
+      { id: "a", startDay: 0, endDay: 2 },
+      { id: "b", startDay: 0, endDay: 2 },
+      { id: "c", startDay: 1, endDay: 2 },
+    ];
+    const without = packBands(spans);
+    const withGhost = packBands([...spans, { id: "ghost", startDay: 30, endDay: 31 }], "ghost");
+    const lanes = (r: ReturnType<typeof packBands>) =>
+      r.bands.filter((b) => b.id !== "ghost").map((b) => [b.id, b.lane]);
+    expect(lanes(withGhost)).toEqual(lanes(without));
+    expect(withGhost.laneCount).toBe(without.laneCount);
+  });
+});
diff --git a/src/lib/calendar-layout.ts b/src/lib/calendar-layout.ts
index 22a2b16d..b32a109c 100644
--- a/src/lib/calendar-layout.ts
+++ b/src/lib/calendar-layout.ts
@@ -8,6 +8,8 @@
 
 import { pad2 } from "./format";
 import type { CalendarEvent } from "./types";
+import type { EditorFields } from "./calendarEdit/eventDraft";
+import { wallInstant } from "./wallTime";
 
 // --- milestone overlay -----------------------------------------------------------------------------
 
@@ -36,6 +38,105 @@ export function isOverlayEvent(ev: CalendarEvent): boolean {
   return isMilestoneEvent(ev) || isPinboardEvent(ev);
 }
 
+// --- the new event's ghost (#884, C10c) ---------------------------------------------------------------
+
+/** The id of the event being created, drawn on the grid until it's saved or discarded. */
+export const DRAFT_EVENT_ID = "draft:new";
+
+/** True for the ghost of the event being created (vs anything synced or overlaid). */
+export function isDraftEvent(ev: CalendarEvent): boolean {
+  return ev.id === DRAFT_EVENT_ID;
+}
+
+/** A draft's look: a dashed edge, not quite solid. Tokens only. The dash is drawn inside the edge,
+ *  so a list that clips its children (a Month cell's chips) can't cut it away. The views leave the
+ *  past-event greying off a ghost, so only one opacity utility is ever on it. */
+export const DRAFT_EVENT_CLASS =
+  "opacity-80 outline-dashed outline-1 -outline-offset-1 outline-ink3";
+
+/** How far the new event has got: not sent, a save out, sent with no proof how it ended (an answer
+ *  that never arrived, or a retry token that ended unproven), or made and waiting for its row. */
+export type DraftState = "unsaved" | "saving" | "unsure" | "saved";
+
+/** The ghost row: a mirror-shaped event, and how far it has got. */
+export interface DraftEvent extends CalendarEvent {
+  draft_state: DraftState;
+}
+
+/** What a screen reader hears before a ghost's name. Never "not saved" once anything was sent: an
+ *  event PM may already have made is never described as not made. */
+const DRAFT_WORDS: Record<DraftState, string> = {
+  unsaved: "New event, not saved yet",
+  saving: "New event, saving",
+  unsure: "New event, PM may already have made it",
+  saved: "New event, saved",
+};
+
+/** The words that say an event is the new one and how far it has got, for the start of its
+ *  accessible name (the dashed edge says it to the eye); null for any other event. */
+export function draftNote(ev: CalendarEvent): string | null {
+  if (!isDraftEvent(ev)) return null;
+  return DRAFT_WORDS[(ev as Partial<DraftEvent>).draft_state ?? "unsaved"];
+}
+
+/** An event's accessible name, `note` (`draftNote`) first when it's the ghost. */
+export function spokenName(note: string | null, name: string): string {
+  return note ? `${note}: ${name}` : name;
+}
+
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+/** The ghost row for `draft` on `calendarId`, in the mirror's own shapes: a UTC `…Z` instant for a
+ *  timed event, or `YYYY-MM-DD` with an exclusive end for an all-day one. Its uid is null, so it's
+ *  never deduped against a synced copy. Null when the draft's times don't resolve (a skipped hour, an
+ *  unreadable value, an end not after the start): then no ghost shows, and the live lines say why. */
+export function draftEvent(
+  draft: EditorFields,
+  calendarId: string,
+  state: DraftState = "unsaved",
+): DraftEvent | null {
+  const t = draft.time;
+  const ghost = {
+    id: DRAFT_EVENT_ID,
+    calendar_id: calendarId,
+    summary: draft.summary.trim() || "(no title)",
+    description: null,
+    location: draft.location.trim() || null,
+    html_link: null,
+    uid: null,
+    draft_state: state,
+  };
+  if (t.kind === "all_day") {
+    if (!ISO_DAY.test(t.first_day) || !ISO_DAY.test(t.last_day) || t.last_day < t.first_day) {
+      return null;
+    }
+    const [y, m, d] = t.last_day.split("-").map(Number);
+    const end = dayKey(new Date(y, m - 1, d + 1));
+    return { ...ghost, start: t.first_day, end, all_day: true };
+  }
+  // As a save reads them: the first of a repeated hour, and nothing for a skipped one.
+  const start = wallInstant(t.start_date, t.start_time, t.start_zone);
+  const end = wallInstant(t.end_date, t.end_time, t.end_zone);
+  if (!start || !end || end.getTime() <= start.getTime()) return null;
+  // Whole minutes, so no milliseconds: the mirror writes `…:00Z`.
+  const iso = (d: Date) => `${d.toISOString().slice(0, 19)}Z`;
+  return { ...ghost, start: iso(start), end: iso(end), all_day: false };
+}
+
+/** A saved quick create's ghost, kept so the event doesn't blink out between the box closing and
+ *  its row arriving: `after` is how many reads of the mirror had started at the save. */
+export interface LandedGhost {
+  ev: DraftEvent;
+  after: number;
+}
+
+/** A saved event's ghost once a read of the mirror lands, `started` being how many reads had started
+ *  by then (only the newest applies, so it's that one): a read begun after the save brings the row,
+ *  and the ghost goes; an older one may not have it yet, and the ghost stays. */
+export function ghostAfterRead(landed: LandedGhost | null, started: number): LandedGhost | null {
+  return landed && started > landed.after ? null : landed;
+}
+
 // --- occurrence identity ---------------------------------------------------------------------------
 
 /** The dedup key for ONE occurrence: the iCal UID *and* the instant. `null` when the event carries no
@@ -366,15 +467,30 @@ export interface BandPlacement extends BandInput {
 
 /** Greedy lane-pack multi-day/all-day spans into stacked rows: sort by start then longest-first
  *  (longer bands take lower lanes for stable stacking), and place each in the lowest lane free before
- *  it starts. Pure. */
-export function packBands(spans: BandInput[]): { bands: BandPlacement[]; laneCount: number } {
-  const sorted = [...spans].sort(
-    (a, b) => a.startDay - b.startDay || b.endDay - b.startDay - (a.endDay - a.startDay),
-  );
-  const laneLastDay: number[] = [];
-  const bands: BandPlacement[] = [];
+ *  it starts. `first` (the new event's ghost, in Month, where lanes past the cap fold into "+N more")
+ *  is placed before the rest, so it takes the top lane and never folds away as it's typed. It holds
+ *  that lane over its own days only, so a band clear of them may still take it. A band that reaches
+ *  its days is kept out of the top lane for its whole run, which can move the bands packed after it
+ *  too, so Month uses this packing only in the weeks the ghost touches and the packing without it
+ *  in every other (buildWeekRows). Pure. */
+export function packBands(
+  spans: BandInput[],
+  first?: string,
+): { bands: BandPlacement[]; laneCount: number } {
+  const ghost = first === undefined ? undefined : spans.find((s) => s.id === first);
+  const sorted = spans
+    .filter((s) => s !== ghost)
+    .sort((a, b) => a.startDay - b.startDay || b.endDay - b.startDay - (a.endDay - a.startDay));
+  const clearOfGhost = (s: BandInput) =>
+    !ghost || s.endDay < ghost.startDay || s.startDay > ghost.endDay;
+  // The ghost's lane tracks the bands put in it like any other; `clearOfGhost` keeps them off the
+  // ghost's own days.
+  const laneLastDay: number[] = ghost ? [-Infinity] : [];
+  const bands: BandPlacement[] = ghost
+    ? [{ id: ghost.id, startDay: ghost.startDay, endDay: ghost.endDay, lane: 0 }]
+    : [];
   for (const s of sorted) {
-    let lane = laneLastDay.findIndex((last) => last < s.startDay);
+    let lane = laneLastDay.findIndex((last, i) => last < s.startDay && (i > 0 || clearOfGhost(s)));
     if (lane === -1) {
       lane = laneLastDay.length;
       laneLastDay.push(s.endDay);
diff --git a/src/lib/calendarEdit/createTargets.test.ts b/src/lib/calendarEdit/createTargets.test.ts
index 045b9ef7..bcbcf681 100644
--- a/src/lib/calendarEdit/createTargets.test.ts
+++ b/src/lib/calendarEdit/createTargets.test.ts
@@ -7,8 +7,10 @@
 
 import { describe, expect, it } from "vitest";
 import type { Calendar, CalendarAccount, CalendarOverview } from "../types";
+import { formatDateLocal } from "../format";
 import {
   createdWhere,
+  createNotes,
   createReasonFor,
   createTargets,
   defaultTarget,
@@ -263,3 +265,26 @@ describe("createdWhere", () => {
     expect(createdWhere(overview(), new Set(), "gone").hidden).toBe(true);
   });
 });
+
+describe("createNotes", () => {
+  // Both surfaces (the full editor and quick create) say these, so they're worded once.
+  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([]);
+    // 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([
+      `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([
+      "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`),
+    ).toEqual([]);
+  });
+});
diff --git a/src/lib/calendarEdit/createTargets.ts b/src/lib/calendarEdit/createTargets.ts
index 3ab56ffe..6604adc2 100644
--- a/src/lib/calendarEdit/createTargets.ts
+++ b/src/lib/calendarEdit/createTargets.ts
@@ -14,6 +14,7 @@ import type {
   EditingStatus,
   TimeDraft,
 } from "../types";
+import { formatDateLocal } from "../format";
 import { wallInstant } from "../wallTime";
 import { DEFAULT_LENGTH_MS } from "./eventDraft";
 import type { CreatedWhere } from "./editReasons";
@@ -160,3 +161,29 @@ export function createdWhere(
   );
   return { name: cal.name, hidden: !cal.selected || (hidden.has(cal.id) && !twinShows) };
 }
+
+/** 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. */
+export function createNotes(
+  time: TimeDraft,
+  overview: CalendarOverview,
+  hidden: ReadonlySet<string>,
+  calendarId: string,
+): string[] {
+  const notes: string[] = [];
+  if (outsideMirror(time, overview)) {
+    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.`,
+    );
+  }
+  const where = createdWhere(overview, hidden, calendarId);
+  if (hidden.has(calendarId) && where.hidden) {
+    notes.push(
+      `${where.name} is hidden in your calendar list, so the new event won't show until you show that calendar again.`,
+    );
+  }
+  return notes;
+}
diff --git a/src/lib/changelog.ts b/src/lib/changelog.ts
index c7636331..dcc030d4 100644
--- a/src/lib/changelog.ts
+++ b/src/lib/changelog.ts
@@ -23,6 +23,15 @@ export interface ChangelogEntry {
 }
 
 export const CHANGELOG: ChangelogEntry[] = [
+  {
+    version: "3.151.0-alpha",
+    date: "2026-10-20",
+    highlights: [
+      "Quick create: press Shift+C on the calendar for a small box under + New event. Type a title and press Enter, and it's in your Google calendar; change the day or the time there, or choose the calendar. More options opens the full editor with everything you've typed, so nothing is lost on the way.",
+      "In the day, week, month and agenda views the new event shows as you type, dashed, in its calendar's colour, and moves as you change the time; a screen reader names it as the new event. The Year view and the Terminal look show only what's in your calendar.",
+      "Clicking elsewhere on the calendar only closes the box while it has no title, and a titled one is still there if you switch tabs and come back, so a half-made event isn't lost by accident; × throws it away.",
+    ],
+  },
   {
     version: "3.150.0-alpha",
     date: "2026-10-20",
diff --git a/src/lib/help.ts b/src/lib/help.ts
index 54904a24..03963ac4 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 c) 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. 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. 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. 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. 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",
diff --git a/src/lib/useDialogLayer.ts b/src/lib/useDialogLayer.ts
index 103ebd94..2e5e3910 100644
--- a/src/lib/useDialogLayer.ts
+++ b/src/lib/useDialogLayer.ts
@@ -38,15 +38,35 @@ export function isAnyDialogOpen(): boolean {
 }
 
 /**
- * Whether a dialog is open that `el` is NOT inside — i.e. `el` sits behind it. A popover or menu that
- * claims Escape for itself asks this first: when a dialog was opened over it (the command palette over
- * an open Panels menu, say), the key belongs to that dialog, not to the hidden popover underneath.
- * Read at event time.
+ * Whether a key pressed on `target` belongs to a dialog open over `el` rather than to `el` itself. A
+ * popover or menu that claims Escape for itself asks this first. A modal dialog `el` isn't inside
+ * (the command palette over an open Panels menu, say) owns the key always, as it holds the keyboard;
+ * a non-modal one (the calendar's quick create, which leaves the page live) only when it was pressed
+ * inside it. Pressed on a popover's trigger, in its panel or on the page beside such a layer, the key
+ * is the popover's. Read at event time.
  */
-export function isCoveredByDialog(el: Element | null): boolean {
+export function isKeyForDialogOver(el: Element | null, target: EventTarget | null): boolean {
   if (!el) return false;
   for (const dialog of openDialogs) {
-    if (!dialog.contains(el)) return true;
+    if (dialog.contains(el)) continue;
+    if (dialog.getAttribute("aria-modal") === "true") return true;
+    if (target instanceof Node && dialog.contains(target)) return true;
+  }
+  return false;
+}
+
+/**
+ * Whether a key pressed on `target` is some open dialog's, for a page-wide use of it (Escape leaving
+ * fullscreen) that must stand down for one: a modal dialog's always; any dialog's it was pressed
+ * inside; and a non-modal dialog's that isn't a layer here (an event's details, which closes on
+ * Escape pressed anywhere). A non-modal layer (quick create) takes only a key pressed inside it, so
+ * with focus on the page beside it the key is the page's. Read at event time.
+ */
+export function isKeyForADialog(target: EventTarget | null): boolean {
+  for (const dialog of document.querySelectorAll<HTMLElement>('[role="dialog"]')) {
+    if (dialog.getAttribute("aria-modal") === "true") return true;
+    if (target instanceof Node && dialog.contains(target)) return true;
+    if (!openDialogs.has(dialog)) return true;
   }
   return false;
 }