diff --git a/Cargo.lock b/Cargo.lock
index 83b01455..7cd24eef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2077,6 +2077,7 @@ dependencies = [
  "locality-connector",
  "locality-core",
  "locality-gmail",
+ "locality-google-calendar",
  "locality-google-docs",
  "locality-granola",
  "locality-linear",
@@ -2133,6 +2134,7 @@ dependencies = [
  "locality-connector",
  "locality-core",
  "locality-gmail",
+ "locality-google-calendar",
  "locality-google-docs",
  "locality-notion",
  "locality-platform",
@@ -2180,6 +2182,20 @@ dependencies = [
  "yaml_serde",
 ]
 
+[[package]]
+name = "locality-google-calendar"
+version = "0.3.2"
+dependencies = [
+ "chrono",
+ "locality-connector",
+ "locality-core",
+ "reqwest",
+ "rustls",
+ "serde",
+ "serde_json",
+ "yaml_serde",
+]
+
 [[package]]
 name = "locality-google-docs"
 version = "0.3.4"
@@ -2266,6 +2282,7 @@ dependencies = [
  "locality-connector",
  "locality-core",
  "locality-gmail",
+ "locality-google-calendar",
  "locality-google-docs",
  "locality-granola",
  "locality-linear",
diff --git a/Cargo.toml b/Cargo.toml
index 5f1e6c24..8c956134 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ members = [
   "crates/locality-store",
   "crates/locality-notion",
   "crates/locality-google-docs",
+  "crates/locality-google-calendar",
   "crates/locality-gmail",
   "crates/locality-granola",
   "crates/locality-linear",
@@ -30,6 +31,7 @@ locality-platform = { path = "crates/locality-platform" }
 locality-store = { path = "crates/locality-store" }
 locality-notion = { path = "crates/locality-notion" }
 locality-google-docs = { path = "crates/locality-google-docs" }
+locality-google-calendar = { path = "crates/locality-google-calendar" }
 locality-gmail = { path = "crates/locality-gmail" }
 locality-granola = { path = "crates/locality-granola" }
 locality-linear = { path = "crates/locality-linear" }
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index 4d583e6d..d77d0e57 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -14,6 +14,7 @@ loc-cli = { path = "../../../crates/loc-cli" }
 locality-connector.workspace = true
 locality-core.workspace = true
 locality-gmail.workspace = true
+locality-google-calendar.workspace = true
 locality-google-docs.workspace = true
 locality-notion.workspace = true
 locality-platform.workspace = true
diff --git a/apps/desktop/src-tauri/src/main.rs b/apps/desktop/src-tauri/src/main.rs
index 1dfb8646..8b8debc3 100644
--- a/apps/desktop/src-tauri/src/main.rs
+++ b/apps/desktop/src-tauri/src/main.rs
@@ -22,9 +22,10 @@ use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use loc_cli::connect::DEFAULT_NOTION_PROFILE_ID;
 use loc_cli::connect::{
     BrokerOAuthConnectOptions, ConnectOptions, GmailBrokerOAuthConnectOptions,
-    GoogleDocsBrokerOAuthConnectOptions, HttpGranolaConnectionProbe, HttpLinearConnectionProbe,
-    run_connect_gmail_broker_oauth, run_connect_google_docs_broker_oauth, run_connect_granola,
-    run_connect_linear, run_connect_notion_broker_oauth, run_disconnect,
+    GoogleCalendarBrokerOAuthConnectOptions, GoogleDocsBrokerOAuthConnectOptions,
+    HttpGranolaConnectionProbe, HttpLinearConnectionProbe, run_connect_gmail_broker_oauth,
+    run_connect_google_calendar_broker_oauth, run_connect_google_docs_broker_oauth,
+    run_connect_granola, run_connect_linear, run_connect_notion_broker_oauth, run_disconnect,
 };
 use loc_cli::daemon::{DaemonRunState, run_daemon_control};
 use loc_cli::diff::{DiffReport, run_diff};
@@ -65,6 +66,10 @@ use locality_gmail::{
     DEFAULT_GMAIL_OAUTH_BROKER_URL, DEFAULT_GMAIL_OAUTH_REDIRECT_URI, GMAIL_CONNECTOR_ID,
     HttpGmailOAuthBrokerClient,
 };
+use locality_google_calendar::{
+    DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL, DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+    GOOGLE_CALENDAR_CONNECTOR_ID, HttpGoogleCalendarOAuthBrokerClient,
+};
 use locality_google_docs::{
     DEFAULT_GOOGLE_DOCS_OAUTH_BROKER_URL, DEFAULT_GOOGLE_DOCS_OAUTH_REDIRECT_URI,
     GOOGLE_DOCS_CONNECTOR_ID, HttpGoogleDocsOAuthBrokerClient,
@@ -531,6 +536,7 @@ struct MountLiveModeChange {
 
 static CONNECT_NOTION_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
 static CONNECT_GOOGLE_DOCS_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
+static CONNECT_GOOGLE_CALENDAR_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
 static CONNECT_GMAIL_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
 static DAEMON_LIFECYCLE_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
 static NOTION_LOGIN_LINK: OnceLock<Mutex<Option<String>>> = OnceLock::new();
@@ -963,6 +969,11 @@ async fn connect_google_docs(app: AppHandle) -> ActionReport {
     run_google_docs_connection_flow(app, true).await
 }
 
+#[tauri::command]
+async fn connect_google_calendar(app: AppHandle) -> ActionReport {
+    run_google_calendar_connection_flow(app, true).await
+}
+
 #[tauri::command]
 async fn connect_gmail(app: AppHandle) -> ActionReport {
     run_gmail_connection_flow(app, true).await
@@ -1101,6 +1112,55 @@ async fn run_google_docs_connection_flow(app: AppHandle, open_browser: bool) ->
     report
 }
 
+async fn run_google_calendar_connection_flow(app: AppHandle, open_browser: bool) -> ActionReport {
+    if CONNECT_GOOGLE_CALENDAR_IN_PROGRESS.swap(true, Ordering::AcqRel) {
+        return ActionReport {
+            ok: false,
+            message: "A Google Calendar connection flow is already waiting for browser approval."
+                .to_string(),
+        };
+    }
+
+    let state_root = default_state_root();
+    let activity_state_root = state_root.clone();
+    let result = tauri::async_runtime::spawn_blocking(move || {
+        connect_google_calendar_with_broker(state_root, open_browser)
+    })
+    .await
+    .map_err(|error| format!("Google Calendar OAuth worker failed: {error}"));
+    CONNECT_GOOGLE_CALENDAR_IN_PROGRESS.store(false, Ordering::Release);
+
+    let report = match result {
+        Ok(Ok(message)) => {
+            if let Err(error) = record_desktop_activity(
+                &activity_state_root,
+                "Connected Google Calendar",
+                &message,
+                "connect",
+            ) {
+                desktop_log(
+                    "warn",
+                    "activity.record_failed",
+                    format!("could not record Google Calendar access activity: {error}"),
+                );
+            }
+            ActionReport { ok: true, message }
+        }
+        Ok(Err(message)) | Err(message) => {
+            desktop_log(
+                "warn",
+                "google_calendar_access.failed",
+                format!("connect google calendar failed: {message}"),
+            );
+            ActionReport { ok: false, message }
+        }
+    };
+    if report.ok {
+        refresh_desktop_surfaces(&app);
+    }
+    report
+}
+
 async fn run_gmail_connection_flow(app: AppHandle, open_browser: bool) -> ActionReport {
     if CONNECT_GMAIL_IN_PROGRESS.swap(true, Ordering::AcqRel) {
         return ActionReport {
@@ -4230,8 +4290,9 @@ fn connection_connector_rank(connector: &str) -> usize {
     match connector {
         "notion" => 0,
         "google-docs" => 1,
-        "gmail" => 2,
-        "granola" => 3,
+        GOOGLE_CALENDAR_CONNECTOR_ID => 2,
+        "gmail" => 3,
+        "granola" => 4,
         _ => 10,
     }
 }
@@ -5515,6 +5576,11 @@ fn mount_access_scope_label(store: Option<&SqliteStateStore>, mount: &MountConfi
             .as_ref()
             .map(|remote_id| format!("Drive folder {}", remote_id.0))
             .unwrap_or_else(|| "Google Docs workspace folder".to_string()),
+        GOOGLE_CALENDAR_CONNECTOR_ID => mount
+            .remote_root_id
+            .as_ref()
+            .map(|remote_id| format!("Calendar {}", remote_id.0))
+            .unwrap_or_else(|| "Primary calendar".to_string()),
         _ => mount
             .remote_root_id
             .as_ref()
@@ -7480,7 +7546,7 @@ fn create_desktop_mount_blocking(request: CreateDesktopMountRequest) -> Result<S
                 })?;
             Some(folder_id)
         }
-        "gmail" | "granola" | "linear" => None,
+        GOOGLE_CALENDAR_CONNECTOR_ID | "gmail" | "granola" | "linear" => None,
         _ => unreachable!("unsupported desktop connector should be rejected before mount setup"),
     };
     let preserved = if can_remount_existing_workspace {
@@ -7552,7 +7618,7 @@ fn append_macos_file_provider_activation_warning(message: &mut String, warning:
 fn desktop_mount_creation_supports_connector(connector: &str) -> bool {
     matches!(
         connector,
-        "notion" | "google-docs" | "gmail" | "granola" | "linear"
+        "notion" | "google-docs" | GOOGLE_CALENDAR_CONNECTOR_ID | "gmail" | "granola" | "linear"
     )
 }
 
@@ -10061,6 +10127,64 @@ fn connect_google_docs_with_broker(
     ))
 }
 
+fn connect_google_calendar_with_broker(
+    state_root: PathBuf,
+    open_browser: bool,
+) -> Result<String, String> {
+    let mut store = SqliteStateStore::open(state_root.clone())
+        .map_err(|error| format!("Could not open Locality state: {error}"))?;
+    let credentials = open_credential_store(&state_root);
+    let broker_url = env_first(&[
+        "LOCALITY_GOOGLE_CALENDAR_OAUTH_BROKER_URL",
+        "LOCALITY_AUTH_BROKER_URL",
+    ])
+    .unwrap_or_else(|| DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL.to_string());
+    let redirect_uri = env_first(&["LOCALITY_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI"])
+        .unwrap_or_else(|| DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string());
+    let broker = HttpGoogleCalendarOAuthBrokerClient::new(broker_url.clone());
+    let start = broker
+        .start(&OAuthBrokerStart {
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            redirect_uri,
+        })
+        .map_err(|error| format!("Could not start Google Calendar OAuth broker flow: {error}"))?;
+    let authorization = run_local_oauth_authorization(
+        "Google Calendar",
+        &start.authorization_url,
+        &start.redirect_uri,
+        &start.state,
+        !open_browser,
+        true,
+    )
+    .map_err(|error| error.message)?;
+    let options = GoogleCalendarBrokerOAuthConnectOptions {
+        connection_id: Some(ConnectionId::new("google-calendar-default")),
+        broker_url,
+        client_id: start.client_id,
+        session: start.session,
+        state: start.state,
+        code: authorization.code,
+        redirect_uri: start.redirect_uri,
+    };
+
+    let report = run_connect_google_calendar_broker_oauth(
+        &mut store,
+        credentials.as_ref(),
+        options,
+        &broker,
+    )
+    .map_err(|error| error.message())?;
+    let connected_message = match report.workspace_name.or(report.account_label) {
+        Some(label) if !label.is_empty() => {
+            format!("Connected Google Calendar account {label}.")
+        }
+        _ => "Connected Google Calendar.".to_string(),
+    };
+    Ok(format!(
+        "{connected_message} Create a Google Calendar source folder to mount primary calendar events."
+    ))
+}
+
 fn connect_gmail_with_broker(state_root: PathBuf, open_browser: bool) -> Result<String, String> {
     let mut store = SqliteStateStore::open(state_root.clone())
         .map_err(|error| format!("Could not open Locality state: {error}"))?;
@@ -11976,6 +12100,87 @@ mod tests {
         assert!(summary.hydration_progress.is_none());
     }
 
+    #[test]
+    fn source_connection_order_places_google_calendar_before_gmail() {
+        let mut connections = vec![
+            connection_for_connector("gmail", "Gmail"),
+            connection_for_connector("google-calendar", "Primary calendar"),
+            connection_for_connector("granola", "Granola"),
+            connection_for_connector("notion", "CodeFlash"),
+            connection_for_connector("google-docs", "Drive"),
+        ];
+
+        let summaries = super::connection_summaries(&connections);
+
+        assert_eq!(
+            summaries
+                .iter()
+                .map(|connection| connection.connector.as_str())
+                .collect::<Vec<_>>(),
+            vec![
+                "notion",
+                "google-docs",
+                "google-calendar",
+                "gmail",
+                "granola"
+            ]
+        );
+
+        connections.reverse();
+        let summaries = super::connection_summaries(&connections);
+        assert_eq!(
+            summaries
+                .iter()
+                .map(|connection| connection.connector.as_str())
+                .collect::<Vec<_>>(),
+            vec![
+                "notion",
+                "google-docs",
+                "google-calendar",
+                "gmail",
+                "granola"
+            ]
+        );
+    }
+
+    #[test]
+    fn desktop_snapshot_lists_google_calendar_mount_without_remote_root() {
+        let temp = TestTempDir::new("desktop-google-calendar-mount");
+        let mut store = SqliteStateStore::open(temp.path().to_path_buf()).expect("open store");
+        let calendar_connection = connection_for_connector("google-calendar", "Primary calendar");
+        let calendar_mount = MountConfig::new(
+            MountId::new("google-calendar-main"),
+            "google-calendar",
+            temp.path().join("google-calendar"),
+        )
+        .with_connection_id(calendar_connection.connection_id.clone())
+        .projection(ProjectionMode::LinuxFuse);
+
+        store
+            .save_connection(calendar_connection)
+            .expect("save calendar connection");
+        store
+            .save_mount(calendar_mount)
+            .expect("save calendar mount");
+
+        let snapshot = super::load_desktop_snapshot_from_store(&store, temp.path())
+            .expect("load snapshot from test store");
+        let calendar = snapshot
+            .mounts
+            .iter()
+            .find(|mount| mount.mount_id == "google-calendar-main")
+            .expect("calendar mount");
+
+        assert_eq!(
+            snapshot.active_mount_id.as_deref(),
+            Some("google-calendar-main")
+        );
+        assert_eq!(snapshot.connection.connector, "google-calendar");
+        assert_eq!(calendar.connector_name, "Google Calendar");
+        assert_eq!(calendar.access_scope, "Primary calendar");
+        assert_eq!(calendar.remote_root_id, None);
+    }
+
     #[test]
     fn desktop_snapshot_lists_all_mounts_and_marks_active_mount() {
         let temp = TestTempDir::new("desktop-all-mounts");
@@ -14567,6 +14772,9 @@ mod tests {
 
     #[test]
     fn desktop_mount_creation_supports_linear_as_editable_source() {
+        assert!(super::desktop_mount_creation_supports_connector(
+            "google-calendar"
+        ));
         assert!(super::desktop_mount_creation_supports_connector("linear"));
         assert!(super::desktop_mount_is_editable_by_default("linear"));
         assert!(!super::desktop_mount_creation_supports_connector("slack"));
@@ -16672,6 +16880,26 @@ mod tests {
         }
     }
 
+    fn connection_for_connector(connector: &str, workspace_name: &str) -> ConnectionRecord {
+        ConnectionRecord {
+            connection_id: ConnectionId::new(format!("{connector}-default")),
+            profile_id: None,
+            connector: connector.to_string(),
+            display_name: format!("{connector}-default"),
+            account_label: Some(workspace_name.to_string()),
+            workspace_id: None,
+            workspace_name: Some(workspace_name.to_string()),
+            auth_kind: "oauth".to_string(),
+            secret_ref: format!("connection:{connector}-default"),
+            scopes: Vec::new(),
+            capabilities_json: "{}".to_string(),
+            status: "active".to_string(),
+            created_at: "1".to_string(),
+            updated_at: "1".to_string(),
+            expires_at: None,
+        }
+    }
+
     fn search_result(kind: &str, state: &str) -> SearchResult {
         SearchResult {
             mount_id: "notion-main".to_string(),
@@ -17492,6 +17720,7 @@ fn main() {
             connect_notion_without_browser,
             change_notion_access,
             connect_google_docs,
+            connect_google_calendar,
             connect_gmail,
             notion_login_link,
             install_state_review,
diff --git a/apps/desktop/src/App.tsx b/apps/desktop/src/App.tsx
index 2a1f0bc4..d3eb16a4 100644
--- a/apps/desktop/src/App.tsx
+++ b/apps/desktop/src/App.tsx
@@ -111,6 +111,7 @@ import {
   type SourceSetupState,
 } from "./source-setup";
 import gmailIconUrl from "./assets/connectors/gmail.svg";
+import googleCalendarIconUrl from "./assets/connectors/google-calendar.svg";
 import googleDocsIconUrl from "./assets/connectors/google-docs.svg";
 import granolaIconUrl from "./assets/connectors/granola.svg";
 import linearIconUrl from "./assets/connectors/linear.svg";
@@ -147,6 +148,7 @@ type ConnectorOption = {
 const CONNECTOR_ICON_URLS: Record<SourceConnectorId, string> = {
   notion: notionIconUrl,
   "google-docs": googleDocsIconUrl,
+  "google-calendar": googleCalendarIconUrl,
   gmail: gmailIconUrl,
   granola: granolaIconUrl,
   linear: linearIconUrl,
@@ -716,6 +718,8 @@ function suggestedAgentPrompt(mountPath: string, connector: OnboardingConnectorI
       return `Use Locality to read my Granola meetings. Open the files under ${mountPath}, search summaries and transcripts with normal file tools, and cite the meeting files you used. Granola is read-only in Locality, so do not try to push edits back.`;
     case "google-docs":
       return `Use Locality to edit my Google Docs workspace. Open the files under ${mountPath}, make the requested edits directly in Markdown, and leave changes pending for Locality review before pushing.`;
+    case "google-calendar":
+      return `Use Locality to inspect my Google Calendar source. Open the files under ${mountPath}, review calendar events with normal file tools, and prepare new event drafts for Locality review before creating them.`;
     case "gmail":
       return `Use Locality to inspect my Gmail source. Open the files under ${mountPath}, search mail with normal file tools, and prepare draft updates only when the mounted draft files support it. Leave outbound changes for Locality review.`;
     case "linear":
@@ -775,6 +779,8 @@ function onboardingConnectorDescription(
         return `${workspaceLabel} is ready. Locality will now create the Notion folder under CloudStorage and prepare the local workspace.`;
       case "google-docs":
         return "Google Docs is ready. Locality mounted the selected Drive folder as local files under CloudStorage.";
+      case "google-calendar":
+        return "Google Calendar is ready. Locality mounted primary calendar events as local files under CloudStorage.";
       case "gmail":
         return "Gmail is ready. Locality mounted mailboxes as local files under CloudStorage.";
       case "granola":
@@ -790,6 +796,8 @@ function onboardingConnectorDescription(
         return "A browser window is open. Choose the workspace and pages Locality can access, then approve.";
       case "google-docs":
         return "A browser window is open. Approve Google Docs access, then Locality will create the local folder.";
+      case "google-calendar":
+        return "A browser window is open. Approve Google Calendar access, then Locality will create the local calendar folder.";
       case "gmail":
         return "A browser window is open. Approve Gmail access, then Locality will create the local mailbox folder.";
       case "granola":
@@ -804,6 +812,8 @@ function onboardingConnectorDescription(
       return "Connect the source you want agents to help with. Your machine talks directly to Notion, and app credentials are protected by macOS Keychain.";
     case "google-docs":
       return "Connect Google Docs during setup so agents can work with docs through the same local file workflow.";
+    case "google-calendar":
+      return "Connect Google Calendar during setup so agents can review events and prepare new event drafts through local files.";
     case "gmail":
       return "Connect Gmail during setup so agents can search mailboxes and prepare reviewed draft work from local files.";
     case "granola":
@@ -819,6 +829,8 @@ function onboardingConnectorPills(connector: OnboardingConnectorId) {
       return ["Scoped access", "Credentials in Keychain", "Direct app connection"];
     case "google-docs":
       return ["Google OAuth", "Drive folder", "Markdown edits"];
+    case "google-calendar":
+      return ["Google OAuth", "Primary calendar", "Event drafts"];
     case "gmail":
       return ["Google OAuth", "Mailbox files", "Draft review"];
     case "granola":
@@ -834,6 +846,8 @@ function onboardingReadyCopy(connector: OnboardingConnectorId) {
       return "Your local workspace is ready. Agents can open this folder, edit Markdown, and leave changes for Review Center. Open the app to review changes, manage sync, and turn on Live Mode when you want file saves to update Notion and new Notion changes to appear locally.";
     case "google-docs":
       return "Your Google Docs workspace is ready as local files. Agents can edit docs in Markdown and leave changes for Review Center before anything is pushed back.";
+    case "google-calendar":
+      return "Your Google Calendar source is ready as local files. Agents can review events and prepare new event drafts before anything is created remotely.";
     case "gmail":
       return "Your Gmail source is ready as local files. Agents can search mailbox content and prepare reviewed draft work without leaving the filesystem.";
     case "granola":
@@ -2021,7 +2035,7 @@ function Onboarding({
     );
   }
 
-  async function connectGoogleOnboarding(connector: "google-docs" | "gmail") {
+  async function connectGoogleOnboarding(connector: "google-docs" | "google-calendar" | "gmail") {
     if (selectedConnectorBusy) {
       return;
     }
@@ -2036,7 +2050,7 @@ function Onboarding({
     setOauthInFlight(true);
     setStep(3);
     try {
-      const command = connector === "google-docs" ? "connect_google_docs" : "connect_gmail";
+      const command = googleOAuthConnectCommand(connector);
       const connectReport = await callCommand<ActionReport>(
         command,
         undefined,
@@ -2085,6 +2099,7 @@ function Onboarding({
         await startConnect();
         return;
       case "google-docs":
+      case "google-calendar":
       case "gmail":
         await connectGoogleOnboarding(selectedOnboardingConnector);
         return;
@@ -3504,7 +3519,7 @@ function MountsView({
       return { ok: false, message: `${sourceDisplayName(connector)} requires an API key.` };
     }
 
-    const command = connector === "google-docs" ? "connect_google_docs" : "connect_gmail";
+    const command = googleOAuthConnectCommand(connector);
     setActionError("");
     setActionMessage("");
     const report = await callCommand<ActionReport>(
@@ -3868,6 +3883,14 @@ function AddSourceDialog({
       keywords: ["google", "docs", "gdocs", "drive", "documents"],
       mounted: sourceMounted(snapshot, "google-docs"),
     },
+    {
+      id: "google-calendar",
+      name: "Google Calendar",
+      description: "Primary calendar events as files, new events from reviewed drafts.",
+      status: sourceConnectorStatus(snapshot, "google-calendar"),
+      keywords: ["google", "calendar", "gcal", "events", "meet"],
+      mounted: sourceMounted(snapshot, "google-calendar"),
+    },
     {
       id: "gmail",
       name: "Gmail",
@@ -4029,6 +4052,11 @@ function AddSourceDialog({
                         <SettingRow title="Workspace folder" value={googleDocsWorkspaceFolder || "Locality"} />
                         <SettingRow title="Local folder" value={sourceDefaultPath(snapshot, connector.id)} />
                       </>
+                    ) : connector.id === "google-calendar" ? (
+                      <>
+                        <SettingRow title="Calendar" value="Primary calendar" />
+                        <SettingRow title="Local folder" value={sourceDefaultPath(snapshot, connector.id)} />
+                      </>
                     ) : connector.id === "granola" ? (
                       <>
                         <SettingRow title="Content" value="Summaries and transcripts" />
@@ -4144,6 +4172,8 @@ function sourceDisplayName(connector: SourceConnectorId) {
       return "Notion";
     case "google-docs":
       return "Google Docs";
+    case "google-calendar":
+      return "Google Calendar";
     case "gmail":
       return "Gmail";
     case "granola":
@@ -4159,6 +4189,8 @@ function sourceMountId(connector: SourceConnectorId) {
       return "notion-main";
     case "google-docs":
       return "google-docs-main";
+    case "google-calendar":
+      return "google-calendar-main";
     case "gmail":
       return "gmail-main";
     case "granola":
@@ -4220,6 +4252,8 @@ function sourceDefaultPath(snapshot: DesktopSnapshot, connector: SourceConnector
       return "~/Library/CloudStorage/Locality/notion";
     case "google-docs":
       return "~/Library/CloudStorage/Locality/google-docs-main";
+    case "google-calendar":
+      return "~/Library/CloudStorage/Locality/google-calendar-main";
     case "gmail":
       return "~/Library/CloudStorage/Locality/gmail-main";
     case "granola":
@@ -4255,6 +4289,17 @@ function sourceActionIcon(connector: SourceConnectorId, needsConnection: boolean
   return <FolderOpen />;
 }
 
+function googleOAuthConnectCommand(connector: "google-docs" | "google-calendar" | "gmail") {
+  switch (connector) {
+    case "google-docs":
+      return "connect_google_docs";
+    case "google-calendar":
+      return "connect_google_calendar";
+    case "gmail":
+      return "connect_gmail";
+  }
+}
+
 function ConnectorIcon({ connector }: { connector: SourceConnectorId }) {
   return (
     <span className={`connector-icon ${connector}`} aria-hidden="true">
@@ -7571,6 +7616,19 @@ function ConnectorOptions({
         </div>
         <span>{connectedConnector === "google-docs" ? "Connected" : "OAuth"}</span>
       </button>
+      <button
+        type="button"
+        className={`connector-option available selectable ${selected === "google-calendar" ? "selected" : ""}`}
+        disabled={busy}
+        onClick={() => onSelect("google-calendar")}
+      >
+        <ConnectorIcon connector="google-calendar" />
+        <div>
+          <strong>Google Calendar</strong>
+          <small>Primary calendar events and reviewed event drafts.</small>
+        </div>
+        <span>{connectedConnector === "google-calendar" ? "Connected" : "OAuth"}</span>
+      </button>
       <button
         type="button"
         className={`connector-option available selectable ${selected === "gmail" ? "selected" : ""}`}
diff --git a/apps/desktop/src/assets/connectors/google-calendar.svg b/apps/desktop/src/assets/connectors/google-calendar.svg
new file mode 100644
index 00000000..bfe93262
--- /dev/null
+++ b/apps/desktop/src/assets/connectors/google-calendar.svg
@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="192" height="192" fill="none" viewBox="0 0 192 192">
+  <rect width="144" height="144" x="24" y="24" fill="#fff" rx="24"/>
+  <path fill="#3186FF" d="M48 24h96c13.255 0 24 10.745 24 24v22H24V48c0-13.255 10.745-24 24-24Z"/>
+  <path fill="#60D673" d="M24 70h34v98H48c-13.255 0-24-10.745-24-24V70Z"/>
+  <path fill="#FEB10C" d="M134 70h34v74c0 13.255-10.745 24-24 24h-10V70Z"/>
+  <path fill="#FC413D" d="M58 70h76v98H58V70Z"/>
+  <rect width="88" height="78" x="52" y="78" fill="#fff" rx="10"/>
+  <path fill="#3186FF" d="M73.5 132.35h17.75V91.1H75.4l-14.1 10.05 6.95 10.05 5.25-3.7v24.85Zm42.824 1.05c12.35 0 20.45-8.8 20.45-21.7 0-12.85-8.1-21.65-20.45-21.65-12.3 0-20.4 8.8-20.4 21.65 0 12.9 8.1 21.7 20.4 21.7Zm0-12.6c-4 0-6.55-3.45-6.55-9.1 0-5.6 2.55-9.05 6.55-9.05s6.6 3.45 6.6 9.05c0 5.65-2.6 9.1-6.6 9.1Z"/>
+  <rect width="16" height="36" x="58" y="8" fill="#202124" rx="8"/>
+  <rect width="16" height="36" x="118" y="8" fill="#202124" rx="8"/>
+</svg>
diff --git a/apps/desktop/src/mounts.test.ts b/apps/desktop/src/mounts.test.ts
index bca44cc9..bace016d 100644
--- a/apps/desktop/src/mounts.test.ts
+++ b/apps/desktop/src/mounts.test.ts
@@ -92,6 +92,31 @@ describe("mount display helpers", () => {
     });
   });
 
+  it("builds Google Calendar mount rows with calendar workspace context", () => {
+    const notion = mount({});
+    const calendar = mount({
+      mountId: "google-calendar-main",
+      connector: "google-calendar",
+      connectorName: "Google Calendar",
+      connectionId: "google-calendar-default",
+      workspaceName: "Primary calendar",
+      localPath: "/home/ada/Locality/google-calendar-main",
+      notionUrl: null,
+      accessScope: "Primary calendar",
+      remoteRootId: null,
+      entityCount: 8,
+      pendingChangeCount: 0,
+    });
+
+    const rows = mountRows([notion, calendar], notion, "google-calendar-main");
+    const selected = selectedMountRow(rows, "google-calendar-main");
+
+    expect(selected).toMatchObject({
+      title: "Google Calendar",
+      subtitle: "Primary calendar / google-calendar-main",
+    });
+  });
+
   it("labels indexed mount entities as items, not physical files", () => {
     expect(mountEntityCountLabel(mount({ entityCount: 1 }))).toBe("1 item");
     expect(mountEntityCountLabel(mount({ entityCount: 260 }))).toBe("260 items");
diff --git a/apps/desktop/src/source-setup.test.ts b/apps/desktop/src/source-setup.test.ts
index adb409d6..1fcb3d84 100644
--- a/apps/desktop/src/source-setup.test.ts
+++ b/apps/desktop/src/source-setup.test.ts
@@ -1,6 +1,7 @@
 import { describe, expect, it } from "vitest";
 import {
   connectedSourcesReadyToMount,
+  isSourceConnectorId,
   sourceConnectorIds,
   sourceRequiresApiKey,
   sourceSkipsManualMountStep,
@@ -27,8 +28,10 @@ describe("source setup progress", () => {
 
   it("includes Linear in the desktop source catalog as an API-key connector", () => {
     expect(sourceConnectorIds()).toContain("linear");
+    expect(sourceConnectorIds()).toContain("google-calendar");
     expect(sourceRequiresApiKey("linear")).toBe(true);
     expect(sourceRequiresApiKey("granola")).toBe(true);
+    expect(sourceRequiresApiKey("google-calendar")).toBe(false);
     expect(sourceRequiresApiKey("gmail")).toBe(false);
     expect(sourceSkipsManualMountStep("linear")).toBe(true);
   });
@@ -54,6 +57,16 @@ describe("source setup progress", () => {
       }),
     ).toEqual(["notion"]);
   });
+
+  it("recognizes Google Calendar as ready to mount when connected", () => {
+    expect(isSourceConnectorId("google-calendar")).toBe(true);
+    expect(
+      connectedSourcesReadyToMount({
+        connections: [{ connector: "google-calendar", status: "active" }],
+        mounts: [],
+      }),
+    ).toEqual(["google-calendar"]);
+  });
 });
 
 describe("source File Provider mount retry", () => {
diff --git a/apps/desktop/src/source-setup.ts b/apps/desktop/src/source-setup.ts
index e3cd3b01..c58f8590 100644
--- a/apps/desktop/src/source-setup.ts
+++ b/apps/desktop/src/source-setup.ts
@@ -1,7 +1,7 @@
 import { classifyMountSetupError } from "./onboarding-errors";
 
 export type SourceSetupState = "idle" | "connecting" | "creating" | "changing" | "success" | "error";
-const SOURCE_CONNECTORS = ["notion", "google-docs", "gmail", "granola", "linear"] as const;
+const SOURCE_CONNECTORS = ["notion", "google-docs", "google-calendar", "gmail", "granola", "linear"] as const;
 export type SourceConnectorId = (typeof SOURCE_CONNECTORS)[number];
 export type ApiKeySourceConnectorId = Extract<SourceConnectorId, "granola" | "linear">;
 export type SourceMountRetryOutcome =
diff --git a/apps/oauth-service/README.md b/apps/oauth-service/README.md
index e83b2a63..b5141ffc 100644
--- a/apps/oauth-service/README.md
+++ b/apps/oauth-service/README.md
@@ -134,6 +134,63 @@ Request:
 }
 ```
 
+### `POST /v1/oauth/google-calendar/start`
+
+Request:
+
+```json
+{
+  "redirect_uri": "http://localhost:8757/oauth/google-calendar/callback"
+}
+```
+
+If omitted, the default callback is
+`http://localhost:8757/oauth/google-calendar/callback`. The broker requests
+`openid`, `email`, `profile`, and
+`https://www.googleapis.com/auth/calendar.events`.
+
+Response:
+
+```json
+{
+  "connector": "google-calendar",
+  "client_id": "public-client-id",
+  "authorization_url": "https://accounts.google.com/o/oauth2/v2/auth?...",
+  "redirect_uri": "http://localhost:8757/oauth/google-calendar/callback",
+  "session": "signed-session",
+  "state": "opaque-state",
+  "expires_in": 600
+}
+```
+
+### `POST /v1/oauth/google-calendar/exchange`
+
+Request:
+
+```json
+{
+  "session": "signed-session",
+  "state": "opaque-state",
+  "code": "provider-authorization-code",
+  "redirect_uri": "http://localhost:8757/oauth/google-calendar/callback"
+}
+```
+
+Response includes the Google OAuth access token for Calendar event scopes,
+granted scopes, optional ID token, `workspace_id: "primary"`,
+`workspace_name: "Primary calendar"`, and either `refresh_token_handle` or
+`refresh_token`, depending on `LOCALITY_TOKEN_MODE`.
+
+### `POST /v1/oauth/google-calendar/refresh`
+
+Request:
+
+```json
+{
+  "refresh_token_handle": "locrh_v1..."
+}
+```
+
 ### `POST /v1/oauth/gmail/start`
 
 Request:
@@ -205,14 +262,14 @@ npm run check
 - `LOCALITY_REFRESH_HANDLE_KEY`: encrypts opaque refresh handles in `handle` mode.
 - `LOCALITY_NOTION_CLIENT_ID`: Notion OAuth client ID.
 - `LOCALITY_NOTION_CLIENT_SECRET`: Notion OAuth client secret.
-- `LOCALITY_GOOGLE_CLIENT_ID`: Google OAuth client ID shared by Google Docs and Gmail.
-- `LOCALITY_GOOGLE_CLIENT_SECRET`: Google OAuth client secret shared by Google Docs and Gmail.
+- `LOCALITY_GOOGLE_CLIENT_ID`: Google OAuth client ID shared by Google Docs, Google Calendar, and Gmail.
+- `LOCALITY_GOOGLE_CLIENT_SECRET`: Google OAuth client secret shared by Google Docs, Google Calendar, and Gmail.
 
 Optional connector overrides:
 
-- `LOCALITY_NOTION_REDIRECT_URIS`, `LOCALITY_GOOGLE_DOCS_REDIRECT_URIS`, `LOCALITY_GMAIL_REDIRECT_URIS`: comma-separated allowed loopback redirect URIs.
-- `LOCALITY_NOTION_AUTH_BASE_URL`, `LOCALITY_GOOGLE_DOCS_AUTH_BASE_URL`, `LOCALITY_GMAIL_AUTH_BASE_URL`: provider authorization base URL.
-- `LOCALITY_NOTION_API_BASE_URL`, `LOCALITY_GOOGLE_DOCS_API_BASE_URL`, `LOCALITY_GMAIL_API_BASE_URL`: provider token API base URL.
+- `LOCALITY_NOTION_REDIRECT_URIS`, `LOCALITY_GOOGLE_DOCS_REDIRECT_URIS`, `LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS`, `LOCALITY_GMAIL_REDIRECT_URIS`: comma-separated allowed loopback redirect URIs.
+- `LOCALITY_NOTION_AUTH_BASE_URL`, `LOCALITY_GOOGLE_DOCS_AUTH_BASE_URL`, `LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL`, `LOCALITY_GMAIL_AUTH_BASE_URL`: provider authorization base URL.
+- `LOCALITY_NOTION_API_BASE_URL`, `LOCALITY_GOOGLE_DOCS_API_BASE_URL`, `LOCALITY_GOOGLE_CALENDAR_API_BASE_URL`, `LOCALITY_GMAIL_API_BASE_URL`: provider token API base URL.
 
 ## Deployment
 
diff --git a/apps/oauth-service/docs/deployment.md b/apps/oauth-service/docs/deployment.md
index b105b3a7..e491288e 100644
--- a/apps/oauth-service/docs/deployment.md
+++ b/apps/oauth-service/docs/deployment.md
@@ -28,11 +28,13 @@ http://127.0.0.1:8757/oauth/notion/callback
 ```
 
 Configure one Google OAuth client with the exact localhost callbacks used by
-Locality for both Google Docs and Gmail:
+Locality for Google Docs, Google Calendar, and Gmail:
 
 ```text
 http://localhost:8757/oauth/google-docs/callback
 http://127.0.0.1:8757/oauth/google-docs/callback
+http://localhost:8757/oauth/google-calendar/callback
+http://127.0.0.1:8757/oauth/google-calendar/callback
 http://localhost:8757/oauth/gmail/callback
 http://127.0.0.1:8757/oauth/gmail/callback
 ```
@@ -51,13 +53,17 @@ LOCALITY_NOTION_OAUTH_CLIENT_ID=<public client id>
 ```
 
 The client ID may also be fetched from `/v1/oauth/notion/start`,
-`/v1/oauth/google-docs/start`, or `/v1/oauth/gmail/start`; keeping it in the
-Locality binary is fine because it is not confidential. The two Google start
-endpoints return the same shared Google OAuth client ID.
+`/v1/oauth/google-docs/start`, `/v1/oauth/google-calendar/start`, or
+`/v1/oauth/gmail/start`; keeping it in the Locality binary is fine because it is
+not confidential. The three Google start endpoints return the same shared
+Google OAuth client ID.
 
-Optional broker environment overrides for Gmail local testing:
+Optional broker environment overrides for Google connector local testing:
 
 ```text
+LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS=http://localhost:8757/oauth/google-calendar/callback,http://127.0.0.1:8757/oauth/google-calendar/callback
+LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL=https://accounts.google.com
+LOCALITY_GOOGLE_CALENDAR_API_BASE_URL=https://oauth2.googleapis.com
 LOCALITY_GMAIL_REDIRECT_URIS=http://localhost:8757/oauth/gmail/callback,http://127.0.0.1:8757/oauth/gmail/callback
 LOCALITY_GMAIL_AUTH_BASE_URL=https://accounts.google.com
 LOCALITY_GMAIL_API_BASE_URL=https://oauth2.googleapis.com
diff --git a/apps/oauth-service/src/app.ts b/apps/oauth-service/src/app.ts
index 7b017406..7eaebacc 100644
--- a/apps/oauth-service/src/app.ts
+++ b/apps/oauth-service/src/app.ts
@@ -6,11 +6,22 @@ import {
   refreshGoogleDocsToken,
   type GoogleDocsTokenResponse
 } from "./oauth/google-docs";
+import {
+  exchangeGoogleCalendarCode,
+  googleCalendarAuthorizeUrl,
+  refreshGoogleCalendarToken,
+  type GoogleCalendarTokenResponse
+} from "./oauth/google-calendar";
 import { exchangeGmailCode, gmailAuthorizeUrl, refreshGmailToken, type GmailTokenResponse } from "./oauth/gmail";
 import { googleClientId } from "./oauth/google";
 import { exchangeNotionCode, notionAuthorizeUrl, refreshNotionToken, type NotionTokenResponse } from "./oauth/notion";
 import { randomBase64Url, decryptJsonHandle, encryptJsonHandle } from "./security/crypto";
-import { validateGmailRedirectUri, validateGoogleDocsRedirectUri, validateNotionRedirectUri } from "./security/redirects";
+import {
+  validateGmailRedirectUri,
+  validateGoogleCalendarRedirectUri,
+  validateGoogleDocsRedirectUri,
+  validateNotionRedirectUri
+} from "./security/redirects";
 import { nowSeconds, signSession, verifySession } from "./security/session";
 import type { ApiErrorBody, BrokerEnv, ConnectorId } from "./types";
 
@@ -59,6 +70,11 @@ app.get("/.well-known/loc-auth-broker", (c) =>
         session_ttl_seconds: SESSION_TTL_SECONDS,
         refresh_token_modes: [tokenMode(c.env)]
       },
+      "google-calendar": {
+        oauth: "brokered_confidential",
+        session_ttl_seconds: SESSION_TTL_SECONDS,
+        refresh_token_modes: [tokenMode(c.env)]
+      },
       gmail: {
         oauth: "brokered_confidential",
         session_ttl_seconds: SESSION_TTL_SECONDS,
@@ -178,6 +194,61 @@ app.post("/v1/oauth/google-docs/refresh", async (c) => {
   return c.json(await shapeGoogleDocsTokenResponse(c.env, token));
 });
 
+app.post("/v1/oauth/google-calendar/start", async (c) => {
+  const body = await optionalJson<StartRequest>(c.req.raw);
+  const redirectUri = validateGoogleCalendarRedirectUri(
+    c.env,
+    body.redirect_uri ?? "http://localhost:8757/oauth/google-calendar/callback"
+  );
+  const now = nowSeconds();
+  const state = randomBase64Url();
+  const session = await signSession(
+    {
+      v: 1,
+      connector: "google-calendar",
+      state,
+      redirect_uri: redirectUri,
+      iat: now,
+      exp: now + SESSION_TTL_SECONDS,
+      nonce: randomBase64Url()
+    },
+    requireOperationalSecret(c.env.LOCALITY_BROKER_SESSION_SECRET, "LOCALITY_BROKER_SESSION_SECRET")
+  );
+  return c.json({
+    connector: "google-calendar",
+    client_id: googleClientId(c.env),
+    authorization_url: googleCalendarAuthorizeUrl(c.env, redirectUri, state),
+    redirect_uri: redirectUri,
+    session,
+    state,
+    expires_in: SESSION_TTL_SECONDS
+  });
+});
+
+app.post("/v1/oauth/google-calendar/exchange", async (c) => {
+  const body = await requiredJson<ExchangeRequest>(c.req.raw);
+  const session = requireString(body.session, "session");
+  const state = requireString(body.state, "state");
+  const code = requireString(body.code, "code");
+  const redirectUri = validateGoogleCalendarRedirectUri(c.env, requireString(body.redirect_uri, "redirect_uri"));
+  const payload = await verifySession(
+    session,
+    requireOperationalSecret(c.env.LOCALITY_BROKER_SESSION_SECRET, "LOCALITY_BROKER_SESSION_SECRET")
+  );
+  if (payload.connector !== "google-calendar" || payload.state !== state || payload.redirect_uri !== redirectUri) {
+    throw badRequest("oauth_session_mismatch", "OAuth callback did not match the broker session");
+  }
+  const token = await exchangeGoogleCalendarCode(c.env, code, redirectUri);
+  return c.json(await shapeGoogleCalendarTokenResponse(c.env, token));
+});
+
+app.post("/v1/oauth/google-calendar/refresh", async (c) => {
+  const body = await requiredJson<RefreshRequest>(c.req.raw);
+  const refreshToken = await resolveRefreshToken(c.env, "google-calendar", body);
+  const token = await refreshGoogleCalendarToken(c.env, refreshToken);
+  return c.json(await shapeGoogleCalendarTokenResponse(c.env, token));
+});
+
 app.post("/v1/oauth/gmail/start", async (c) => {
   const body = await optionalJson<StartRequest>(c.req.raw);
   const redirectUri = validateGmailRedirectUri(
@@ -274,6 +345,21 @@ async function shapeGoogleDocsTokenResponse(env: BrokerEnv, token: GoogleDocsTok
   };
 }
 
+async function shapeGoogleCalendarTokenResponse(env: BrokerEnv, token: GoogleCalendarTokenResponse) {
+  const refresh = await shapeRefreshToken(env, "google-calendar", token.refresh_token);
+  return {
+    connector: "google-calendar",
+    access_token: token.access_token,
+    token_type: token.token_type,
+    expires_in: token.expires_in,
+    scope: token.scope,
+    id_token: token.id_token,
+    workspace_id: "primary",
+    workspace_name: "Primary calendar",
+    ...refresh
+  };
+}
+
 async function shapeGmailTokenResponse(env: BrokerEnv, token: GmailTokenResponse) {
   const refresh = await shapeRefreshToken(env, "gmail", token.refresh_token);
   return {
diff --git a/apps/oauth-service/src/oauth/google-calendar.ts b/apps/oauth-service/src/oauth/google-calendar.ts
new file mode 100644
index 00000000..6e438df7
--- /dev/null
+++ b/apps/oauth-service/src/oauth/google-calendar.ts
@@ -0,0 +1,97 @@
+import { upstreamError } from "../http/errors";
+import type { BrokerEnv } from "../types";
+import { googleClientId, googleClientSecret } from "./google";
+
+export const GOOGLE_CALENDAR_OAUTH_SCOPES = [
+  "openid",
+  "email",
+  "profile",
+  "https://www.googleapis.com/auth/calendar.events"
+];
+
+export interface GoogleCalendarTokenResponse {
+  access_token: string;
+  token_type?: string;
+  refresh_token?: string;
+  expires_in?: number;
+  scope?: string;
+  id_token?: string;
+}
+
+export function googleCalendarAuthorizeUrl(env: BrokerEnv, redirectUri: string, state: string): string {
+  const url = new URL(`${googleCalendarAuthBaseUrl(env)}/o/oauth2/v2/auth`);
+  url.searchParams.set("client_id", googleClientId(env));
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("redirect_uri", redirectUri);
+  url.searchParams.set("scope", GOOGLE_CALENDAR_OAUTH_SCOPES.join(" "));
+  url.searchParams.set("state", state);
+  url.searchParams.set("access_type", "offline");
+  url.searchParams.set("prompt", "consent");
+  url.searchParams.set("include_granted_scopes", "true");
+  return url.toString();
+}
+
+export async function exchangeGoogleCalendarCode(
+  env: BrokerEnv,
+  code: string,
+  redirectUri: string,
+  fetcher: typeof fetch = fetch
+): Promise<GoogleCalendarTokenResponse> {
+  return googleCalendarTokenRequest(
+    env,
+    {
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri
+    },
+    fetcher
+  );
+}
+
+export async function refreshGoogleCalendarToken(
+  env: BrokerEnv,
+  refreshToken: string,
+  fetcher: typeof fetch = fetch
+): Promise<GoogleCalendarTokenResponse> {
+  return googleCalendarTokenRequest(
+    env,
+    {
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    },
+    fetcher
+  );
+}
+
+async function googleCalendarTokenRequest(
+  env: BrokerEnv,
+  body: Record<string, string>,
+  fetcher: typeof fetch
+): Promise<GoogleCalendarTokenResponse> {
+  const clientId = googleClientId(env);
+  const clientSecret = googleClientSecret(env);
+  const params = new URLSearchParams({
+    client_id: clientId,
+    client_secret: clientSecret,
+    ...body
+  });
+  const response = await fetcher(`${googleCalendarApiBaseUrl(env)}/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: params.toString()
+  });
+  if (!response.ok) {
+    throw upstreamError(`Google Calendar OAuth returned HTTP ${response.status}`);
+  }
+  return response.json() as Promise<GoogleCalendarTokenResponse>;
+}
+
+function googleCalendarAuthBaseUrl(env: BrokerEnv): string {
+  return (env.LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL ?? "https://accounts.google.com").replace(/\/+$/, "");
+}
+
+function googleCalendarApiBaseUrl(env: BrokerEnv): string {
+  return (env.LOCALITY_GOOGLE_CALENDAR_API_BASE_URL ?? "https://oauth2.googleapis.com").replace(/\/+$/, "");
+}
diff --git a/apps/oauth-service/src/security/redirects.ts b/apps/oauth-service/src/security/redirects.ts
index c1cbed4b..04af88e8 100644
--- a/apps/oauth-service/src/security/redirects.ts
+++ b/apps/oauth-service/src/security/redirects.ts
@@ -11,6 +11,11 @@ const DEFAULT_GOOGLE_DOCS_REDIRECT_URIS = [
   "http://127.0.0.1:8757/oauth/google-docs/callback"
 ];
 
+const DEFAULT_GOOGLE_CALENDAR_REDIRECT_URIS = [
+  "http://localhost:8757/oauth/google-calendar/callback",
+  "http://127.0.0.1:8757/oauth/google-calendar/callback"
+];
+
 const DEFAULT_GMAIL_REDIRECT_URIS = [
   "http://localhost:8757/oauth/gmail/callback",
   "http://127.0.0.1:8757/oauth/gmail/callback"
@@ -32,6 +37,14 @@ export function validateGoogleDocsRedirectUri(env: BrokerEnv, redirectUri: strin
   return validateLoopbackRedirectUri("Google Docs", allowedGoogleDocsRedirectUris(env), redirectUri);
 }
 
+export function allowedGoogleCalendarRedirectUris(env: BrokerEnv): string[] {
+  return splitList(env.LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS) ?? DEFAULT_GOOGLE_CALENDAR_REDIRECT_URIS;
+}
+
+export function validateGoogleCalendarRedirectUri(env: BrokerEnv, redirectUri: string): string {
+  return validateLoopbackRedirectUri("Google Calendar", allowedGoogleCalendarRedirectUris(env), redirectUri);
+}
+
 export function allowedGmailRedirectUris(env: BrokerEnv): string[] {
   return splitList(env.LOCALITY_GMAIL_REDIRECT_URIS) ?? DEFAULT_GMAIL_REDIRECT_URIS;
 }
diff --git a/apps/oauth-service/src/security/session.ts b/apps/oauth-service/src/security/session.ts
index 5a2cba01..3ed3eb9d 100644
--- a/apps/oauth-service/src/security/session.ts
+++ b/apps/oauth-service/src/security/session.ts
@@ -53,7 +53,10 @@ function isOAuthSessionPayload(value: unknown): value is OAuthSessionPayload {
   const payload = value as Partial<OAuthSessionPayload>;
   return (
     payload.v === 1 &&
-    (payload.connector === "notion" || payload.connector === "google-docs" || payload.connector === "gmail") &&
+    (payload.connector === "notion" ||
+      payload.connector === "google-docs" ||
+      payload.connector === "google-calendar" ||
+      payload.connector === "gmail") &&
     typeof payload.state === "string" &&
     typeof payload.redirect_uri === "string" &&
     typeof payload.iat === "number" &&
diff --git a/apps/oauth-service/src/types.ts b/apps/oauth-service/src/types.ts
index 443d6873..18eb2ddc 100644
--- a/apps/oauth-service/src/types.ts
+++ b/apps/oauth-service/src/types.ts
@@ -13,12 +13,15 @@ export interface BrokerEnv {
   LOCALITY_GOOGLE_DOCS_REDIRECT_URIS?: string;
   LOCALITY_GOOGLE_DOCS_AUTH_BASE_URL?: string;
   LOCALITY_GOOGLE_DOCS_API_BASE_URL?: string;
+  LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS?: string;
+  LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL?: string;
+  LOCALITY_GOOGLE_CALENDAR_API_BASE_URL?: string;
   LOCALITY_GMAIL_REDIRECT_URIS?: string;
   LOCALITY_GMAIL_AUTH_BASE_URL?: string;
   LOCALITY_GMAIL_API_BASE_URL?: string;
 }
 
-export type ConnectorId = "notion" | "google-docs" | "gmail";
+export type ConnectorId = "notion" | "google-docs" | "google-calendar" | "gmail";
 
 export interface ApiErrorBody {
   error: {
diff --git a/apps/oauth-service/test/app.test.ts b/apps/oauth-service/test/app.test.ts
index c72a14b1..855843f3 100644
--- a/apps/oauth-service/test/app.test.ts
+++ b/apps/oauth-service/test/app.test.ts
@@ -13,8 +13,12 @@ interface StartResponse {
 }
 
 interface BrokerTokenResponse {
+  connector: string;
   access_token: string;
   scope?: string;
+  id_token?: string;
+  workspace_id?: string;
+  workspace_name?: string;
   refresh_token?: string;
   refresh_token_kind?: string;
   refresh_token_handle?: string;
@@ -34,6 +38,9 @@ const env: BrokerEnv = {
   LOCALITY_GOOGLE_DOCS_API_BASE_URL: "https://oauth2.example.test",
   LOCALITY_GOOGLE_DOCS_AUTH_BASE_URL: "https://accounts.example.test",
   LOCALITY_GOOGLE_DOCS_REDIRECT_URIS: "http://localhost:8757/oauth/google-docs/callback",
+  LOCALITY_GOOGLE_CALENDAR_API_BASE_URL: "https://oauth2.example.test",
+  LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL: "https://accounts.example.test",
+  LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS: "http://localhost:8757/oauth/google-calendar/callback",
   LOCALITY_GMAIL_API_BASE_URL: "https://oauth2.example.test",
   LOCALITY_GMAIL_AUTH_BASE_URL: "https://accounts.example.test",
   LOCALITY_GMAIL_REDIRECT_URIS: "http://localhost:8757/oauth/gmail/callback"
@@ -58,6 +65,11 @@ describe("auth broker", () => {
     expect(response.status).toBe(200);
     await expect(response.json()).resolves.toMatchObject({
       connectors: {
+        "google-calendar": {
+          oauth: "brokered_confidential",
+          session_ttl_seconds: 600,
+          refresh_token_modes: ["handle"]
+        },
         gmail: {
           oauth: "brokered_confidential",
           session_ttl_seconds: 600,
@@ -365,6 +377,94 @@ describe("auth broker", () => {
     expect(refreshRequest.get("refresh_token")).toBe("google-docs-refresh-token");
   });
 
+  it("starts a Google Calendar OAuth broker session with shared Google client id", async () => {
+    const response = await app.request("/v1/oauth/google-calendar/start", { method: "POST" }, env);
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as StartResponse;
+    expect(body.connector).toBe("google-calendar");
+    expect(body.client_id).toBe("google-client-id");
+    const authorizationUrl = new URL(body.authorization_url);
+    expect(`${authorizationUrl.origin}${authorizationUrl.pathname}`).toBe(
+      "https://accounts.example.test/o/oauth2/v2/auth"
+    );
+    expect(authorizationUrl.searchParams.get("client_id")).toBe("google-client-id");
+    expect(authorizationUrl.searchParams.get("response_type")).toBe("code");
+    expect(authorizationUrl.searchParams.get("redirect_uri")).toBe(
+      "http://localhost:8757/oauth/google-calendar/callback"
+    );
+    expect(authorizationUrl.searchParams.get("scope")?.split(" ").sort()).toEqual(
+      [
+        "openid",
+        "email",
+        "profile",
+        "https://www.googleapis.com/auth/calendar.events"
+      ].sort()
+    );
+    expect(authorizationUrl.searchParams.get("access_type")).toBe("offline");
+    expect(authorizationUrl.searchParams.get("prompt")).toBe("consent");
+    expect(authorizationUrl.searchParams.get("include_granted_scopes")).toBe("true");
+    expect(body.redirect_uri).toBe("http://localhost:8757/oauth/google-calendar/callback");
+    expect(body.session).toBeTruthy();
+    expect(body.state).toBeTruthy();
+  });
+
+  it("exchanges a Google Calendar authorization code without exposing the raw refresh token in handle mode", async () => {
+    const start = await startGoogleCalendarSession();
+    const fetchMock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) =>
+      Response.json({
+        access_token: "calendar-access-token",
+        refresh_token: "calendar-refresh-token",
+        token_type: "Bearer",
+        expires_in: 3600,
+        scope: "openid email profile https://www.googleapis.com/auth/calendar.events",
+        id_token: "calendar-id-token"
+      })
+    );
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    const response = await app.request(
+      "/v1/oauth/google-calendar/exchange",
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          session: start.session,
+          state: start.state,
+          code: "authorization-code",
+          redirect_uri: "http://localhost:8757/oauth/google-calendar/callback"
+        })
+      },
+      env
+    );
+
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as BrokerTokenResponse;
+    expect(body.connector).toBe("google-calendar");
+    expect(body.access_token).toBe("calendar-access-token");
+    expect(body.scope).toBe("openid email profile https://www.googleapis.com/auth/calendar.events");
+    expect(body.id_token).toBe("calendar-id-token");
+    expect(body.workspace_id).toBe("primary");
+    expect(body.workspace_name).toBe("Primary calendar");
+    expect(body.refresh_token).toBeUndefined();
+    expect(body.refresh_token_kind).toBe("handle");
+    expect(body.refresh_token_handle).toMatch(/^locrh_v1\./);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://oauth2.example.test/token",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/x-www-form-urlencoded"
+        })
+      })
+    );
+    const requestBody = new URLSearchParams((fetchMock.mock.calls[0]?.[1] as RequestInit).body as string);
+    expect(requestBody.get("client_id")).toBe("google-client-id");
+    expect(requestBody.get("client_secret")).toBe("google-client-secret");
+    expect(requestBody.get("grant_type")).toBe("authorization_code");
+    expect(requestBody.get("code")).toBe("authorization-code");
+    expect(requestBody.get("redirect_uri")).toBe("http://localhost:8757/oauth/google-calendar/callback");
+  });
+
   it("creates a Gmail OAuth session and authorization URL", async () => {
     const response = await app.request("/v1/oauth/gmail/start", { method: "POST" }, env);
     expect(response.status).toBe(200);
@@ -560,6 +660,12 @@ async function startGoogleDocsSession() {
   return response.json() as Promise<StartResponse>;
 }
 
+async function startGoogleCalendarSession() {
+  const response = await app.request("/v1/oauth/google-calendar/start", { method: "POST" }, env);
+  expect(response.status).toBe(200);
+  return response.json() as Promise<StartResponse>;
+}
+
 async function startGmailSession() {
   const response = await app.request("/v1/oauth/gmail/start", { method: "POST" }, env);
   expect(response.status).toBe(200);
diff --git a/apps/oauth-service/test/google-calendar.test.ts b/apps/oauth-service/test/google-calendar.test.ts
new file mode 100644
index 00000000..192be7e6
--- /dev/null
+++ b/apps/oauth-service/test/google-calendar.test.ts
@@ -0,0 +1,224 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import app from "../src/app";
+import type { BrokerEnv } from "../src/types";
+
+interface StartResponse {
+  connector: string;
+  client_id: string;
+  authorization_url: string;
+  redirect_uri: string;
+  session: string;
+  state: string;
+}
+
+interface BrokerTokenResponse {
+  connector: string;
+  access_token: string;
+  scope?: string;
+  id_token?: string;
+  workspace_id?: string;
+  workspace_name?: string;
+  refresh_token?: string;
+  refresh_token_kind?: string;
+  refresh_token_handle?: string;
+}
+
+const env: BrokerEnv = {
+  LOCALITY_BROKER_SESSION_SECRET: "test-session-secret-with-enough-entropy",
+  LOCALITY_REFRESH_HANDLE_KEY: "test-refresh-handle-key-with-enough-entropy",
+  LOCALITY_TOKEN_MODE: "handle",
+  LOCALITY_NOTION_CLIENT_ID: "notion-client-id",
+  LOCALITY_NOTION_CLIENT_SECRET: "notion-client-secret",
+  LOCALITY_GOOGLE_CLIENT_ID: "google-client-id",
+  LOCALITY_GOOGLE_CLIENT_SECRET: "google-client-secret",
+  LOCALITY_GOOGLE_CALENDAR_API_BASE_URL: "https://oauth2.example.test",
+  LOCALITY_GOOGLE_CALENDAR_AUTH_BASE_URL: "https://accounts.example.test",
+  LOCALITY_GOOGLE_CALENDAR_REDIRECT_URIS: "http://localhost:8757/oauth/google-calendar/callback"
+};
+
+describe("Google Calendar OAuth broker", () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-06-11T12:00:00Z"));
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("publishes Google Calendar in broker discovery", async () => {
+    const response = await app.request("/.well-known/loc-auth-broker", { method: "GET" }, env);
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      connectors: {
+        "google-calendar": {
+          oauth: "brokered_confidential",
+          session_ttl_seconds: 600,
+          refresh_token_modes: ["handle"]
+        }
+      }
+    });
+  });
+
+  it("starts a Google Calendar OAuth broker session with shared Google client id", async () => {
+    const response = await app.request("/v1/oauth/google-calendar/start", { method: "POST" }, env);
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as StartResponse;
+    expect(body.connector).toBe("google-calendar");
+    expect(body.client_id).toBe("google-client-id");
+    const authorizationUrl = new URL(body.authorization_url);
+    expect(`${authorizationUrl.origin}${authorizationUrl.pathname}`).toBe(
+      "https://accounts.example.test/o/oauth2/v2/auth"
+    );
+    expect(authorizationUrl.searchParams.get("client_id")).toBe("google-client-id");
+    expect(authorizationUrl.searchParams.get("response_type")).toBe("code");
+    expect(authorizationUrl.searchParams.get("redirect_uri")).toBe(
+      "http://localhost:8757/oauth/google-calendar/callback"
+    );
+    expect(authorizationUrl.searchParams.get("scope")?.split(" ").sort()).toEqual(
+      [
+        "openid",
+        "email",
+        "profile",
+        "https://www.googleapis.com/auth/calendar.events"
+      ].sort()
+    );
+    expect(authorizationUrl.searchParams.get("access_type")).toBe("offline");
+    expect(authorizationUrl.searchParams.get("prompt")).toBe("consent");
+    expect(authorizationUrl.searchParams.get("include_granted_scopes")).toBe("true");
+    expect(body.redirect_uri).toBe("http://localhost:8757/oauth/google-calendar/callback");
+    expect(body.session).toBeTruthy();
+    expect(body.state).toBeTruthy();
+  });
+
+  it("exchanges a Google Calendar authorization code without exposing the raw refresh token in handle mode", async () => {
+    const start = await startGoogleCalendarSession();
+    const fetchMock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) =>
+      Response.json({
+        access_token: "calendar-access-token",
+        refresh_token: "calendar-refresh-token",
+        token_type: "Bearer",
+        expires_in: 3600,
+        scope: "openid email profile https://www.googleapis.com/auth/calendar.events",
+        id_token: "calendar-id-token"
+      })
+    );
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    const response = await app.request(
+      "/v1/oauth/google-calendar/exchange",
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          session: start.session,
+          state: start.state,
+          code: "authorization-code",
+          redirect_uri: "http://localhost:8757/oauth/google-calendar/callback"
+        })
+      },
+      env
+    );
+
+    expect(response.status).toBe(200);
+    const body = (await response.json()) as BrokerTokenResponse;
+    expect(body.connector).toBe("google-calendar");
+    expect(body.access_token).toBe("calendar-access-token");
+    expect(body.scope).toBe("openid email profile https://www.googleapis.com/auth/calendar.events");
+    expect(body.id_token).toBe("calendar-id-token");
+    expect(body.workspace_id).toBe("primary");
+    expect(body.workspace_name).toBe("Primary calendar");
+    expect(body.refresh_token).toBeUndefined();
+    expect(body.refresh_token_kind).toBe("handle");
+    expect(body.refresh_token_handle).toMatch(/^locrh_v1\./);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://oauth2.example.test/token",
+      expect.objectContaining({
+        method: "POST",
+        headers: expect.objectContaining({
+          "Content-Type": "application/x-www-form-urlencoded"
+        })
+      })
+    );
+    const requestBody = new URLSearchParams((fetchMock.mock.calls[0]?.[1] as RequestInit).body as string);
+    expect(requestBody.get("client_id")).toBe("google-client-id");
+    expect(requestBody.get("client_secret")).toBe("google-client-secret");
+    expect(requestBody.get("grant_type")).toBe("authorization_code");
+    expect(requestBody.get("code")).toBe("authorization-code");
+    expect(requestBody.get("redirect_uri")).toBe("http://localhost:8757/oauth/google-calendar/callback");
+  });
+
+  it("refreshes Google Calendar credentials through an opaque refresh handle", async () => {
+    const start = await startGoogleCalendarSession();
+    let calls = 0;
+    const fetchMock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => {
+      calls += 1;
+      if (calls === 1) {
+        return Response.json({
+          access_token: "calendar-access-token",
+          refresh_token: "calendar-refresh-token",
+          expires_in: 3600,
+          scope: "openid email profile https://www.googleapis.com/auth/calendar.events",
+          id_token: "calendar-id-token"
+        });
+      }
+      return Response.json({
+        access_token: "new-calendar-access-token",
+        refresh_token: "new-calendar-refresh-token",
+        expires_in: 3600,
+        scope: "openid email profile https://www.googleapis.com/auth/calendar.events"
+      });
+    });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+    const exchanged = await app.request(
+      "/v1/oauth/google-calendar/exchange",
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          session: start.session,
+          state: start.state,
+          code: "authorization-code",
+          redirect_uri: "http://localhost:8757/oauth/google-calendar/callback"
+        })
+      },
+      env
+    );
+    expect(exchanged.status).toBe(200);
+    const exchangeBody = (await exchanged.json()) as BrokerTokenResponse;
+
+    const refreshed = await app.request(
+      "/v1/oauth/google-calendar/refresh",
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ refresh_token_handle: exchangeBody.refresh_token_handle })
+      },
+      env
+    );
+
+    expect(refreshed.status).toBe(200);
+    const refreshBody = (await refreshed.json()) as BrokerTokenResponse;
+    expect(refreshBody.connector).toBe("google-calendar");
+    expect(refreshBody.access_token).toBe("new-calendar-access-token");
+    expect(refreshBody.refresh_token).toBeUndefined();
+    expect(refreshBody.refresh_token_kind).toBe("handle");
+    expect(refreshBody.refresh_token_handle).toMatch(/^locrh_v1\./);
+    const refreshRequest = new URLSearchParams((fetchMock.mock.calls[1]?.[1] as RequestInit).body as string);
+    expect(refreshRequest.get("client_id")).toBe("google-client-id");
+    expect(refreshRequest.get("client_secret")).toBe("google-client-secret");
+    expect(refreshRequest.get("grant_type")).toBe("refresh_token");
+    expect(refreshRequest.get("refresh_token")).toBe("calendar-refresh-token");
+  });
+});
+
+async function startGoogleCalendarSession() {
+  const response = await app.request("/v1/oauth/google-calendar/start", { method: "POST" }, env);
+  expect(response.status).toBe(200);
+  return response.json() as Promise<StartResponse>;
+}
diff --git a/crates/loc-cli/Cargo.toml b/crates/loc-cli/Cargo.toml
index ab37a742..3532ba69 100644
--- a/crates/loc-cli/Cargo.toml
+++ b/crates/loc-cli/Cargo.toml
@@ -22,6 +22,7 @@ locality-store.workspace = true
 locality-notion.workspace = true
 locality-gmail.workspace = true
 locality-granola.workspace = true
+locality-google-calendar.workspace = true
 locality-linear.workspace = true
 locality-google-docs.workspace = true
 localityd = { path = "../localityd" }
diff --git a/crates/loc-cli/src/commands.rs b/crates/loc-cli/src/commands.rs
index bb3c92ec..3d5dd114 100644
--- a/crates/loc-cli/src/commands.rs
+++ b/crates/loc-cli/src/commands.rs
@@ -21,6 +21,10 @@ use locality_gmail::{
     DEFAULT_GMAIL_OAUTH_BROKER_URL, DEFAULT_GMAIL_OAUTH_REDIRECT_URI, GMAIL_CONNECTOR_ID,
     GmailMountSettings, GmailProjectionView, HttpGmailOAuthBrokerClient,
 };
+use locality_google_calendar::{
+    DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL, DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+    GOOGLE_CALENDAR_CONNECTOR_ID, GoogleCalendarMountSettings, HttpGoogleCalendarOAuthBrokerClient,
+};
 use locality_google_docs::{
     DEFAULT_GOOGLE_DOCS_OAUTH_BROKER_URL, DEFAULT_GOOGLE_DOCS_OAUTH_REDIRECT_URI,
     GOOGLE_DOCS_CONNECTOR_ID, HttpGoogleDocsOAuthBrokerClient,
@@ -59,11 +63,12 @@ use serde_json::Value;
 use crate::connect::{
     BrokerOAuthConnectOptions, ConnectError, ConnectOptions, ConnectReport, ConnectionShowReport,
     ConnectionsReport, DisconnectReport, GmailBrokerOAuthConnectOptions,
-    GoogleDocsBrokerOAuthConnectOptions, HttpGranolaConnectionProbe, HttpLinearConnectionProbe,
-    HttpNotionConnectionProbe, OAuthConnectOptions, ProfilesReport, run_connect_gmail_broker_oauth,
-    run_connect_google_docs_broker_oauth, run_connect_granola, run_connect_linear,
-    run_connect_notion, run_connect_notion_broker_oauth, run_connect_notion_oauth,
-    run_connection_show, run_connections, run_disconnect, run_profiles,
+    GoogleCalendarBrokerOAuthConnectOptions, GoogleDocsBrokerOAuthConnectOptions,
+    HttpGranolaConnectionProbe, HttpLinearConnectionProbe, HttpNotionConnectionProbe,
+    OAuthConnectOptions, ProfilesReport, run_connect_gmail_broker_oauth,
+    run_connect_google_calendar_broker_oauth, run_connect_google_docs_broker_oauth,
+    run_connect_granola, run_connect_linear, run_connect_notion, run_connect_notion_broker_oauth,
+    run_connect_notion_oauth, run_connection_show, run_connections, run_disconnect, run_profiles,
 };
 use crate::connector::{
     ConnectorResolveError, SourceDescriptor, resolve_notion_connector_for_mount,
@@ -229,6 +234,8 @@ enum ConnectCommand {
     Notion(ConnectNotionArgs),
     #[command(name = "google-docs", about = "Connect Google Docs")]
     GoogleDocs(ConnectGoogleDocsArgs),
+    #[command(name = "google-calendar", about = "Connect Google Calendar")]
+    GoogleCalendar(ConnectGoogleCalendarArgs),
     #[command(about = "Connect Gmail")]
     Gmail(ConnectGmailArgs),
     #[command(about = "Connect Granola with an API key")]
@@ -328,6 +335,26 @@ struct ConnectGmailArgs {
     redirect_uri: Option<String>,
 }
 
+#[derive(Debug, Args)]
+struct ConnectGoogleCalendarArgs {
+    #[arg(
+        long,
+        value_name = "ID",
+        help = "Connection id to save. Defaults to google-calendar-default."
+    )]
+    name: Option<String>,
+    #[arg(long, help = "Print the OAuth URL instead of opening a browser.")]
+    no_browser: bool,
+    #[arg(long, value_name = "URL", help = "OAuth broker base URL.")]
+    broker_url: Option<String>,
+    #[arg(
+        long,
+        value_name = "URI",
+        help = "OAuth redirect URI for the local callback listener."
+    )]
+    redirect_uri: Option<String>,
+}
+
 #[derive(Debug, Subcommand)]
 enum ConnectionCommand {
     #[command(about = "Show connection details")]
@@ -407,6 +434,8 @@ enum MountCommand {
     Notion(MountNotionArgs),
     #[command(name = "google-docs", about = "Mount Google Docs content")]
     GoogleDocs(MountGoogleDocsArgs),
+    #[command(name = "google-calendar", about = "Mount Google Calendar")]
+    GoogleCalendar(MountGoogleCalendarArgs),
     #[command(about = "Mount Gmail")]
     Gmail(MountGmailArgs),
     #[command(about = "Mount Granola meeting notes read-only")]
@@ -577,6 +606,46 @@ struct MountGmailArgs {
     view: Option<String>,
 }
 
+#[derive(Debug, Args)]
+struct MountGoogleCalendarArgs {
+    #[arg(
+        value_name = "path",
+        help = "Local directory where the Google Calendar mount should be registered."
+    )]
+    path: String,
+    #[arg(long, value_name = "id", help = "Connection id to use for this mount.")]
+    connection: Option<String>,
+    #[arg(
+        long,
+        value_name = "id",
+        help = "Mount id to save. Defaults to google-calendar-main."
+    )]
+    mount_id: Option<String>,
+    #[arg(
+        long,
+        value_name = "mode",
+        help = "Projection mode. Supported values depend on the host platform."
+    )]
+    projection: Option<String>,
+    #[arg(
+        long,
+        help = "Register the mount as read-only and block push operations."
+    )]
+    read_only: bool,
+    #[arg(
+        long,
+        value_name = "YYYY-MM-DD",
+        help = "Fetch Google Calendar events on or after this date. Must be paired with --before."
+    )]
+    after: Option<String>,
+    #[arg(
+        long,
+        value_name = "YYYY-MM-DD",
+        help = "Fetch Google Calendar events before this date. Must be paired with --after."
+    )]
+    before: Option<String>,
+}
+
 #[derive(Debug, Args)]
 struct PathArg {
     #[arg(
@@ -1008,6 +1077,21 @@ fn legacy_args_for_command(command: &LocalityCommand) -> Vec<String> {
                         options.redirect_uri.as_deref(),
                     );
                 }
+                ConnectCommand::GoogleCalendar(options) => {
+                    args.push("google-calendar".to_string());
+                    push_optional_flag_value(&mut args, "--name", options.name.as_deref());
+                    push_flag(&mut args, "--no-browser", options.no_browser);
+                    push_optional_flag_value(
+                        &mut args,
+                        "--broker-url",
+                        options.broker_url.as_deref(),
+                    );
+                    push_optional_flag_value(
+                        &mut args,
+                        "--redirect-uri",
+                        options.redirect_uri.as_deref(),
+                    );
+                }
                 ConnectCommand::Gmail(options) => {
                     args.push("gmail".to_string());
                     push_optional_flag_value(&mut args, "--name", options.name.as_deref());
@@ -1118,6 +1202,24 @@ fn legacy_args_for_command(command: &LocalityCommand) -> Vec<String> {
                     );
                     push_flag(&mut args, "--read-only", options.read_only);
                 }
+                MountCommand::GoogleCalendar(options) => {
+                    args.push("google-calendar".to_string());
+                    args.push(options.path.clone());
+                    push_optional_flag_value(
+                        &mut args,
+                        "--connection",
+                        options.connection.as_deref(),
+                    );
+                    push_optional_flag_value(&mut args, "--mount-id", options.mount_id.as_deref());
+                    push_optional_flag_value(
+                        &mut args,
+                        "--projection",
+                        options.projection.as_deref(),
+                    );
+                    push_optional_flag_value(&mut args, "--after", options.after.as_deref());
+                    push_optional_flag_value(&mut args, "--before", options.before.as_deref());
+                    push_flag(&mut args, "--read-only", options.read_only);
+                }
                 MountCommand::Gmail(options) => {
                     args.push("gmail".to_string());
                     args.push(options.path.clone());
@@ -1501,6 +1603,9 @@ fn connect(args: &[String], json: bool) -> i32 {
     if connector == Some(GMAIL_CONNECTOR_ID) {
         return connect_gmail(args, json);
     }
+    if connector == Some(GOOGLE_CALENDAR_CONNECTOR_ID) {
+        return connect_google_calendar(args, json);
+    }
     if connector == Some(GOOGLE_DOCS_CONNECTOR_ID) {
         return connect_google_docs(args, json);
     }
@@ -1510,7 +1615,7 @@ fn connect(args: &[String], json: bool) -> i32 {
             CommandError::new(
                 "connect",
                 "usage",
-                "usage: loc connect <notion|google-docs|gmail|granola|linear> [options] [--json]",
+                "usage: loc connect <notion|google-docs|google-calendar|gmail|granola|linear> [options] [--json]",
             ),
             EXIT_USAGE,
         );
@@ -1820,6 +1925,86 @@ fn connect_google_docs(args: &[String], json: bool) -> i32 {
     }
 }
 
+fn connect_google_calendar(args: &[String], json: bool) -> i32 {
+    let state_root = default_state_root();
+    let mut store = match SqliteStateStore::open(state_root.clone()) {
+        Ok(store) => store,
+        Err(error) => {
+            return command_error(
+                json,
+                CommandError::new("connect", "store_open_failed", error.to_string()),
+                EXIT_INTERNAL,
+            );
+        }
+    };
+    let credentials = open_credential_store(&state_root);
+    let broker_config = match google_calendar_oauth_broker_config(args) {
+        Ok(config) => config,
+        Err(error) => return command_error(json, error, EXIT_INTERNAL),
+    };
+    let broker = HttpGoogleCalendarOAuthBrokerClient::new(broker_config.broker_url.clone());
+    let start = match broker.start(&OAuthBrokerStart {
+        connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+        redirect_uri: broker_config.redirect_uri,
+    }) {
+        Ok(start) => start,
+        Err(error) => {
+            return command_error(
+                json,
+                CommandError::new(
+                    "connect",
+                    "oauth_broker_start_failed",
+                    format!("Google Calendar OAuth broker start failed: {error}"),
+                )
+                .with_suggested_command("loc connect google-calendar"),
+                EXIT_INTERNAL,
+            );
+        }
+    };
+    let authorization = match run_local_oauth_authorization(
+        "Google Calendar",
+        &start.authorization_url,
+        &start.redirect_uri,
+        &start.state,
+        has_flag(args, "--no-browser"),
+        json,
+    ) {
+        Ok(authorization) => authorization,
+        Err(error) => {
+            return command_error(
+                json,
+                google_calendar_local_oauth_command_error(error),
+                EXIT_INTERNAL,
+            );
+        }
+    };
+    let options = GoogleCalendarBrokerOAuthConnectOptions {
+        connection_id: flag_value(args, "--name").map(ConnectionId::new),
+        broker_url: broker_config.broker_url,
+        client_id: start.client_id,
+        session: start.session,
+        state: start.state,
+        code: authorization.code,
+        redirect_uri: start.redirect_uri,
+    };
+    match run_connect_google_calendar_broker_oauth(
+        &mut store,
+        credentials.as_ref(),
+        options,
+        &broker,
+    ) {
+        Ok(report) if json => {
+            print_json(&report);
+            EXIT_SUCCESS
+        }
+        Ok(report) => {
+            print_connect_report(&report);
+            EXIT_SUCCESS
+        }
+        Err(error) => connect_command_error("connect", json, error),
+    }
+}
+
 fn connect_gmail(args: &[String], json: bool) -> i32 {
     let state_root = default_state_root();
     let mut store = match SqliteStateStore::open(state_root.clone()) {
@@ -2705,13 +2890,16 @@ fn mount(args: &[String], json: bool) -> i32 {
             );
         }
     };
-    let settings_json = if descriptor.id() == GMAIL_CONNECTOR_ID {
-        match gmail_mount_settings_json(args) {
+    let settings_json = match descriptor.id() {
+        GMAIL_CONNECTOR_ID => match gmail_mount_settings_json(args) {
             Ok(settings_json) => settings_json,
             Err(error) => return command_error(json, error, EXIT_USAGE),
-        }
-    } else {
-        "{}".to_string()
+        },
+        GOOGLE_CALENDAR_CONNECTOR_ID => match google_calendar_mount_settings_json(args) {
+            Ok(settings_json) => settings_json,
+            Err(error) => return command_error(json, error, EXIT_USAGE),
+        },
+        _ => "{}".to_string(),
     };
 
     let state_root = default_state_root();
@@ -2842,6 +3030,41 @@ fn gmail_mount_settings_json(args: &[String]) -> Result<String, CommandError> {
     })
 }
 
+fn google_calendar_mount_settings_json(args: &[String]) -> Result<String, CommandError> {
+    let after = flag_value(args, "--after");
+    let before = flag_value(args, "--before");
+
+    if after.is_none() && before.is_none() {
+        return Ok("{}".to_string());
+    }
+
+    let settings = match (after, before) {
+        (Some(after), Some(before)) => GoogleCalendarMountSettings::with_date_window(after, before)
+            .map_err(|error| {
+                CommandError::new(
+                    "mount",
+                    "google_calendar_date_window_invalid",
+                    locality_error_message(error),
+                )
+            })?,
+        _ => {
+            return Err(CommandError::new(
+                "mount",
+                "google_calendar_date_window_requires_after_and_before",
+                "Google Calendar date windows require both --after and --before",
+            ));
+        }
+    };
+
+    settings.to_json().map_err(|error| {
+        CommandError::new(
+            "mount",
+            "google_calendar_settings_encode_failed",
+            error.to_string(),
+        )
+    })
+}
+
 fn locality_error_message(error: LocalityError) -> String {
     match error {
         LocalityError::Validation(issues) => issues
@@ -2954,6 +3177,19 @@ fn mount_remote_root_id(
             }
             Ok(None)
         }
+        GOOGLE_CALENDAR_CONNECTOR_ID => {
+            if has_flag(args, "--workspace")
+                || flag_value(args, "--root-page").is_some()
+                || flag_value(args, "--workspace-folder").is_some()
+            {
+                return Err(CommandError::new(
+                    "mount",
+                    "usage",
+                    "loc mount google-calendar does not accept Notion or Google Docs root flags",
+                ));
+            }
+            Ok(None)
+        }
         GRANOLA_CONNECTOR_ID => {
             if has_flag(args, "--workspace")
                 || flag_value(args, "--root-page").is_some()
@@ -6908,6 +7144,12 @@ struct GoogleDocsOAuthBrokerCliConfig {
     redirect_uri: String,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct GoogleCalendarOAuthBrokerCliConfig {
+    broker_url: String,
+    redirect_uri: String,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 struct GmailOAuthBrokerCliConfig {
     broker_url: String,
@@ -7029,6 +7271,34 @@ fn gmail_oauth_broker_config(args: &[String]) -> Result<GmailOAuthBrokerCliConfi
     })
 }
 
+fn google_calendar_oauth_broker_config(
+    args: &[String],
+) -> Result<GoogleCalendarOAuthBrokerCliConfig, CommandError> {
+    let broker_url = flag_value(args, "--broker-url")
+        .map(str::to_string)
+        .or_else(|| {
+            env_first(&[
+                "LOCALITY_GOOGLE_CALENDAR_OAUTH_BROKER_URL",
+                "LOCALITY_AUTH_BROKER_URL",
+            ])
+        })
+        .unwrap_or_else(|| DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL.to_string());
+    let redirect_uri = flag_value(args, "--redirect-uri")
+        .map(str::to_string)
+        .or_else(|| env_first(&["LOCALITY_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI"]))
+        .unwrap_or_else(|| DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string());
+
+    local_redirect(&redirect_uri).map_err(|error| {
+        CommandError::new("connect", error.code, error.message)
+            .with_suggested_command("loc connect google-calendar")
+    })?;
+
+    Ok(GoogleCalendarOAuthBrokerCliConfig {
+        broker_url,
+        redirect_uri,
+    })
+}
+
 fn missing_oauth_config(name: &str) -> CommandError {
     CommandError::new(
         "connect",
@@ -7113,6 +7383,15 @@ fn gmail_local_oauth_command_error(error: LocalOAuthError) -> CommandError {
     }
 }
 
+fn google_calendar_local_oauth_command_error(error: LocalOAuthError) -> CommandError {
+    let command_error = CommandError::new("connect", error.code, error.message);
+    if command_error.code == "invalid_redirect_uri" {
+        command_error.with_suggested_command("loc connect google-calendar")
+    } else {
+        command_error
+    }
+}
+
 fn warn_daemon_fallback(command: &str, reason: DaemonUnavailableReason) {
     if std::env::var("LOCALITY_DAEMON_DISABLE").is_err() {
         match reason {
@@ -7907,7 +8186,7 @@ fn projection_mode_for_target(args: &[String], target_os: &str) -> Result<Projec
 
 fn mount_usage() -> String {
     format!(
-        "usage: loc mount notion <path> (--workspace|--root-page <page-id>) [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]\n       loc mount google-docs <path> --workspace-folder <name-or-id> [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]\n       loc mount gmail <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--after YYYY-MM-DD --before YYYY-MM-DD] [--view messages|threads] [--read-only] [--json]\n       loc mount granola <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--json]\n       loc mount linear <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]",
+        "usage: loc mount notion <path> (--workspace|--root-page <page-id>) [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]\n       loc mount google-docs <path> --workspace-folder <name-or-id> [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]\n       loc mount google-calendar <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--after YYYY-MM-DD --before YYYY-MM-DD] [--read-only] [--json]\n       loc mount gmail <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--after YYYY-MM-DD --before YYYY-MM-DD] [--view messages|threads] [--read-only] [--json]\n       loc mount granola <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--json]\n       loc mount linear <path> [--connection <id>] [--mount-id <id>] [--projection {0}] [--read-only] [--json]",
         projection_usage_options_for_target(std::env::consts::OS)
     )
 }
@@ -8112,6 +8391,10 @@ fn takes_value(arg: &str) -> bool {
             | "--connection"
             | "--name"
             | "--projection"
+            | "--workspace-folder"
+            | "--after"
+            | "--before"
+            | "--view"
             | "--helper"
             | "--display-name"
             | "--redirect-uri"
@@ -8415,6 +8698,7 @@ mod tests {
                     "Commands:",
                     "notion",
                     "google-docs",
+                    "google-calendar",
                     "gmail",
                     "granola",
                     "linear",
@@ -8439,6 +8723,15 @@ mod tests {
                     "--redirect-uri",
                 ],
             ),
+            (
+                vec!["connect", "google-calendar", "--help"],
+                vec![
+                    "Usage: loc connect google-calendar",
+                    "Connect Google Calendar",
+                    "--broker-url",
+                    "--redirect-uri",
+                ],
+            ),
             (
                 vec!["connect", "gmail", "--help"],
                 vec![
@@ -8533,6 +8826,7 @@ mod tests {
                     "Commands:",
                     "notion",
                     "google-docs",
+                    "google-calendar",
                     "gmail",
                     "granola",
                     "linear",
@@ -8556,6 +8850,17 @@ mod tests {
                     "--workspace-folder",
                 ],
             ),
+            (
+                vec!["mount", "google-calendar", "--help"],
+                vec![
+                    "Usage: loc mount google-calendar",
+                    "Mount Google Calendar",
+                    "--connection",
+                    "--projection",
+                    "--after",
+                    "--before",
+                ],
+            ),
             (
                 vec!["mount", "gmail", "--help"],
                 vec![
@@ -8845,9 +9150,10 @@ mod tests {
     }
 
     #[test]
-    fn mount_usage_mentions_gmail_settings_flags() {
+    fn mount_usage_mentions_google_mail_and_calendar_settings_flags() {
         let usage = mount_usage();
 
+        assert!(usage.contains("loc mount google-calendar"));
         assert!(usage.contains("--after YYYY-MM-DD --before YYYY-MM-DD"));
         assert!(usage.contains("--view messages|threads"));
         assert!(usage.contains("loc mount linear <path>"));
@@ -8945,6 +9251,32 @@ mod tests {
             ]
         );
 
+        let cli = parse_cli([
+            "connect",
+            "google-calendar",
+            "--name",
+            "calendar-work",
+            "--no-browser",
+            "--broker-url",
+            "https://auth.example.test",
+            "--redirect-uri",
+            "http://localhost:8757/oauth/google-calendar/callback",
+        ]);
+        assert_eq!(
+            legacy_args_for_command(cli.command.as_ref().expect("command")),
+            vec![
+                "connect",
+                "google-calendar",
+                "--name",
+                "calendar-work",
+                "--no-browser",
+                "--broker-url",
+                "https://auth.example.test",
+                "--redirect-uri",
+                "http://localhost:8757/oauth/google-calendar/callback"
+            ]
+        );
+
         let cli = parse_cli([
             "mount",
             "gmail",
@@ -8973,6 +9305,42 @@ mod tests {
             ]
         );
 
+        let cli = parse_cli([
+            "mount",
+            "google-calendar",
+            "/tmp/Locality/calendar-main",
+            "--connection",
+            "calendar-work",
+            "--mount-id",
+            "calendar-main",
+            "--projection",
+            "plain-files",
+            "--after",
+            "2026-07-01",
+            "--before",
+            "2026-07-31",
+            "--read-only",
+        ]);
+        assert_eq!(
+            legacy_args_for_command(cli.command.as_ref().expect("command")),
+            vec![
+                "mount",
+                "google-calendar",
+                "/tmp/Locality/calendar-main",
+                "--connection",
+                "calendar-work",
+                "--mount-id",
+                "calendar-main",
+                "--projection",
+                "plain-files",
+                "--after",
+                "2026-07-01",
+                "--before",
+                "2026-07-31",
+                "--read-only"
+            ]
+        );
+
         let cli = parse_cli([
             "search",
             "initial",
diff --git a/crates/loc-cli/src/connect.rs b/crates/loc-cli/src/connect.rs
index 0f65584a..47e67a50 100644
--- a/crates/loc-cli/src/connect.rs
+++ b/crates/loc-cli/src/connect.rs
@@ -6,6 +6,13 @@ use locality_gmail::{
     GMAIL_CONNECTOR_ID, GMAIL_OAUTH_SCOPES, HttpGmailOAuthBrokerClient, StoredGmailCredential,
     gmail_capabilities_json, validate_gmail_oauth_scopes,
 };
+use locality_google_calendar::oauth::{
+    google_calendar_capabilities_json, validate_google_calendar_oauth_scopes,
+};
+use locality_google_calendar::{
+    GOOGLE_CALENDAR_CONNECTOR_ID, GOOGLE_CALENDAR_OAUTH_SCOPES,
+    HttpGoogleCalendarOAuthBrokerClient, StoredGoogleCalendarCredential,
+};
 use locality_google_docs::{
     GOOGLE_DOCS_CONNECTOR_ID, GOOGLE_DOCS_OAUTH_SCOPES, HttpGoogleDocsOAuthBrokerClient,
     StoredGoogleDocsCredential, google_docs_capabilities_json,
@@ -28,6 +35,7 @@ use serde::Serialize;
 pub const DEFAULT_NOTION_PROFILE_ID: &str = "notion-token-default";
 pub const DEFAULT_NOTION_OAUTH_PROFILE_ID: &str = "notion-oauth-default";
 pub const DEFAULT_GOOGLE_DOCS_OAUTH_PROFILE_ID: &str = "google-docs-oauth-default";
+pub const DEFAULT_GOOGLE_CALENDAR_OAUTH_PROFILE_ID: &str = "google-calendar-oauth-default";
 pub const DEFAULT_GMAIL_OAUTH_PROFILE_ID: &str = "gmail-oauth-default";
 pub const DEFAULT_GRANOLA_API_KEY_PROFILE_ID: &str = "granola-api-key-default";
 pub const DEFAULT_LINEAR_API_KEY_PROFILE_ID: &str = "linear-api-key-default";
@@ -80,6 +88,17 @@ pub struct GmailBrokerOAuthConnectOptions {
     pub redirect_uri: String,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct GoogleCalendarBrokerOAuthConnectOptions {
+    pub connection_id: Option<ConnectionId>,
+    pub broker_url: String,
+    pub client_id: String,
+    pub session: String,
+    pub state: String,
+    pub code: String,
+    pub redirect_uri: String,
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Serialize)]
 pub struct ConnectReport {
     pub ok: bool,
@@ -229,6 +248,13 @@ pub trait GmailOAuthBrokerExchange {
     ) -> Result<OAuthBrokerToken, ConnectError>;
 }
 
+pub trait GoogleCalendarOAuthBrokerExchange {
+    fn exchange_code(
+        &self,
+        request: &OAuthBrokerCodeExchange,
+    ) -> Result<OAuthBrokerToken, ConnectError>;
+}
+
 #[derive(Clone, Debug, Default)]
 pub struct HttpNotionConnectionProbe;
 
@@ -296,6 +322,19 @@ impl GmailOAuthBrokerExchange for HttpGmailOAuthBrokerClient {
     }
 }
 
+impl GoogleCalendarOAuthBrokerExchange for HttpGoogleCalendarOAuthBrokerClient {
+    fn exchange_code(
+        &self,
+        request: &OAuthBrokerCodeExchange,
+    ) -> Result<OAuthBrokerToken, ConnectError> {
+        HttpGoogleCalendarOAuthBrokerClient::exchange_code(self, request).map_err(|error| {
+            ConnectError::OAuthExchangeFailed(OAuthExchangeFailure::google_calendar(
+                error.to_string(),
+            ))
+        })
+    }
+}
+
 pub fn run_connect_notion<S, P>(
     store: &mut S,
     credentials: &dyn CredentialStore,
@@ -839,6 +878,102 @@ where
     })
 }
 
+pub fn run_connect_google_calendar_broker_oauth<S, E>(
+    store: &mut S,
+    credentials: &dyn CredentialStore,
+    options: GoogleCalendarBrokerOAuthConnectOptions,
+    exchange: &E,
+) -> Result<ConnectReport, ConnectError>
+where
+    S: ConnectionRepository + ConnectorProfileRepository,
+    E: GoogleCalendarOAuthBrokerExchange,
+{
+    let connection_id = match options.connection_id {
+        Some(connection_id) => connection_id,
+        None => default_connection_id_for_connector(
+            store,
+            GOOGLE_CALENDAR_CONNECTOR_ID,
+            "google-calendar-default",
+            "Google Calendar",
+        )?,
+    };
+    let exchange_request = OAuthBrokerCodeExchange {
+        connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+        session: options.session,
+        state: options.state,
+        code: options.code,
+        redirect_uri: options.redirect_uri,
+    };
+    let token = exchange.exchange_code(&exchange_request)?;
+    validate_google_calendar_oauth_scopes(&token.scopes).map_err(|error| {
+        ConnectError::OAuthExchangeFailed(OAuthExchangeFailure::google_calendar(error.to_string()))
+    })?;
+    let acquired_at = timestamp_secs();
+    let secret_ref = format!("connection:{}", connection_id.0);
+    let stored = StoredGoogleCalendarCredential::from_broker_token(
+        token.clone(),
+        options.client_id,
+        options.broker_url,
+        acquired_at,
+    );
+    let secret = serde_json::to_string(&stored).map_err(|error| {
+        ConnectError::CredentialEncode(CredentialEncodeFailure::google_calendar(error.to_string()))
+    })?;
+    credentials.put(&secret_ref, &secret).map_err(|error| {
+        ConnectError::Credential(CredentialStorageFailure::google_calendar(error))
+    })?;
+
+    let now = timestamp();
+    let profile_id = ConnectorProfileId::new(DEFAULT_GOOGLE_CALENDAR_OAUTH_PROFILE_ID);
+    store
+        .save_connector_profile(default_google_calendar_oauth_profile(now.clone()))
+        .map_err(ConnectError::Store)?;
+
+    let display_name = connection_id.0.clone();
+    let account_label = token
+        .account_label
+        .clone()
+        .or_else(|| token.account_id.clone())
+        .or_else(|| token.workspace_name.clone());
+    let connection = ConnectionRecord {
+        connection_id: connection_id.clone(),
+        profile_id: Some(profile_id.clone()),
+        connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+        display_name: display_name.clone(),
+        account_label: account_label.clone(),
+        workspace_id: token.workspace_id.clone(),
+        workspace_name: token.workspace_name.clone(),
+        auth_kind: "oauth".to_string(),
+        secret_ref,
+        scopes: token.scopes.clone(),
+        capabilities_json: google_calendar_capabilities_json().map_err(|error| {
+            ConnectError::CredentialEncode(CredentialEncodeFailure::google_calendar(
+                error.to_string(),
+            ))
+        })?,
+        status: "active".to_string(),
+        created_at: now.clone(),
+        updated_at: now,
+        expires_at: stored.expires_at.map(|expires_at| expires_at.to_string()),
+    };
+    store
+        .save_connection(connection)
+        .map_err(ConnectError::Store)?;
+
+    Ok(ConnectReport {
+        ok: true,
+        command: "connect",
+        connection_id: connection_id.0,
+        profile_id: profile_id.0,
+        connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+        display_name,
+        account_label,
+        workspace_id: token.workspace_id,
+        workspace_name: token.workspace_name,
+        auth_kind: "oauth".to_string(),
+    })
+}
+
 pub fn run_profiles<S>(store: &S) -> Result<ProfilesReport, ConnectError>
 where
     S: ConnectorProfileRepository,
@@ -936,6 +1071,7 @@ pub struct OAuthExchangeFailure {
 enum OAuthExchangeConnector {
     Notion,
     GoogleDocs,
+    GoogleCalendar,
     Gmail,
 }
 
@@ -961,10 +1097,18 @@ impl OAuthExchangeFailure {
         }
     }
 
+    pub fn google_calendar(message: impl Into<String>) -> Self {
+        Self {
+            connector: OAuthExchangeConnector::GoogleCalendar,
+            message: message.into(),
+        }
+    }
+
     fn connector_display_name(&self) -> &'static str {
         match self.connector {
             OAuthExchangeConnector::Notion => "Notion",
             OAuthExchangeConnector::GoogleDocs => "Google Docs",
+            OAuthExchangeConnector::GoogleCalendar => "Google Calendar",
             OAuthExchangeConnector::Gmail => "Gmail",
         }
     }
@@ -973,6 +1117,7 @@ impl OAuthExchangeFailure {
         match self.connector {
             OAuthExchangeConnector::Notion => "loc connect notion",
             OAuthExchangeConnector::GoogleDocs => "loc connect google-docs",
+            OAuthExchangeConnector::GoogleCalendar => "loc connect google-calendar",
             OAuthExchangeConnector::Gmail => "loc connect gmail",
         }
     }
@@ -994,6 +1139,7 @@ pub struct CredentialStorageFailure {
 enum CredentialFailureConnector {
     Notion,
     GoogleDocs,
+    GoogleCalendar,
     Gmail,
     Granola,
     Linear,
@@ -1012,6 +1158,10 @@ impl CredentialEncodeFailure {
         Self::new(CredentialFailureConnector::Gmail, message)
     }
 
+    pub fn google_calendar(message: impl Into<String>) -> Self {
+        Self::new(CredentialFailureConnector::GoogleCalendar, message)
+    }
+
     pub fn granola(message: impl Into<String>) -> Self {
         Self::new(CredentialFailureConnector::Granola, message)
     }
@@ -1053,6 +1203,10 @@ impl CredentialStorageFailure {
         Self::new(CredentialFailureConnector::Gmail, error)
     }
 
+    pub fn google_calendar(error: CredentialError) -> Self {
+        Self::new(CredentialFailureConnector::GoogleCalendar, error)
+    }
+
     pub fn granola(error: CredentialError) -> Self {
         Self::new(CredentialFailureConnector::Granola, error)
     }
@@ -1096,6 +1250,7 @@ impl CredentialFailureConnector {
     fn from_connector_id(connector: &str) -> Self {
         match connector {
             GOOGLE_DOCS_CONNECTOR_ID => Self::GoogleDocs,
+            GOOGLE_CALENDAR_CONNECTOR_ID => Self::GoogleCalendar,
             GMAIL_CONNECTOR_ID => Self::Gmail,
             GRANOLA_CONNECTOR_ID => Self::Granola,
             LINEAR_CONNECTOR_ID => Self::Linear,
@@ -1107,6 +1262,7 @@ impl CredentialFailureConnector {
         match self {
             Self::Notion => "Notion",
             Self::GoogleDocs => "Google Docs",
+            Self::GoogleCalendar => "Google Calendar",
             Self::Gmail => "Gmail",
             Self::Granola => "Granola",
             Self::Linear => "Linear",
@@ -1117,6 +1273,7 @@ impl CredentialFailureConnector {
         match self {
             Self::Notion => "loc connect notion",
             Self::GoogleDocs => "loc connect google-docs",
+            Self::GoogleCalendar => "loc connect google-calendar",
             Self::Gmail => "loc connect gmail",
             Self::Granola => "loc connect granola --api-key-stdin",
             Self::Linear => "loc connect linear --api-key-stdin",
@@ -1304,6 +1461,25 @@ fn default_gmail_oauth_profile(now: String) -> ConnectorProfileRecord {
     }
 }
 
+fn default_google_calendar_oauth_profile(now: String) -> ConnectorProfileRecord {
+    ConnectorProfileRecord {
+        profile_id: ConnectorProfileId::new(DEFAULT_GOOGLE_CALENDAR_OAUTH_PROFILE_ID),
+        connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+        display_name: "Google Calendar OAuth".to_string(),
+        auth_kind: "oauth".to_string(),
+        scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+            .iter()
+            .map(|scope| scope.to_string())
+            .collect(),
+        capabilities_json: google_calendar_capabilities_json().unwrap_or_else(|_| "{}".to_string()),
+        enabled_actions_json: "[\"read\",\"create\"]".to_string(),
+        connector_version: "google-calendar.v1".to_string(),
+        status: "active".to_string(),
+        created_at: now.clone(),
+        updated_at: now,
+    }
+}
+
 fn default_granola_api_key_profile(now: String) -> ConnectorProfileRecord {
     ConnectorProfileRecord {
         profile_id: ConnectorProfileId::new(DEFAULT_GRANOLA_API_KEY_PROFILE_ID),
diff --git a/crates/loc-cli/src/diff.rs b/crates/loc-cli/src/diff.rs
index 459e0d3b..79fa6cfc 100644
--- a/crates/loc-cli/src/diff.rs
+++ b/crates/loc-cli/src/diff.rs
@@ -553,6 +553,7 @@ pub enum PropertyValueOutput {
     Number(String),
     String(String),
     List(Vec<String>),
+    Array(Vec<PropertyValueOutput>),
     Object(Vec<PropertyUpdateOutput>),
 }
 
@@ -564,6 +565,9 @@ impl From<PropertyValue> for PropertyValueOutput {
             PropertyValue::Number(value) => Self::Number(value),
             PropertyValue::String(value) => Self::String(value),
             PropertyValue::List(value) => Self::List(value),
+            PropertyValue::Array(value) => {
+                Self::Array(value.into_iter().map(PropertyValueOutput::from).collect())
+            }
             PropertyValue::Object(value) => Self::Object(
                 value
                     .into_iter()
diff --git a/crates/loc-cli/tests/connect.rs b/crates/loc-cli/tests/connect.rs
index 2525c297..c3da6731 100644
--- a/crates/loc-cli/tests/connect.rs
+++ b/crates/loc-cli/tests/connect.rs
@@ -1,17 +1,21 @@
 use loc_cli::connect::{
     BrokerOAuthConnectOptions, ConnectOptions, CredentialEncodeFailure, CredentialStorageFailure,
-    DEFAULT_GMAIL_OAUTH_PROFILE_ID, DEFAULT_GOOGLE_DOCS_OAUTH_PROFILE_ID,
-    DEFAULT_LINEAR_API_KEY_PROFILE_ID, DEFAULT_NOTION_OAUTH_PROFILE_ID, DEFAULT_NOTION_PROFILE_ID,
-    GmailBrokerOAuthConnectOptions, GmailOAuthBrokerExchange, GoogleDocsBrokerOAuthConnectOptions,
+    DEFAULT_GMAIL_OAUTH_PROFILE_ID, DEFAULT_GOOGLE_CALENDAR_OAUTH_PROFILE_ID,
+    DEFAULT_GOOGLE_DOCS_OAUTH_PROFILE_ID, DEFAULT_LINEAR_API_KEY_PROFILE_ID,
+    DEFAULT_NOTION_OAUTH_PROFILE_ID, DEFAULT_NOTION_PROFILE_ID, GmailBrokerOAuthConnectOptions,
+    GmailOAuthBrokerExchange, GoogleCalendarBrokerOAuthConnectOptions,
+    GoogleCalendarOAuthBrokerExchange, GoogleDocsBrokerOAuthConnectOptions,
     GoogleDocsOAuthBrokerExchange, LinearConnectionProbe, NotionConnectionProbe,
     NotionConnectionProbeResult, NotionOAuthBrokerExchange, NotionOAuthExchange,
     OAuthConnectOptions, OAuthExchangeFailure, run_connect_gmail_broker_oauth,
-    run_connect_google_docs_broker_oauth, run_connect_linear, run_connect_notion,
-    run_connect_notion_broker_oauth, run_connect_notion_oauth, run_disconnect, run_profiles,
+    run_connect_google_calendar_broker_oauth, run_connect_google_docs_broker_oauth,
+    run_connect_linear, run_connect_notion, run_connect_notion_broker_oauth,
+    run_connect_notion_oauth, run_disconnect, run_profiles,
 };
 use locality_connector::ConnectorCapabilities;
 use locality_connector::oauth_broker::{OAuthBrokerCodeExchange, OAuthBrokerToken};
 use locality_gmail::{GMAIL_OAUTH_SCOPES, StoredGmailCredential};
+use locality_google_calendar::{GOOGLE_CALENDAR_OAUTH_SCOPES, StoredGoogleCalendarCredential};
 use locality_google_docs::{GOOGLE_DOCS_OAUTH_SCOPES, StoredGoogleDocsCredential};
 use locality_linear::LINEAR_CONNECTOR_ID;
 use locality_notion::oauth::{
@@ -369,6 +373,56 @@ fn connect_gmail_broker_oauth_stores_refresh_handle_without_secrets() {
     assert!(!json.contains("secret_ref"));
 }
 
+#[test]
+fn connect_google_calendar_broker_oauth_stores_refresh_handle_without_secrets() {
+    let mut store = InMemoryStateStore::new();
+    let credentials = InMemoryCredentialStore::new();
+    let exchange = FakeGoogleCalendarBrokerOAuthExchange;
+
+    let report = run_connect_google_calendar_broker_oauth(
+        &mut store,
+        &credentials,
+        GoogleCalendarBrokerOAuthConnectOptions {
+            connection_id: Some(ConnectionId::new("google-calendar-default")),
+            broker_url: "https://auth.example.test".to_string(),
+            client_id: "google-client-id".to_string(),
+            session: "broker-session".to_string(),
+            state: "state-1".to_string(),
+            code: "oauth-code".to_string(),
+            redirect_uri: "http://localhost:8757/oauth/google-calendar/callback".to_string(),
+        },
+        &exchange,
+    )
+    .expect("connect google calendar oauth");
+
+    assert_eq!(report.connection_id, "google-calendar-default");
+    assert_eq!(report.profile_id, DEFAULT_GOOGLE_CALENDAR_OAUTH_PROFILE_ID);
+    assert_eq!(report.connector, "google-calendar");
+    assert_eq!(report.auth_kind, "oauth");
+    assert_eq!(report.account_label.as_deref(), Some("user@example.com"));
+
+    let secret = credentials
+        .get("connection:google-calendar-default")
+        .expect("credential saved");
+    let stored =
+        serde_json::from_str::<StoredGoogleCalendarCredential>(&secret).expect("stored oauth");
+    assert_eq!(
+        stored.refresh_token_handle.as_deref(),
+        Some("opaque-refresh-handle")
+    );
+    assert_eq!(
+        stored.oauth_broker_url.as_deref(),
+        Some("https://auth.example.test")
+    );
+    assert_eq!(stored.oauth_client_id.as_deref(), Some("google-client-id"));
+
+    let json = serde_json::to_string(&report).expect("json");
+    assert!(!json.contains("oauth-access-token"));
+    assert!(!json.contains("opaque-refresh-handle"));
+    assert!(!json.contains("client-secret"));
+    assert!(!json.contains("secret_ref"));
+}
+
 #[test]
 fn connect_gmail_broker_oauth_accepts_worker_scope_string() {
     let mut store = InMemoryStateStore::new();
@@ -486,6 +540,53 @@ fn connect_gmail_broker_oauth_scope_validation_reports_gmail_guidance() {
     assert_eq!(error.suggested_command(), Some("loc connect gmail"));
 }
 
+#[test]
+fn connect_google_calendar_broker_oauth_rejects_missing_required_scope() {
+    let mut store = InMemoryStateStore::new();
+    let credentials = InMemoryCredentialStore::new();
+    let exchange = ScopedFakeGoogleCalendarBrokerOAuthExchange {
+        scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+            .iter()
+            .filter(|scope| **scope != "https://www.googleapis.com/auth/calendar.events")
+            .map(|scope| scope.to_string())
+            .collect(),
+    };
+
+    let error = run_connect_google_calendar_broker_oauth(
+        &mut store,
+        &credentials,
+        google_calendar_connect_options(),
+        &exchange,
+    )
+    .expect_err("missing Google Calendar events scope must be rejected");
+    let message = error.message();
+
+    assert_eq!(error.code(), "oauth_exchange_failed");
+    assert!(
+        message.starts_with("Google Calendar OAuth exchange failed: "),
+        "{message}"
+    );
+    assert!(
+        message.contains("https://www.googleapis.com/auth/calendar.events"),
+        "{message}"
+    );
+    assert_eq!(
+        error.suggested_command(),
+        Some("loc connect google-calendar")
+    );
+    assert!(
+        credentials
+            .get("connection:google-calendar-default")
+            .is_err()
+    );
+    assert!(
+        store
+            .get_connection(&ConnectionId::new("google-calendar-default"))
+            .expect("lookup connection")
+            .is_none()
+    );
+}
+
 #[test]
 fn connect_oauth_exchange_errors_report_connector_guidance() {
     let notion = loc_cli::connect::ConnectError::OAuthExchangeFailed(OAuthExchangeFailure::notion(
@@ -521,6 +622,20 @@ fn connect_oauth_exchange_errors_report_connector_guidance() {
     );
     assert!(!gmail_message.contains("Notion OAuth"));
     assert_eq!(gmail.suggested_command(), Some("loc connect gmail"));
+
+    let google_calendar = loc_cli::connect::ConnectError::OAuthExchangeFailed(
+        OAuthExchangeFailure::google_calendar("authorization code was rejected"),
+    );
+    let google_calendar_message = google_calendar.message();
+    assert_eq!(
+        google_calendar_message,
+        "Google Calendar OAuth exchange failed: authorization code was rejected"
+    );
+    assert!(!google_calendar_message.contains("Notion OAuth"));
+    assert_eq!(
+        google_calendar.suggested_command(),
+        Some("loc connect google-calendar")
+    );
 }
 
 #[test]
@@ -970,6 +1085,54 @@ impl GmailOAuthBrokerExchange for FakeGmailBrokerOAuthExchange {
     }
 }
 
+#[derive(Clone, Debug)]
+struct FakeGoogleCalendarBrokerOAuthExchange;
+
+impl GoogleCalendarOAuthBrokerExchange for FakeGoogleCalendarBrokerOAuthExchange {
+    fn exchange_code(
+        &self,
+        request: &OAuthBrokerCodeExchange,
+    ) -> Result<OAuthBrokerToken, loc_cli::connect::ConnectError> {
+        assert_eq!(request.connector, "google-calendar");
+        assert_eq!(request.session, "broker-session");
+        assert_eq!(request.state, "state-1");
+        assert_eq!(request.code, "oauth-code");
+        assert_eq!(
+            request.redirect_uri,
+            "http://localhost:8757/oauth/google-calendar/callback"
+        );
+        Ok(google_calendar_broker_token(
+            GOOGLE_CALENDAR_OAUTH_SCOPES
+                .iter()
+                .rev()
+                .map(|scope| scope.to_string())
+                .collect(),
+        ))
+    }
+}
+
+#[derive(Clone, Debug)]
+struct ScopedFakeGoogleCalendarBrokerOAuthExchange {
+    scopes: Vec<String>,
+}
+
+impl GoogleCalendarOAuthBrokerExchange for ScopedFakeGoogleCalendarBrokerOAuthExchange {
+    fn exchange_code(
+        &self,
+        request: &OAuthBrokerCodeExchange,
+    ) -> Result<OAuthBrokerToken, loc_cli::connect::ConnectError> {
+        assert_eq!(request.connector, "google-calendar");
+        assert_eq!(request.session, "broker-session");
+        assert_eq!(request.state, "state-1");
+        assert_eq!(request.code, "oauth-code");
+        assert_eq!(
+            request.redirect_uri,
+            "http://localhost:8757/oauth/google-calendar/callback"
+        );
+        Ok(google_calendar_broker_token(self.scopes.clone()))
+    }
+}
+
 #[derive(Clone, Debug)]
 struct ScopedFakeGmailBrokerOAuthExchange {
     scopes: Vec<String>,
@@ -1045,6 +1208,18 @@ fn gmail_connect_options() -> GmailBrokerOAuthConnectOptions {
     }
 }
 
+fn google_calendar_connect_options() -> GoogleCalendarBrokerOAuthConnectOptions {
+    GoogleCalendarBrokerOAuthConnectOptions {
+        connection_id: Some(ConnectionId::new("google-calendar-default")),
+        broker_url: "https://auth.example.test".to_string(),
+        client_id: "google-client-id".to_string(),
+        session: "broker-session".to_string(),
+        state: "state-1".to_string(),
+        code: "oauth-code".to_string(),
+        redirect_uri: "http://localhost:8757/oauth/google-calendar/callback".to_string(),
+    }
+}
+
 fn gmail_broker_token(scopes: Vec<String>) -> OAuthBrokerToken {
     OAuthBrokerToken {
         access_token: "oauth-access-token".to_string(),
@@ -1059,6 +1234,20 @@ fn gmail_broker_token(scopes: Vec<String>) -> OAuthBrokerToken {
     }
 }
 
+fn google_calendar_broker_token(scopes: Vec<String>) -> OAuthBrokerToken {
+    OAuthBrokerToken {
+        access_token: "oauth-access-token".to_string(),
+        token_type: Some("Bearer".to_string()),
+        expires_in: Some(3600),
+        refresh_token_handle: Some("opaque-refresh-handle".to_string()),
+        account_id: Some("acct-1".to_string()),
+        account_label: Some("user@example.com".to_string()),
+        workspace_id: Some("primary".to_string()),
+        workspace_name: Some("Primary Calendar".to_string()),
+        scopes,
+    }
+}
+
 fn gmail_worker_token_payload(scope: String) -> serde_json::Value {
     serde_json::json!({
         "access_token": "oauth-access-token",
diff --git a/crates/loc-cli/tests/mount.rs b/crates/loc-cli/tests/mount.rs
index 12229f90..2137b13b 100644
--- a/crates/loc-cli/tests/mount.rs
+++ b/crates/loc-cli/tests/mount.rs
@@ -10,6 +10,8 @@ use loc_cli::mount::{GuidanceFileAction, MountOptions, run_mount};
 use locality_connector::ConnectorCapabilities;
 use locality_core::model::{MountId, RemoteId};
 use locality_gmail::{GMAIL_OAUTH_SCOPES, gmail_capabilities_json};
+use locality_google_calendar::oauth::google_calendar_capabilities_json;
+use locality_google_calendar::{GOOGLE_CALENDAR_OAUTH_SCOPES, StoredGoogleCalendarCredential};
 use locality_platform::{capabilities::projection_cli_value, mount_cli_capabilities};
 use locality_store::{
     ConnectionId, ConnectionRecord, ConnectionRepository, ConnectorProfileId,
@@ -555,6 +557,95 @@ fn cli_mount_gmail_persists_date_window_and_thread_view() {
     );
 }
 
+#[test]
+fn cli_mount_google_calendar_persists_explicit_date_window_settings() {
+    let fixture = MountFixture::new("loc-cli-google-calendar-mount-settings");
+    fs::create_dir_all(&fixture.root).expect("create fixture root");
+    let state_root = fixture.root.join("state");
+    seed_cli_google_calendar_connection(&state_root, "calendar-work");
+
+    let loc = env!("CARGO_BIN_EXE_loc");
+    let mount_root = fixture.root.join("calendar");
+    let mount_root_arg = mount_root.display().to_string();
+
+    let report = loc_json_ok(loc_command(loc, &state_root).args([
+        "mount",
+        "google-calendar",
+        mount_root_arg.as_str(),
+        "--connection",
+        "calendar-work",
+        "--mount-id",
+        "calendar-main",
+        "--projection",
+        "plain-files",
+        "--after",
+        "2026-07-01",
+        "--before",
+        "2026-07-31",
+        "--json",
+    ]));
+
+    assert_eq!(report["connector"], "google-calendar", "{report:#?}");
+    assert_eq!(
+        report["settings_json"],
+        r#"{"google_calendar":{"date_window":{"after":"2026-07-01","before":"2026-07-31"}}}"#,
+        "{report:#?}"
+    );
+
+    let store = SqliteStateStore::open(state_root).expect("open state");
+    let mount = store
+        .get_mount(&MountId::new("calendar-main"))
+        .expect("load mount")
+        .expect("mount exists");
+    assert_eq!(mount.connector, "google-calendar");
+    assert_eq!(mount.remote_root_id, None);
+    assert_eq!(
+        mount.connection_id,
+        Some(ConnectionId::new("calendar-work"))
+    );
+    assert_eq!(
+        mount.settings_json,
+        r#"{"google_calendar":{"date_window":{"after":"2026-07-01","before":"2026-07-31"}}}"#
+    );
+}
+
+#[test]
+fn cli_mount_google_calendar_rejects_partial_date_window() {
+    for args in [
+        vec!["--after", "2026-07-01"],
+        vec!["--before", "2026-07-31"],
+    ] {
+        let fixture = MountFixture::new("loc-cli-google-calendar-partial-date-window");
+        fs::create_dir_all(&fixture.root).expect("create fixture root");
+        let state_root = fixture.root.join("state");
+        seed_cli_google_calendar_connection(&state_root, "calendar-work");
+        let loc = env!("CARGO_BIN_EXE_loc");
+        let mount_root = fixture.root.join("calendar");
+        let mount_root_arg = mount_root.display().to_string();
+        let mut command = loc_command(loc, &state_root);
+        command.args([
+            "mount",
+            "google-calendar",
+            mount_root_arg.as_str(),
+            "--connection",
+            "calendar-work",
+            "--projection",
+            "plain-files",
+            "--json",
+        ]);
+        command.args(args);
+
+        let output = command.output().expect("run loc mount google-calendar");
+        assert!(!output.status.success());
+        let body: serde_json::Value =
+            serde_json::from_slice(&output.stdout).expect("json error response");
+        assert_eq!(
+            body["code"],
+            "google_calendar_date_window_requires_after_and_before"
+        );
+    }
+}
+
 #[test]
 fn cli_mount_gmail_rejects_partial_date_window() {
     for args in [
@@ -821,6 +912,54 @@ fn cli_mount_gmail_rejects_remote_root_selectors() {
     }
 }
 
+#[test]
+fn cli_mount_google_calendar_rejects_remote_root_selectors() {
+    let cases: &[&[&str]] = &[
+        &["--workspace"],
+        &["--root-page", "root-page"],
+        &["--workspace-folder", "workspace-folder"],
+    ];
+
+    for forbidden_args in cases {
+        let fixture = MountFixture::new("loc-cli-google-calendar-mount-root-rejection");
+        fs::create_dir_all(&fixture.root).expect("create fixture root");
+        let state_root = fixture.root.join("state");
+        seed_cli_google_calendar_connection(&state_root, "calendar-work");
+
+        let loc = env!("CARGO_BIN_EXE_loc");
+        let mount_root = fixture.root.join("calendar");
+        let mount_root_arg = mount_root.display().to_string();
+        let mut command = loc_command(loc, &state_root);
+        command.args([
+            "mount",
+            "google-calendar",
+            mount_root_arg.as_str(),
+            "--connection",
+            "calendar-work",
+            "--mount-id",
+            "calendar-main",
+            "--projection",
+            "plain-files",
+            "--json",
+        ]);
+        command.args(*forbidden_args);
+
+        let output = command.output().expect("run loc mount google-calendar");
+        let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
+        let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
+        assert!(
+            !output.status.success(),
+            "Google Calendar mount accepted forbidden args {forbidden_args:?}\nstdout:\n{stdout}\nstderr:\n{stderr}"
+        );
+
+        let store = SqliteStateStore::open(state_root).expect("open state");
+        assert!(
+            store.load_mounts().expect("load mounts").is_empty(),
+            "Google Calendar mount with forbidden args {forbidden_args:?} must not be persisted"
+        );
+    }
+}
+
 #[test]
 fn virtual_mount_rejects_duplicate_mount_point_under_same_root() {
     let fixture = MountFixture::new("loc-cli-duplicate-mount-point");
@@ -1047,6 +1186,81 @@ fn seed_cli_gmail_connection(state_root: &Path, connection_id: &str) {
         .expect("seed Gmail connection");
 }
 
+fn seed_cli_google_calendar_connection(state_root: &Path, connection_id: &str) {
+    fs::create_dir_all(state_root).expect("create state root");
+    let profile_id = ConnectorProfileId::new("google-calendar-oauth-default");
+    let secret_ref = format!("connection:{connection_id}");
+    let credentials = FileCredentialStore::new(state_root);
+    let credential = StoredGoogleCalendarCredential {
+        kind: "oauth".to_string(),
+        connector: "google-calendar".to_string(),
+        access_token: "access-token".to_string(),
+        token_type: Some("Bearer".to_string()),
+        oauth_client_id: Some("google-client-id".to_string()),
+        oauth_broker_url: Some("https://auth.example.test".to_string()),
+        account_id: Some("acct-1".to_string()),
+        account_label: Some(format!("{connection_id}@example.com")),
+        workspace_id: Some("primary".to_string()),
+        workspace_name: Some("Primary Calendar".to_string()),
+        scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+            .iter()
+            .map(|scope| scope.to_string())
+            .collect(),
+        refresh_token_handle: Some("refresh-handle".to_string()),
+        acquired_at: 1_783_036_800,
+        expires_at: None,
+    };
+    credentials
+        .put(
+            &secret_ref,
+            &serde_json::to_string(&credential).expect("credential json"),
+        )
+        .expect("seed credential");
+
+    let now = "2026-07-03T00:00:00Z".to_string();
+    let capabilities_json =
+        google_calendar_capabilities_json().expect("google calendar capabilities");
+    let scopes = GOOGLE_CALENDAR_OAUTH_SCOPES
+        .iter()
+        .map(|scope| scope.to_string())
+        .collect::<Vec<_>>();
+    let mut store = SqliteStateStore::open(state_root.to_path_buf()).expect("open state");
+    store
+        .save_connector_profile(ConnectorProfileRecord {
+            profile_id: profile_id.clone(),
+            connector: "google-calendar".to_string(),
+            display_name: "Google Calendar OAuth".to_string(),
+            auth_kind: "oauth".to_string(),
+            scopes: scopes.clone(),
+            capabilities_json: capabilities_json.clone(),
+            enabled_actions_json: "[\"read\",\"create\"]".to_string(),
+            connector_version: "google-calendar.v1".to_string(),
+            status: "active".to_string(),
+            created_at: now.clone(),
+            updated_at: now.clone(),
+        })
+        .expect("seed Google Calendar profile");
+    store
+        .save_connection(ConnectionRecord {
+            connection_id: ConnectionId::new(connection_id),
+            profile_id: Some(profile_id),
+            connector: "google-calendar".to_string(),
+            display_name: "Google Calendar".to_string(),
+            account_label: Some(format!("{connection_id}@example.com")),
+            workspace_id: Some("primary".to_string()),
+            workspace_name: Some("Primary Calendar".to_string()),
+            auth_kind: "oauth".to_string(),
+            secret_ref,
+            scopes,
+            capabilities_json,
+            status: "active".to_string(),
+            created_at: now.clone(),
+            updated_at: now,
+            expires_at: None,
+        })
+        .expect("seed Google Calendar connection");
+}
+
 fn loc_command(loc: &str, state_root: &Path) -> Command {
     let mut command = Command::new(loc);
     command
diff --git a/crates/locality-core/src/diff.rs b/crates/locality-core/src/diff.rs
index 936945a5..e49fbce5 100644
--- a/crates/locality-core/src/diff.rs
+++ b/crates/locality-core/src/diff.rs
@@ -266,12 +266,14 @@ pub fn property_value_from_frontmatter(value: &Value) -> PropertyValue {
         Value::Bool(value) => PropertyValue::Bool(*value),
         Value::Number(value) => PropertyValue::Number(value.to_string()),
         Value::String(value) => PropertyValue::String(value.clone()),
-        Value::Sequence(values) => PropertyValue::List(
-            values
-                .iter()
-                .filter_map(simple_frontmatter_string)
-                .collect::<Vec<_>>(),
-        ),
+        Value::Sequence(values) => values
+            .iter()
+            .map(simple_frontmatter_string)
+            .collect::<Option<Vec<_>>>()
+            .map(PropertyValue::List)
+            .unwrap_or_else(|| {
+                PropertyValue::Array(values.iter().map(property_value_from_frontmatter).collect())
+            }),
         Value::Mapping(mapping) => PropertyValue::Object(
             mapping
                 .iter()
@@ -1142,3 +1144,61 @@ fn issue(code: impl Into<String>, line: usize, message: impl Into<String>) -> Va
         Some("restore the directive line exactly or delete it to delete the block".to_string()),
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::property_value_from_frontmatter;
+    use crate::planner::PropertyValue;
+    use yaml_serde::Value;
+
+    #[test]
+    fn property_value_from_frontmatter_preserves_nested_sequences_for_connector_drafts() {
+        let value: Value = yaml_serde::from_str(
+            r#"
+attendees:
+  - email: ann@example.com
+    optional: true
+reminders:
+  overrides:
+    - method: popup
+      minutes: 10
+"#,
+        )
+        .expect("yaml");
+
+        let converted = property_value_from_frontmatter(&value);
+        let PropertyValue::Object(root) = converted else {
+            panic!("expected root object");
+        };
+        let PropertyValue::Array(attendees) = root.get("attendees").expect("attendees") else {
+            panic!("expected attendees array");
+        };
+        let PropertyValue::Object(attendee) = attendees.first().expect("first attendee") else {
+            panic!("expected attendee object");
+        };
+        assert_eq!(
+            attendee.get("email"),
+            Some(&PropertyValue::String("ann@example.com".to_string()))
+        );
+        assert_eq!(attendee.get("optional"), Some(&PropertyValue::Bool(true)));
+
+        let PropertyValue::Object(reminders) = root.get("reminders").expect("reminders") else {
+            panic!("expected reminders object");
+        };
+        let PropertyValue::Array(overrides) = reminders.get("overrides").expect("overrides") else {
+            panic!("expected reminders overrides array");
+        };
+        let PropertyValue::Object(override_value) = overrides.first().expect("first override")
+        else {
+            panic!("expected override object");
+        };
+        assert_eq!(
+            override_value.get("method"),
+            Some(&PropertyValue::String("popup".to_string()))
+        );
+        assert_eq!(
+            override_value.get("minutes"),
+            Some(&PropertyValue::Number("10".to_string()))
+        );
+    }
+}
diff --git a/crates/locality-core/src/planner.rs b/crates/locality-core/src/planner.rs
index 09f574b0..61c19371 100644
--- a/crates/locality-core/src/planner.rs
+++ b/crates/locality-core/src/planner.rs
@@ -252,6 +252,7 @@ pub enum PropertyValue {
     Number(String),
     String(String),
     List(Vec<String>),
+    Array(Vec<PropertyValue>),
     Object(BTreeMap<String, PropertyValue>),
 }
 
diff --git a/crates/locality-google-calendar/Cargo.toml b/crates/locality-google-calendar/Cargo.toml
new file mode 100644
index 00000000..7cbda236
--- /dev/null
+++ b/crates/locality-google-calendar/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "locality-google-calendar"
+version = "0.3.2"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[lib]
+name = "locality_google_calendar"
+path = "src/lib.rs"
+
+[dependencies]
+chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
+locality-core.workspace = true
+locality-connector.workspace = true
+reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "query", "rustls-no-provider"] }
+rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+yaml_serde = "0.10"
diff --git a/crates/locality-google-calendar/src/client.rs b/crates/locality-google-calendar/src/client.rs
new file mode 100644
index 00000000..c39c37a9
--- /dev/null
+++ b/crates/locality-google-calendar/src/client.rs
@@ -0,0 +1,782 @@
+use std::fmt;
+use std::fmt::Write as _;
+use std::sync::OnceLock;
+use std::time::Duration;
+
+use locality_core::{LocalityError, LocalityResult};
+use reqwest::StatusCode;
+use reqwest::blocking::Client;
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
+use crate::dto::{CalendarEvent, CalendarEventCreateRequest, CalendarEventList};
+
+pub const DEFAULT_GOOGLE_CALENDAR_API_BASE_URL: &str = "https://www.googleapis.com";
+const GOOGLE_CALENDAR_HTTP_TIMEOUT: Duration = Duration::from_secs(30);
+const GOOGLE_CALENDAR_ERROR_SUMMARY_LIMIT: usize = 1000;
+
+static REQWEST_CRYPTO_PROVIDER: OnceLock<()> = OnceLock::new();
+
+pub trait GoogleCalendarApi: std::fmt::Debug + Send + Sync {
+    fn list_events(
+        &self,
+        calendar_id: &str,
+        time_min: &str,
+        time_max: &str,
+        page_token: Option<&str>,
+    ) -> LocalityResult<CalendarEventList>;
+
+    fn get_event(&self, calendar_id: &str, event_id: &str) -> LocalityResult<CalendarEvent>;
+
+    fn insert_event(
+        &self,
+        calendar_id: &str,
+        request: CalendarEventCreateRequest,
+        create_conference: bool,
+    ) -> LocalityResult<CalendarEvent>;
+}
+
+#[derive(Clone)]
+pub struct HttpGoogleCalendarApiClient {
+    access_token: String,
+    base_url: String,
+    client: Client,
+}
+
+impl fmt::Debug for HttpGoogleCalendarApiClient {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("HttpGoogleCalendarApiClient")
+            .field("access_token", &"<redacted>")
+            .field("base_url", &self.base_url)
+            .field("client", &self.client)
+            .finish()
+    }
+}
+
+impl HttpGoogleCalendarApiClient {
+    pub fn new(access_token: impl Into<String>) -> Self {
+        Self::with_base_url(access_token, DEFAULT_GOOGLE_CALENDAR_API_BASE_URL)
+    }
+
+    pub fn with_base_url(access_token: impl Into<String>, base_url: impl Into<String>) -> Self {
+        ensure_reqwest_crypto_provider();
+        let client = Client::builder()
+            .timeout(GOOGLE_CALENDAR_HTTP_TIMEOUT)
+            .build()
+            .expect("build google calendar api http client");
+        Self {
+            access_token: access_token.into(),
+            base_url: base_url.into().trim_end_matches('/').to_string(),
+            client,
+        }
+    }
+
+    fn get_json<T>(&self, url: String, query: Vec<(String, String)>) -> LocalityResult<T>
+    where
+        T: DeserializeOwned,
+    {
+        let mut request = self.client.get(url).bearer_auth(&self.access_token);
+        for (key, value) in query {
+            request = request.query(&[(key.as_str(), value.as_str())]);
+        }
+        decode_response(request.send(), "google calendar api GET")
+    }
+
+    fn post_json<T, B>(
+        &self,
+        url: String,
+        body: &B,
+        query: Vec<(String, String)>,
+    ) -> LocalityResult<T>
+    where
+        T: DeserializeOwned,
+        B: Serialize + ?Sized,
+    {
+        let mut request = self
+            .client
+            .post(url)
+            .bearer_auth(&self.access_token)
+            .json(body);
+        for (key, value) in query {
+            request = request.query(&[(key.as_str(), value.as_str())]);
+        }
+        decode_response(request.send(), "google calendar api POST")
+    }
+}
+
+impl GoogleCalendarApi for HttpGoogleCalendarApiClient {
+    fn list_events(
+        &self,
+        calendar_id: &str,
+        time_min: &str,
+        time_max: &str,
+        page_token: Option<&str>,
+    ) -> LocalityResult<CalendarEventList> {
+        self.get_json(
+            calendar_events_url(&self.base_url, calendar_id),
+            event_list_query(time_min, time_max, page_token),
+        )
+    }
+
+    fn get_event(&self, calendar_id: &str, event_id: &str) -> LocalityResult<CalendarEvent> {
+        self.get_json(
+            calendar_event_url(&self.base_url, calendar_id, event_id),
+            Vec::new(),
+        )
+    }
+
+    fn insert_event(
+        &self,
+        calendar_id: &str,
+        request: CalendarEventCreateRequest,
+        create_conference: bool,
+    ) -> LocalityResult<CalendarEvent> {
+        self.post_json(
+            calendar_events_url(&self.base_url, calendar_id),
+            &request,
+            event_insert_query(create_conference),
+        )
+    }
+}
+
+pub fn calendar_events_url(base_url: &str, calendar_id: &str) -> String {
+    format!(
+        "{}/calendar/v3/calendars/{}/events",
+        base_url.trim_end_matches('/'),
+        percent_encode_path_segment(calendar_id)
+    )
+}
+
+pub fn calendar_event_url(base_url: &str, calendar_id: &str, event_id: &str) -> String {
+    format!(
+        "{}/{}",
+        calendar_events_url(base_url, calendar_id),
+        percent_encode_path_segment(event_id)
+    )
+}
+
+pub fn event_list_query(
+    time_min: &str,
+    time_max: &str,
+    page_token: Option<&str>,
+) -> Vec<(String, String)> {
+    let mut query = vec![
+        ("timeMin".to_string(), time_min.to_string()),
+        ("timeMax".to_string(), time_max.to_string()),
+        ("singleEvents".to_string(), "true".to_string()),
+        ("orderBy".to_string(), "startTime".to_string()),
+        ("maxResults".to_string(), "250".to_string()),
+    ];
+    if let Some(page_token) = page_token {
+        query.push(("pageToken".to_string(), page_token.to_string()));
+    }
+    query
+}
+
+pub fn event_insert_query(create_conference: bool) -> Vec<(String, String)> {
+    let mut query = vec![("sendUpdates".to_string(), "all".to_string())];
+    if create_conference {
+        query.push(("conferenceDataVersion".to_string(), "1".to_string()));
+    }
+    query
+}
+
+#[derive(Debug, Deserialize)]
+struct GoogleApiErrorEnvelope {
+    error: Option<GoogleApiErrorBody>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GoogleApiErrorBody {
+    code: Option<i64>,
+    message: Option<String>,
+    status: Option<String>,
+    #[serde(default)]
+    errors: Vec<GoogleApiErrorDetail>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GoogleApiErrorDetail {
+    domain: Option<String>,
+    reason: Option<String>,
+    message: Option<String>,
+}
+
+#[derive(Debug)]
+struct GoogleApiErrorSummary {
+    text: String,
+    status: Option<String>,
+    reasons: Vec<String>,
+}
+
+fn decode_response<T>(
+    response: Result<reqwest::blocking::Response, reqwest::Error>,
+    context: &str,
+) -> LocalityResult<T>
+where
+    T: DeserializeOwned,
+{
+    let response =
+        response.map_err(|error| LocalityError::Io(format!("{context} failed: {error}")))?;
+    let status = response.status();
+    if !status.is_success() {
+        let body = response
+            .text()
+            .unwrap_or_else(|error| format!("<failed to read error body: {error}>"));
+        let summary = google_api_error_summary(&body);
+        if status == StatusCode::UNAUTHORIZED {
+            return Err(LocalityError::Guardrail(format!(
+                "google calendar authentication failed; reconnect Google Calendar: {}",
+                summary.text
+            )));
+        }
+        if status == StatusCode::NOT_FOUND {
+            return Err(LocalityError::RemoteNotFound(summary.text));
+        }
+        if status == StatusCode::FORBIDDEN {
+            if is_google_rate_limit_error(&summary) {
+                return Err(LocalityError::RateLimited {
+                    provider: "google calendar".to_string(),
+                    retry_after: Duration::from_secs(0),
+                    message: summary.text,
+                });
+            }
+            return Err(LocalityError::Guardrail(format!(
+                "google calendar permission denied: {}",
+                summary.text
+            )));
+        }
+        if status == StatusCode::TOO_MANY_REQUESTS {
+            return Err(LocalityError::RateLimited {
+                provider: "google calendar".to_string(),
+                retry_after: Duration::from_secs(0),
+                message: summary.text,
+            });
+        }
+        return Err(LocalityError::Io(format!(
+            "{context} returned HTTP {status}: {}",
+            summary.text
+        )));
+    }
+    response
+        .json()
+        .map_err(|error| LocalityError::Io(format!("{context} response decode failed: {error}")))
+}
+
+fn google_api_error_summary(body: &str) -> GoogleApiErrorSummary {
+    let parsed = serde_json::from_str::<GoogleApiErrorEnvelope>(body)
+        .ok()
+        .and_then(|envelope| envelope.error);
+    let Some(error) = parsed else {
+        return GoogleApiErrorSummary {
+            text: capped_error_text(body),
+            status: None,
+            reasons: Vec::new(),
+        };
+    };
+
+    let status = cleaned_error_field(error.status.as_deref());
+    let message = cleaned_error_field(error.message.as_deref());
+    let mut text = match (status.as_deref(), error.code) {
+        (Some(status), Some(code)) => format!("{status} ({code})"),
+        (Some(status), None) => status.to_string(),
+        (None, Some(code)) => format!("code {code}"),
+        (None, None) => String::new(),
+    };
+    if let Some(message) = message.as_deref() {
+        if text.is_empty() {
+            text.push_str(message);
+        } else {
+            text.push_str(": ");
+            text.push_str(message);
+        }
+    }
+
+    let mut reasons = Vec::new();
+    let details: Vec<String> = error
+        .errors
+        .iter()
+        .filter_map(|detail| {
+            let domain = cleaned_error_field(detail.domain.as_deref());
+            let reason = cleaned_error_field(detail.reason.as_deref());
+            let detail_message = cleaned_error_field(detail.message.as_deref());
+            if let Some(reason) = reason.as_deref() {
+                reasons.push(reason.to_string());
+            }
+
+            let label = match (domain.as_deref(), reason.as_deref()) {
+                (Some(domain), Some(reason)) => Some(format!("{domain}/{reason}")),
+                (Some(domain), None) => Some(domain.to_string()),
+                (None, Some(reason)) => Some(reason.to_string()),
+                (None, None) => None,
+            };
+            let detail_message = detail_message
+                .as_deref()
+                .filter(|detail_message| Some(*detail_message) != message.as_deref());
+            match (label, detail_message) {
+                (Some(label), Some(detail_message)) => Some(format!("{label}: {detail_message}")),
+                (Some(label), None) => Some(label),
+                (None, Some(detail_message)) => Some(detail_message.to_string()),
+                (None, None) => None,
+            }
+        })
+        .collect();
+    if !details.is_empty() {
+        if text.is_empty() {
+            text.push_str(&details.join("; "));
+        } else {
+            text.push_str(" [");
+            text.push_str(&details.join("; "));
+            text.push(']');
+        }
+    }
+    if text.is_empty() {
+        text.push_str("google api error");
+    }
+
+    GoogleApiErrorSummary {
+        text: cap_error_text(&text, GOOGLE_CALENDAR_ERROR_SUMMARY_LIMIT),
+        status,
+        reasons,
+    }
+}
+
+fn is_google_rate_limit_error(summary: &GoogleApiErrorSummary) -> bool {
+    summary
+        .status
+        .as_deref()
+        .is_some_and(|status| status.eq_ignore_ascii_case("RESOURCE_EXHAUSTED"))
+        || summary
+            .reasons
+            .iter()
+            .any(|reason| is_google_rate_limit_reason(reason))
+}
+
+fn is_google_rate_limit_reason(reason: &str) -> bool {
+    let normalized = reason
+        .chars()
+        .filter(|character| !matches!(character, '_' | '-' | ' '))
+        .collect::<String>()
+        .to_ascii_lowercase();
+    normalized.contains("ratelimit")
+        || normalized.contains("quota")
+        || normalized.contains("resourceexhausted")
+        || normalized == "toomanyrequests"
+}
+
+fn cleaned_error_field(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToString::to_string)
+}
+
+fn capped_error_text(value: &str) -> String {
+    let value = value.trim();
+    if value.is_empty() {
+        return "<empty error body>".to_string();
+    }
+    cap_error_text(value, GOOGLE_CALENDAR_ERROR_SUMMARY_LIMIT)
+}
+
+fn cap_error_text(value: &str, limit: usize) -> String {
+    if value.chars().count() <= limit {
+        return value.to_string();
+    }
+    const SUFFIX: &str = "... [truncated]";
+    let take = limit.saturating_sub(SUFFIX.chars().count());
+    let mut capped = value.chars().take(take).collect::<String>();
+    capped.push_str(SUFFIX);
+    capped
+}
+
+fn ensure_reqwest_crypto_provider() {
+    REQWEST_CRYPTO_PROVIDER.get_or_init(|| {
+        let _ = rustls::crypto::ring::default_provider().install_default();
+    });
+}
+
+fn percent_encode_path_segment(value: &str) -> String {
+    let mut encoded = String::with_capacity(value.len());
+    for byte in value.bytes() {
+        if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'.' | b'_' | b'~') {
+            encoded.push(byte as char);
+        } else {
+            let _ = write!(&mut encoded, "%{byte:02X}");
+        }
+    }
+    encoded
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Read, Write};
+    use std::net::{TcpListener, TcpStream};
+    use std::sync::mpsc;
+    use std::thread;
+    use std::time::Duration;
+
+    use locality_core::LocalityError;
+    use serde_json::{Value, json};
+
+    use crate::dto::{CalendarEventCreateRequest, EventDateTime};
+
+    use super::{
+        GoogleCalendarApi, HttpGoogleCalendarApiClient, calendar_event_url, calendar_events_url,
+        event_insert_query, event_list_query,
+    };
+
+    #[test]
+    fn event_list_query_uses_primary_calendar_window_and_expands_instances() {
+        let query = event_list_query(
+            "2026-06-16T00:00:00Z",
+            "2027-01-12T00:00:00Z",
+            Some("page-2"),
+        );
+
+        assert_eq!(
+            query,
+            vec![
+                ("timeMin".to_string(), "2026-06-16T00:00:00Z".to_string()),
+                ("timeMax".to_string(), "2027-01-12T00:00:00Z".to_string()),
+                ("singleEvents".to_string(), "true".to_string()),
+                ("orderBy".to_string(), "startTime".to_string()),
+                ("maxResults".to_string(), "250".to_string()),
+                ("pageToken".to_string(), "page-2".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn insert_query_sends_attendee_updates_and_enables_conference_data_when_needed() {
+        assert_eq!(
+            event_insert_query(true),
+            vec![
+                ("sendUpdates".to_string(), "all".to_string()),
+                ("conferenceDataVersion".to_string(), "1".to_string()),
+            ]
+        );
+        assert_eq!(
+            event_insert_query(false),
+            vec![("sendUpdates".to_string(), "all".to_string())]
+        );
+    }
+
+    #[test]
+    fn event_urls_percent_encode_calendar_and_event_ids() {
+        assert_eq!(
+            calendar_events_url("https://calendar.example.test", "primary"),
+            "https://calendar.example.test/calendar/v3/calendars/primary/events"
+        );
+        assert_eq!(
+            calendar_event_url(
+                "https://calendar.example.test",
+                "team@example.com",
+                "event:1"
+            ),
+            "https://calendar.example.test/calendar/v3/calendars/team%40example.com/events/event%3A1"
+        );
+    }
+
+    #[test]
+    fn list_events_sends_bearer_auth_and_calendar_window_query() {
+        let (base_url, request_rx, server) = spawn_response_server(
+            "HTTP/1.1 200 OK",
+            r#"{"items":[{"id":"event-1","summary":"Team sync"}],"nextPageToken":"next"}"#,
+        );
+        let client = HttpGoogleCalendarApiClient::with_base_url("access-token", base_url);
+
+        let events = client
+            .list_events(
+                "team@example.com",
+                "2026-06-16T00:00:00Z",
+                "2027-01-12T00:00:00Z",
+                Some("page-2"),
+            )
+            .expect("events");
+
+        assert_eq!(events.items[0].id.as_deref(), Some("event-1"));
+        assert_eq!(events.next_page_token.as_deref(), Some("next"));
+        let request = request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert_eq!(request.method, "GET");
+        assert_eq!(
+            request.target,
+            "/calendar/v3/calendars/team%40example.com/events?timeMin=2026-06-16T00%3A00%3A00Z&timeMax=2027-01-12T00%3A00%3A00Z&singleEvents=true&orderBy=startTime&maxResults=250&pageToken=page-2"
+        );
+        assert_eq!(request.header("authorization"), Some("Bearer access-token"));
+    }
+
+    #[test]
+    fn insert_event_sends_json_body_and_conference_query() {
+        let (base_url, request_rx, server) = spawn_response_server(
+            "HTTP/1.1 200 OK",
+            r#"{"id":"created-1","summary":"Planning"}"#,
+        );
+        let client = HttpGoogleCalendarApiClient::with_base_url("access-token", base_url);
+        let request_body = CalendarEventCreateRequest {
+            summary: "Planning".to_string(),
+            start: EventDateTime {
+                date_time: Some("2026-07-20T09:00:00Z".to_string()),
+                ..EventDateTime::default()
+            },
+            end: EventDateTime {
+                date_time: Some("2026-07-20T09:30:00Z".to_string()),
+                ..EventDateTime::default()
+            },
+            ..CalendarEventCreateRequest::default()
+        };
+
+        let event = client
+            .insert_event("team@example.com", request_body, true)
+            .expect("created event");
+
+        assert_eq!(event.id.as_deref(), Some("created-1"));
+        let request = request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert_eq!(request.method, "POST");
+        assert_eq!(
+            request.target,
+            "/calendar/v3/calendars/team%40example.com/events?sendUpdates=all&conferenceDataVersion=1"
+        );
+        assert_eq!(request.header("authorization"), Some("Bearer access-token"));
+        assert_eq!(request.header("content-type"), Some("application/json"));
+        let body: Value = serde_json::from_str(&request.body).expect("json body");
+        assert_eq!(body["summary"], json!("Planning"));
+        assert_eq!(body["start"]["dateTime"], json!("2026-07-20T09:00:00Z"));
+        assert_eq!(body["end"]["dateTime"], json!("2026-07-20T09:30:00Z"));
+    }
+
+    #[test]
+    fn http_errors_map_google_calendar_status_semantics() {
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 401 Unauthorized",
+                google_error_body(401, "UNAUTHENTICATED", "Invalid Credentials", "authError"),
+            ),
+            LocalityError::Guardrail(
+                "google calendar authentication failed; reconnect Google Calendar: UNAUTHENTICATED (401): Invalid Credentials [global/authError]"
+                    .to_string()
+            )
+        );
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 403 Forbidden",
+                google_error_body(
+                    403,
+                    "PERMISSION_DENIED",
+                    "Calendar access denied",
+                    "forbidden"
+                ),
+            ),
+            LocalityError::Guardrail(
+                "google calendar permission denied: PERMISSION_DENIED (403): Calendar access denied [global/forbidden]"
+                    .to_string()
+            )
+        );
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 403 Forbidden",
+                google_error_body(
+                    403,
+                    "RESOURCE_EXHAUSTED",
+                    "Calendar quota exceeded",
+                    "userRateLimitExceeded"
+                ),
+            ),
+            LocalityError::RateLimited {
+                provider: "google calendar".to_string(),
+                retry_after: Duration::from_secs(0),
+                message:
+                    "RESOURCE_EXHAUSTED (403): Calendar quota exceeded [global/userRateLimitExceeded]"
+                        .to_string(),
+            }
+        );
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 404 Not Found",
+                google_error_body(404, "NOT_FOUND", "Calendar not found", "notFound"),
+            ),
+            LocalityError::RemoteNotFound(
+                "NOT_FOUND (404): Calendar not found [global/notFound]".to_string()
+            )
+        );
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 429 Too Many Requests",
+                google_error_body(429, "RESOURCE_EXHAUSTED", "Slow down", "rateLimitExceeded"),
+            ),
+            LocalityError::RateLimited {
+                provider: "google calendar".to_string(),
+                retry_after: Duration::from_secs(0),
+                message: "RESOURCE_EXHAUSTED (429): Slow down [global/rateLimitExceeded]"
+                    .to_string(),
+            }
+        );
+        assert_eq!(
+            request_error_for_status(
+                "HTTP/1.1 500 Internal Server Error",
+                google_error_body(500, "INTERNAL", "Backend error", "backendError"),
+            ),
+            LocalityError::Io(
+                "google calendar api GET returned HTTP 500 Internal Server Error: INTERNAL (500): Backend error [global/backendError]"
+                    .to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn server_error_with_large_non_json_body_is_capped() {
+        let large_body = format!("{}SENSITIVE_TAIL_DO_NOT_COPY", "x".repeat(5000));
+
+        let error = request_error_for_status("HTTP/1.1 500 Internal Server Error", large_body);
+
+        let LocalityError::Io(message) = error else {
+            panic!("expected io error");
+        };
+        assert!(
+            message
+                .starts_with("google calendar api GET returned HTTP 500 Internal Server Error: ")
+        );
+        assert!(message.contains("[truncated]"));
+        assert!(!message.contains("SENSITIVE_TAIL_DO_NOT_COPY"));
+        assert!(message.len() < 1150, "{message}");
+    }
+
+    fn request_error_for_status(status_line: &'static str, body: String) -> LocalityError {
+        let (base_url, request_rx, server) = spawn_response_server(status_line, body);
+        let client = HttpGoogleCalendarApiClient::with_base_url("access-token", base_url);
+        let error = client
+            .get_event("primary", "event-1")
+            .expect_err("status should fail");
+        request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        error
+    }
+
+    fn google_error_body(code: i64, status: &str, message: &str, reason: &str) -> String {
+        json!({
+            "error": {
+                "code": code,
+                "message": message,
+                "status": status,
+                "errors": [
+                    {
+                        "domain": "global",
+                        "reason": reason,
+                        "message": message,
+                    }
+                ],
+            }
+        })
+        .to_string()
+    }
+
+    #[derive(Debug)]
+    struct CapturedRequest {
+        method: String,
+        target: String,
+        headers: Vec<(String, String)>,
+        body: String,
+    }
+
+    impl CapturedRequest {
+        fn parse(raw: String) -> Self {
+            let (header_block, body) = raw.split_once("\r\n\r\n").unwrap_or((raw.as_str(), ""));
+            let mut lines = header_block.lines();
+            let request_line = lines.next().unwrap_or_default();
+            let mut request_parts = request_line.split_whitespace();
+            let method = request_parts.next().unwrap_or_default().to_string();
+            let target = request_parts.next().unwrap_or_default().to_string();
+            let headers = lines
+                .filter_map(|line| line.split_once(':'))
+                .map(|(name, value)| (name.trim().to_ascii_lowercase(), value.trim().to_string()))
+                .collect();
+
+            Self {
+                method,
+                target,
+                headers,
+                body: body.to_string(),
+            }
+        }
+
+        fn header(&self, name: &str) -> Option<&str> {
+            let name = name.to_ascii_lowercase();
+            self.headers
+                .iter()
+                .find(|(header_name, _)| header_name == &name)
+                .map(|(_, value)| value.as_str())
+        }
+    }
+
+    fn spawn_response_server(
+        status_line: &'static str,
+        body: impl Into<String>,
+    ) -> (
+        String,
+        mpsc::Receiver<CapturedRequest>,
+        thread::JoinHandle<()>,
+    ) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind test server");
+        let base_url = format!("http://{}", listener.local_addr().expect("local addr"));
+        let body = body.into();
+        let (request_tx, request_rx) = mpsc::channel();
+        let server = thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept request");
+            let request = CapturedRequest::parse(read_http_request(&mut stream));
+            request_tx.send(request).expect("send request");
+            let response = format!(
+                "{status_line}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                body.len()
+            );
+            stream
+                .write_all(response.as_bytes())
+                .expect("write response");
+        });
+        (base_url, request_rx, server)
+    }
+
+    fn read_http_request(stream: &mut TcpStream) -> String {
+        let mut request = Vec::new();
+        let mut buffer = [0_u8; 4096];
+        let headers_end = loop {
+            let bytes_read = stream.read(&mut buffer).expect("read request");
+            if bytes_read == 0 {
+                break request.len();
+            }
+            request.extend_from_slice(&buffer[..bytes_read]);
+            if let Some(headers_end) = find_headers_end(&request) {
+                break headers_end;
+            }
+        };
+        let content_length = content_length(&request[..headers_end]);
+        while request.len() < headers_end + content_length {
+            let bytes_read = stream.read(&mut buffer).expect("read request body");
+            if bytes_read == 0 {
+                break;
+            }
+            request.extend_from_slice(&buffer[..bytes_read]);
+        }
+        String::from_utf8(request).expect("utf8 request")
+    }
+
+    fn find_headers_end(request: &[u8]) -> Option<usize> {
+        request
+            .windows(4)
+            .position(|window| window == b"\r\n\r\n")
+            .map(|index| index + 4)
+    }
+
+    fn content_length(headers: &[u8]) -> usize {
+        String::from_utf8_lossy(headers)
+            .lines()
+            .find_map(|line| {
+                let (name, value) = line.split_once(':')?;
+                name.eq_ignore_ascii_case("content-length")
+                    .then(|| value.trim().parse().ok())
+                    .flatten()
+            })
+            .unwrap_or(0)
+    }
+}
diff --git a/crates/locality-google-calendar/src/connector.rs b/crates/locality-google-calendar/src/connector.rs
new file mode 100644
index 00000000..82634b09
--- /dev/null
+++ b/crates/locality-google-calendar/src/connector.rs
@@ -0,0 +1,1840 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::ffi::OsStr;
+use std::fmt;
+use std::fmt::Write as _;
+use std::path::{Component, Path, PathBuf};
+use std::sync::Arc;
+
+use locality_connector::{
+    ApplyPlanRequest, ApplyPlanResult, ApplyUndoRequest, ApplyUndoResult, ChildContainer,
+    Connector, ConnectorCapabilities, ConnectorKind, EnumerateRequest, FetchRequest,
+    ListChildrenRequest, ListChildrenResult, NativeEntity, ObserveRequest, ParsedEntity,
+};
+use locality_core::freshness::{RemoteObservation, RemoteVersion};
+use locality_core::journal::{JournalApplyEffect, PushId, PushOperationId};
+use locality_core::model::{
+    CanonicalDocument, EntityKind, HydrationState, MountId, RemoteId, TreeEntry,
+};
+use locality_core::planner::{PropertyValue, PushOperation, PushOperationKind};
+use locality_core::validation::ValidationIssue;
+use locality_core::{LocalityError, LocalityResult};
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+use crate::client::{GoogleCalendarApi, HttpGoogleCalendarApiClient};
+use crate::dto::{CalendarEvent, CalendarEventCreateRequest, EventAttendee, EventDateTime};
+use crate::oauth::GOOGLE_CALENDAR_CONNECTOR_ID;
+use crate::render::{
+    GOOGLE_CALENDAR_EVENT_NATIVE_KIND, GoogleCalendarDraftDocument,
+    parse_google_calendar_draft_document, render_google_calendar_event,
+};
+use crate::settings::GoogleCalendarMountSettings;
+
+pub const PRIMARY_CALENDAR_ID: &str = "primary";
+const EVENTS_FOLDER_ID: &str = "google-calendar-folder:events";
+const DRAFT_FOLDER_ID: &str = "google-calendar-folder:draft";
+const LOCAL_DRAFT_REMOTE_ID: &str = "google-calendar-draft:local";
+const GOOGLE_CALENDAR_DRAFT_NATIVE_KIND: &str = "google_calendar_draft";
+const LOCAL_DRAFT_EVENT_ID: &str = "locality-google-calendar-draft-local";
+const LOCAL_DRAFT_CONFERENCE_REQUEST_ID: &str = "locality-google-calendar-conference-local";
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct GoogleCalendarConfig {
+    pub access_token: String,
+    pub settings: GoogleCalendarMountSettings,
+}
+
+impl fmt::Debug for GoogleCalendarConfig {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("GoogleCalendarConfig")
+            .field("access_token", &"<redacted>")
+            .field("settings", &self.settings)
+            .finish()
+    }
+}
+
+#[derive(Clone)]
+pub struct GoogleCalendarConnector {
+    config: GoogleCalendarConfig,
+    api: Arc<dyn GoogleCalendarApi>,
+}
+
+impl fmt::Debug for GoogleCalendarConnector {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("GoogleCalendarConnector")
+            .field("access_token", &"<redacted>")
+            .field("settings", &self.config.settings)
+            .finish()
+    }
+}
+
+impl GoogleCalendarConfig {
+    pub fn new(access_token: impl Into<String>) -> Self {
+        Self {
+            access_token: access_token.into(),
+            settings: GoogleCalendarMountSettings::default(),
+        }
+    }
+
+    pub fn with_settings(mut self, settings: GoogleCalendarMountSettings) -> Self {
+        self.settings = settings;
+        self
+    }
+}
+
+impl GoogleCalendarConnector {
+    pub fn new(config: GoogleCalendarConfig) -> Self {
+        let api = Arc::new(HttpGoogleCalendarApiClient::new(
+            config.access_token.clone(),
+        ));
+        Self::with_api(config, api)
+    }
+
+    pub fn with_api(config: GoogleCalendarConfig, api: Arc<dyn GoogleCalendarApi>) -> Self {
+        Self { config, api }
+    }
+
+    pub fn config(&self) -> &GoogleCalendarConfig {
+        &self.config
+    }
+
+    pub fn api(&self) -> &dyn GoogleCalendarApi {
+        self.api.as_ref()
+    }
+}
+
+impl Connector for GoogleCalendarConnector {
+    fn kind(&self) -> ConnectorKind {
+        ConnectorKind(GOOGLE_CALENDAR_CONNECTOR_ID)
+    }
+
+    fn capabilities(&self) -> ConnectorCapabilities {
+        ConnectorCapabilities {
+            supports_block_updates: false,
+            supports_databases: false,
+            supports_oauth: true,
+            supports_remote_observation: true,
+            supports_entity_body_updates: false,
+            supports_lazy_child_enumeration: true,
+            supports_media_download: false,
+            supports_undo: false,
+            supports_batch_observation: false,
+        }
+    }
+
+    fn supported_push_operations(&self) -> BTreeSet<PushOperationKind> {
+        [PushOperationKind::CreateEntity].into_iter().collect()
+    }
+
+    fn enumerate(&self, request: EnumerateRequest) -> LocalityResult<Vec<TreeEntry>> {
+        let mut entries = google_calendar_folder_entries(&request.mount_id, Path::new(""));
+        entries.extend(list_primary_event_entries(
+            self.api.as_ref(),
+            &self.config.settings,
+            &request.mount_id,
+            Path::new("events"),
+        )?);
+        Ok(entries)
+    }
+
+    fn list_children(&self, request: ListChildrenRequest) -> LocalityResult<ListChildrenResult> {
+        let entries = match request.container {
+            ChildContainer::Root => {
+                google_calendar_folder_entries(&request.mount_id, &request.parent_path)
+            }
+            ChildContainer::DirectoryChildren(remote_id)
+                if remote_id.as_str() == EVENTS_FOLDER_ID =>
+            {
+                list_primary_event_entries(
+                    self.api.as_ref(),
+                    &self.config.settings,
+                    &request.mount_id,
+                    &request.parent_path,
+                )?
+            }
+            ChildContainer::DirectoryChildren(remote_id)
+                if remote_id.as_str() == DRAFT_FOLDER_ID =>
+            {
+                Vec::new()
+            }
+            _ => Vec::new(),
+        };
+        Ok(ListChildrenResult::complete(entries))
+    }
+
+    fn observe(&self, request: ObserveRequest) -> LocalityResult<RemoteObservation> {
+        if let Some(folder) = folder_spec(request.remote_id.as_str()) {
+            return Ok(folder_observation(
+                request.mount_id,
+                &request.remote_id,
+                folder,
+            ));
+        }
+
+        let Some((calendar_id, event_id)) = parse_event_remote_id(&request.remote_id) else {
+            return Err(LocalityError::RemoteNotFound(format!(
+                "unknown google calendar remote id `{}`",
+                request.remote_id.as_str()
+            )));
+        };
+        require_primary_calendar_id(calendar_id)?;
+        let event = self.api.get_event(PRIMARY_CALENDAR_ID, event_id)?;
+        let deleted = event.status.as_deref() == Some("cancelled");
+        let entry = event_entry(
+            &request.mount_id,
+            Path::new("events"),
+            PRIMARY_CALENDAR_ID,
+            event.clone(),
+        );
+        Ok(RemoteObservation::new(
+            request.mount_id,
+            request.remote_id,
+            EntityKind::Page,
+            entry.title,
+            entry.path,
+        )
+        .with_parent(RemoteId::new(EVENTS_FOLDER_ID))
+        .with_remote_version(RemoteVersion::new(event.remote_version()))
+        .deleted(deleted)
+        .with_raw_metadata_json(serde_json::to_string(&event).unwrap_or_else(|_| "{}".to_string())))
+    }
+
+    fn fetch(&self, request: FetchRequest) -> LocalityResult<NativeEntity> {
+        let Some((calendar_id, event_id)) = parse_event_remote_id(&request.remote_id) else {
+            return Err(LocalityError::Unsupported(
+                "google calendar fetch remote id",
+            ));
+        };
+        require_primary_calendar_id(calendar_id)?;
+        let event = self.api.get_event(PRIMARY_CALENDAR_ID, event_id)?;
+        let bundle = GoogleCalendarNativeBundle {
+            calendar_id: PRIMARY_CALENDAR_ID.to_string(),
+            event,
+        };
+        let raw = serde_json::to_vec(&bundle).map_err(|error| {
+            LocalityError::Io(format!("google calendar native encode failed: {error}"))
+        })?;
+        Ok(NativeEntity {
+            remote_id: request.remote_id,
+            kind: GOOGLE_CALENDAR_EVENT_NATIVE_KIND.to_string(),
+            raw,
+        })
+    }
+
+    fn render(&self, entity: &NativeEntity) -> LocalityResult<CanonicalDocument> {
+        if entity.kind != GOOGLE_CALENDAR_EVENT_NATIVE_KIND {
+            return Err(LocalityError::Unsupported("google calendar native kind"));
+        }
+        let bundle =
+            serde_json::from_slice::<GoogleCalendarNativeBundle>(&entity.raw).map_err(|error| {
+                LocalityError::Io(format!("google calendar native decode failed: {error}"))
+            })?;
+        render_google_calendar_event(&bundle.calendar_id, &entity.remote_id, &bundle.event)
+            .map(|rendered| rendered.document)
+    }
+
+    fn parse(&self, document: &CanonicalDocument) -> LocalityResult<ParsedEntity> {
+        let draft = parse_google_calendar_draft_document(document)?;
+        let create_google_meet = draft.create_google_meet;
+        let create_request = draft.into_create_request(
+            LOCAL_DRAFT_EVENT_ID.to_string(),
+            LOCAL_DRAFT_CONFERENCE_REQUEST_ID.to_string(),
+        );
+        let raw = serde_json::to_vec(&GoogleCalendarDraftNative {
+            create_request,
+            create_google_meet,
+        })
+        .map_err(|error| {
+            LocalityError::Io(format!("google calendar draft encode failed: {error}"))
+        })?;
+        let remote_id = RemoteId::new(LOCAL_DRAFT_REMOTE_ID);
+        Ok(ParsedEntity {
+            remote_id: remote_id.clone(),
+            native: NativeEntity {
+                remote_id,
+                kind: GOOGLE_CALENDAR_DRAFT_NATIVE_KIND.to_string(),
+                raw,
+            },
+        })
+    }
+
+    fn check_concurrency(&self, _request: ApplyPlanRequest<'_>) -> LocalityResult<()> {
+        Ok(())
+    }
+
+    fn apply(&self, request: ApplyPlanRequest<'_>) -> LocalityResult<ApplyPlanResult> {
+        let mut changed_remote_ids = Vec::new();
+        let mut effects = Vec::new();
+
+        for (index, operation) in request.plan.operations.iter().enumerate() {
+            let operation_id =
+                request.operation_ids.get(index).cloned().ok_or_else(|| {
+                    LocalityError::InvalidState("missing operation id".to_string())
+                })?;
+            let PushOperation::CreateEntity {
+                parent_id,
+                parent_kind,
+                parent_workspace,
+                title,
+                properties,
+                body,
+                source_path,
+            } = operation
+            else {
+                return Err(LocalityError::Unsupported("google calendar push operation"));
+            };
+            if parent_id.as_str() != DRAFT_FOLDER_ID
+                || parent_kind.as_ref() != Some(&EntityKind::Directory)
+                || *parent_workspace
+            {
+                return Err(LocalityError::Unsupported("google calendar create parent"));
+            }
+            if !is_direct_draft_child(source_path) {
+                return Err(LocalityError::Unsupported(
+                    "google calendar draft source path",
+                ));
+            }
+
+            let event_id = locality_event_id(request.push_id, &operation_id);
+            match self.api.get_event(PRIMARY_CALENDAR_ID, &event_id) {
+                Ok(existing) => {
+                    let created_id = event_id_or_fallback_string(existing.id.as_deref(), &event_id);
+                    let entity_id = event_remote_id(PRIMARY_CALENDAR_ID, &created_id);
+                    changed_remote_ids.push(entity_id.clone());
+                    effects.push(JournalApplyEffect::CreatedEntity {
+                        operation_id,
+                        operation_index: index,
+                        parent_id: RemoteId::new(EVENTS_FOLDER_ID),
+                        entity_id,
+                    });
+                    continue;
+                }
+                Err(LocalityError::RemoteNotFound(_)) => {}
+                Err(error) => return Err(error),
+            }
+
+            let draft = draft_from_push_create(title, properties, body, source_path)?;
+            let create_google_meet = draft.create_google_meet;
+            let create_request = draft.into_create_request(event_id.clone(), event_id.clone());
+            let created =
+                self.api
+                    .insert_event(PRIMARY_CALENDAR_ID, create_request, create_google_meet)?;
+            let created_id = event_id_or_fallback_string(created.id.as_deref(), &event_id);
+            let entity_id = event_remote_id(PRIMARY_CALENDAR_ID, &created_id);
+            changed_remote_ids.push(entity_id.clone());
+            effects.push(JournalApplyEffect::CreatedEntity {
+                operation_id,
+                operation_index: index,
+                parent_id: RemoteId::new(EVENTS_FOLDER_ID),
+                entity_id,
+            });
+        }
+
+        Ok(ApplyPlanResult {
+            changed_remote_ids,
+            effects,
+        })
+    }
+
+    fn apply_undo(&self, _request: ApplyUndoRequest<'_>) -> LocalityResult<ApplyUndoResult> {
+        Err(LocalityError::Unsupported("google calendar undo"))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+struct GoogleCalendarNativeBundle {
+    calendar_id: String,
+    event: CalendarEvent,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+struct GoogleCalendarDraftNative {
+    create_request: CalendarEventCreateRequest,
+    create_google_meet: bool,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct FolderSpec {
+    id: &'static str,
+    title: &'static str,
+}
+
+fn folder_specs() -> [FolderSpec; 2] {
+    [
+        FolderSpec {
+            id: EVENTS_FOLDER_ID,
+            title: "events",
+        },
+        FolderSpec {
+            id: DRAFT_FOLDER_ID,
+            title: "draft",
+        },
+    ]
+}
+
+fn folder_spec(remote_id: &str) -> Option<FolderSpec> {
+    folder_specs()
+        .into_iter()
+        .find(|folder| folder.id == remote_id)
+}
+
+fn google_calendar_folder_entries(mount_id: &MountId, parent_path: &Path) -> Vec<TreeEntry> {
+    folder_specs()
+        .into_iter()
+        .map(|folder| TreeEntry {
+            mount_id: mount_id.clone(),
+            remote_id: RemoteId::new(folder.id),
+            kind: EntityKind::Directory,
+            title: folder.title.to_string(),
+            path: parent_path.join(folder.title),
+            hydration: HydrationState::Stub,
+            content_hash: None,
+            remote_edited_at: Some(format!("folder:{}", folder.title)),
+            stub_frontmatter: None,
+        })
+        .collect()
+}
+
+fn folder_observation(
+    mount_id: MountId,
+    remote_id: &RemoteId,
+    folder: FolderSpec,
+) -> RemoteObservation {
+    RemoteObservation::new(
+        mount_id,
+        remote_id.clone(),
+        EntityKind::Directory,
+        folder.title,
+        PathBuf::from(folder.title),
+    )
+    .with_remote_version(RemoteVersion::new(format!("folder:{}", folder.title)))
+    .with_raw_metadata_json(format!(
+        r#"{{"kind":"google_calendar_folder","id":"{}","title":"{}"}}"#,
+        folder.id, folder.title
+    ))
+}
+
+fn list_primary_event_entries(
+    api: &dyn GoogleCalendarApi,
+    settings: &GoogleCalendarMountSettings,
+    mount_id: &MountId,
+    parent_path: &Path,
+) -> LocalityResult<Vec<TreeEntry>> {
+    let window = settings.effective_date_window();
+    let time_min = window.time_min_rfc3339();
+    let time_max = window.time_max_rfc3339();
+    let mut page_token = None;
+    let mut seen_page_tokens = BTreeSet::new();
+    let mut entries = Vec::new();
+
+    loop {
+        let page = api.list_events(
+            PRIMARY_CALENDAR_ID,
+            &time_min,
+            &time_max,
+            page_token.as_deref(),
+        )?;
+        entries.extend(
+            page.items
+                .into_iter()
+                .filter(|event| event.status.as_deref() != Some("cancelled"))
+                .map(|event| event_entry(mount_id, parent_path, PRIMARY_CALENDAR_ID, event)),
+        );
+
+        let Some(next_page_token) = page.next_page_token else {
+            break;
+        };
+        track_next_page_token(&mut seen_page_tokens, &next_page_token)?;
+        page_token = Some(next_page_token);
+    }
+
+    Ok(entries)
+}
+
+fn track_next_page_token(
+    seen_page_tokens: &mut BTreeSet<String>,
+    next_page_token: &str,
+) -> LocalityResult<()> {
+    match seen_page_tokens.insert(next_page_token.to_string()) {
+        true => Ok(()),
+        false => Err(LocalityError::Io(format!(
+            "google calendar pagination returned repeated page token `{next_page_token}` for calendar `{PRIMARY_CALENDAR_ID}`"
+        ))),
+    }
+}
+
+fn event_entry(
+    mount_id: &MountId,
+    parent_path: &Path,
+    calendar_id: &str,
+    event: CalendarEvent,
+) -> TreeEntry {
+    let event_id = event_id_or_fallback(&event);
+    let remote_id = event_remote_id(calendar_id, event_id);
+    let title = event.title();
+    let remote_edited_at = Some(event.remote_version());
+    let path = parent_path.join(event_filename(&event, event_id));
+    let stub_frontmatter = render_google_calendar_event(calendar_id, &remote_id, &event)
+        .ok()
+        .map(|rendered| rendered.document.frontmatter);
+
+    TreeEntry {
+        mount_id: mount_id.clone(),
+        remote_id,
+        kind: EntityKind::Page,
+        title,
+        path,
+        hydration: HydrationState::Stub,
+        content_hash: None,
+        remote_edited_at,
+        stub_frontmatter,
+    }
+}
+
+fn event_remote_id(calendar_id: &str, event_id: &str) -> RemoteId {
+    RemoteId::new(format!("google-calendar-event:{calendar_id}:{event_id}"))
+}
+
+fn parse_event_remote_id(remote_id: &RemoteId) -> Option<(&str, &str)> {
+    remote_id
+        .as_str()
+        .strip_prefix("google-calendar-event:")
+        .and_then(|rest| rest.split_once(':'))
+        .and_then(|(calendar_id, event_id)| {
+            (!calendar_id.is_empty() && !event_id.is_empty()).then_some((calendar_id, event_id))
+        })
+}
+
+fn require_primary_calendar_id(calendar_id: &str) -> LocalityResult<()> {
+    if calendar_id == PRIMARY_CALENDAR_ID {
+        Ok(())
+    } else {
+        Err(LocalityError::Unsupported(
+            "google calendar non-primary calendar id",
+        ))
+    }
+}
+
+fn is_direct_draft_child(path: &Path) -> bool {
+    let mut components = path.components();
+    let Some(Component::Normal(folder)) = components.next() else {
+        return false;
+    };
+    if folder != OsStr::new("draft") {
+        return false;
+    }
+    let Some(Component::Normal(file_name)) = components.next() else {
+        return false;
+    };
+    if components.next().is_some() {
+        return false;
+    }
+    Path::new(file_name).extension() == Some(OsStr::new("md"))
+}
+
+fn locality_event_id(push_id: &PushId, operation_id: &PushOperationId) -> String {
+    let input = format!("{}:{}", push_id.0, operation_id.0);
+    let mut event_id = String::from("loc");
+    for byte in input.as_bytes() {
+        write!(&mut event_id, "{byte:02x}").expect("write hex event id");
+    }
+    event_id.truncate(1024);
+    event_id
+}
+
+fn event_id_or_fallback_string(value: Option<&str>, fallback: &str) -> String {
+    value
+        .map(str::trim)
+        .filter(|id| !id.is_empty())
+        .unwrap_or(fallback)
+        .to_string()
+}
+
+fn draft_from_push_create(
+    title: &str,
+    properties: &BTreeMap<String, PropertyValue>,
+    body: &str,
+    source_path: &Path,
+) -> LocalityResult<GoogleCalendarDraftDocument> {
+    let mut issues = Vec::new();
+    let start = event_datetime_property(properties, "start", source_path, &mut issues);
+    let end = event_datetime_property(properties, "end", source_path, &mut issues);
+    if let (Some(start), Some(end)) = (start.as_ref(), end.as_ref()) {
+        match (event_datetime_shape(start), event_datetime_shape(end)) {
+            (Some(start_shape), Some(end_shape)) if start_shape != end_shape => {
+                issues.push(ValidationIssue::new(
+                    "google_calendar_draft_mixed_date_shapes",
+                    source_path,
+                    Some(1),
+                    "Google Calendar draft `start` and `end` must both use `date` or both use `dateTime`",
+                    Some(
+                        "use `date` for both all-day boundaries or `dateTime` for both timed boundaries"
+                            .to_string(),
+                    ),
+                ));
+            }
+            _ => {}
+        }
+    }
+    let create_google_meet = google_meet_property(properties, source_path, &mut issues);
+    if !issues.is_empty() {
+        return Err(LocalityError::Validation(issues));
+    }
+
+    Ok(GoogleCalendarDraftDocument {
+        summary: string_property(properties, "summary")
+            .map(|summary| summary.trim())
+            .filter(|summary| !summary.is_empty())
+            .map(ToOwned::to_owned)
+            .unwrap_or_else(|| title.to_string()),
+        description: if body.is_empty() {
+            string_property(properties, "description").cloned()
+        } else {
+            Some(body.to_string())
+        },
+        location: non_blank_string_property(properties, "location"),
+        start: start.expect("validated start property"),
+        end: end.expect("validated end property"),
+        attendees: attendees_property(properties),
+        recurrence: recurrence_property(properties),
+        reminders: properties.get("reminders").map(property_value_to_json),
+        transparency: non_blank_string_property(properties, "transparency"),
+        visibility: non_blank_string_property(properties, "visibility"),
+        create_google_meet,
+        extra: properties
+            .iter()
+            .filter(|(key, _)| !calendar_draft_known_property(key))
+            .map(|(key, value)| (key.clone(), property_value_to_json(value)))
+            .collect(),
+    })
+}
+
+fn calendar_draft_known_property(key: &str) -> bool {
+    matches!(
+        key,
+        "title"
+            | "summary"
+            | "description"
+            | "location"
+            | "start"
+            | "end"
+            | "attendees"
+            | "recurrence"
+            | "reminders"
+            | "transparency"
+            | "visibility"
+            | "google_calendar"
+            | "loc"
+    )
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EventDateTimeShape {
+    Date,
+    DateTime,
+}
+
+fn event_datetime_property(
+    properties: &BTreeMap<String, PropertyValue>,
+    field: &str,
+    source_path: &Path,
+    issues: &mut Vec<ValidationIssue>,
+) -> Option<EventDateTime> {
+    let Some(value) = properties.get(field) else {
+        issues.push(ValidationIssue::new(
+            format!("google_calendar_draft_missing_{field}"),
+            source_path,
+            Some(1),
+            format!("Google Calendar draft requires `{field}` frontmatter"),
+            Some(format!("add a Google Calendar `{field}` object")),
+        ));
+        return None;
+    };
+    let PropertyValue::Object(values) = value else {
+        issues.push(invalid_datetime_shape_issue(field, source_path));
+        return None;
+    };
+
+    let date = validate_datetime_component(field, "date", values.get("date"), source_path, issues);
+    let date_time = validate_datetime_component(
+        field,
+        "dateTime",
+        values.get("dateTime"),
+        source_path,
+        issues,
+    );
+    if date.invalid || date_time.invalid {
+        return None;
+    }
+
+    match (date.value, date_time.value) {
+        (Some(date), None) => Some(EventDateTime {
+            date: Some(date),
+            date_time: None,
+            time_zone: string_property(values, "timeZone").cloned(),
+        }),
+        (None, Some(date_time)) => Some(EventDateTime {
+            date: None,
+            date_time: Some(date_time),
+            time_zone: string_property(values, "timeZone").cloned(),
+        }),
+        _ => {
+            issues.push(invalid_datetime_shape_issue(field, source_path));
+            None
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+struct DateTimeComponentValidation {
+    value: Option<String>,
+    invalid: bool,
+}
+
+fn validate_datetime_component(
+    field: &str,
+    component: &str,
+    value: Option<&PropertyValue>,
+    source_path: &Path,
+    issues: &mut Vec<ValidationIssue>,
+) -> DateTimeComponentValidation {
+    let Some(value) = value else {
+        return DateTimeComponentValidation::default();
+    };
+    match value {
+        PropertyValue::String(value) if !value.trim().is_empty() => DateTimeComponentValidation {
+            value: Some(value.clone()),
+            invalid: false,
+        },
+        PropertyValue::String(_) => {
+            issues.push(ValidationIssue::new(
+                format!(
+                    "google_calendar_draft_blank_{}_{}",
+                    field,
+                    date_component_code(component)
+                ),
+                source_path,
+                Some(1),
+                format!("Google Calendar draft `{field}.{component}` must not be blank"),
+                Some(format!(
+                    "remove `{field}.{component}` or set a non-empty {component}"
+                )),
+            ));
+            DateTimeComponentValidation {
+                value: None,
+                invalid: true,
+            }
+        }
+        _ => {
+            issues.push(ValidationIssue::new(
+                format!(
+                    "google_calendar_draft_invalid_{}_{}",
+                    field,
+                    date_component_code(component)
+                ),
+                source_path,
+                Some(1),
+                format!("Google Calendar draft `{field}.{component}` must be a non-empty string"),
+                Some(format!(
+                    "remove `{field}.{component}` or set a non-empty string"
+                )),
+            ));
+            DateTimeComponentValidation {
+                value: None,
+                invalid: true,
+            }
+        }
+    }
+}
+
+fn invalid_datetime_shape_issue(field: &str, source_path: &Path) -> ValidationIssue {
+    ValidationIssue::new(
+        format!("google_calendar_draft_invalid_{field}_shape"),
+        source_path,
+        Some(1),
+        format!("Google Calendar draft `{field}` must include exactly one of `date` or `dateTime`"),
+        Some(format!(
+            "set either `{field}.date` or `{field}.dateTime`, not both"
+        )),
+    )
+}
+
+fn event_datetime_shape(value: &EventDateTime) -> Option<EventDateTimeShape> {
+    match (
+        value
+            .date
+            .as_ref()
+            .is_some_and(|date| !date.trim().is_empty()),
+        value
+            .date_time
+            .as_ref()
+            .is_some_and(|date_time| !date_time.trim().is_empty()),
+    ) {
+        (true, false) => Some(EventDateTimeShape::Date),
+        (false, true) => Some(EventDateTimeShape::DateTime),
+        _ => None,
+    }
+}
+
+fn date_component_code(component: &str) -> &str {
+    match component {
+        "dateTime" => "date_time",
+        _ => component,
+    }
+}
+
+fn attendees_property(properties: &BTreeMap<String, PropertyValue>) -> Vec<EventAttendee> {
+    match properties.get("attendees") {
+        Some(PropertyValue::Array(values)) => values
+            .iter()
+            .filter_map(|value| match value {
+                PropertyValue::Object(values) => attendee_from_properties(values),
+                _ => None,
+            })
+            .collect(),
+        Some(PropertyValue::List(values)) => values
+            .iter()
+            .filter_map(|email| attendee_from_email(email))
+            .collect(),
+        Some(PropertyValue::String(email)) => attendee_from_email(email).into_iter().collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn attendee_from_email(email: &str) -> Option<EventAttendee> {
+    let email = email.trim();
+    (!email.is_empty()).then(|| EventAttendee {
+        email: Some(email.to_string()),
+        ..EventAttendee::default()
+    })
+}
+
+fn attendee_from_properties(values: &BTreeMap<String, PropertyValue>) -> Option<EventAttendee> {
+    let email = non_blank_string_property_from_map(values, "email")?;
+    let known = [
+        "email",
+        "displayName",
+        "responseStatus",
+        "optional",
+        "comment",
+        "additionalGuests",
+        "resource",
+        "id",
+    ];
+    Some(EventAttendee {
+        email: Some(email),
+        display_name: non_blank_string_property_from_map(values, "displayName"),
+        response_status: non_blank_string_property_from_map(values, "responseStatus"),
+        optional: bool_property(values, "optional"),
+        comment: non_blank_string_property_from_map(values, "comment"),
+        additional_guests: i64_property(values, "additionalGuests"),
+        resource: bool_property(values, "resource"),
+        id: non_blank_string_property_from_map(values, "id"),
+        extra: values
+            .iter()
+            .filter(|(key, _)| !known.contains(&key.as_str()))
+            .map(|(key, value)| (key.clone(), property_value_to_json(value)))
+            .collect(),
+        ..EventAttendee::default()
+    })
+}
+
+fn recurrence_property(properties: &BTreeMap<String, PropertyValue>) -> Vec<String> {
+    match properties.get("recurrence") {
+        Some(PropertyValue::List(values)) => values
+            .iter()
+            .filter_map(|value| non_blank(value).map(ToOwned::to_owned))
+            .collect(),
+        Some(PropertyValue::Array(values)) => values
+            .iter()
+            .filter_map(|value| match value {
+                PropertyValue::String(value) => non_blank(value).map(ToOwned::to_owned),
+                _ => None,
+            })
+            .collect(),
+        Some(PropertyValue::String(value)) => {
+            non_blank(value).into_iter().map(str::to_string).collect()
+        }
+        _ => Vec::new(),
+    }
+}
+
+fn google_meet_property(
+    properties: &BTreeMap<String, PropertyValue>,
+    source_path: &Path,
+    issues: &mut Vec<ValidationIssue>,
+) -> bool {
+    let Some(PropertyValue::Object(google_calendar)) = properties.get("google_calendar") else {
+        return false;
+    };
+    let Some(conference) = google_calendar.get("conference") else {
+        return false;
+    };
+    if matches!(conference, PropertyValue::String(value) if value.trim() == "google_meet") {
+        return true;
+    }
+
+    issues.push(ValidationIssue::new(
+        "google_calendar_draft_unsupported_conference",
+        source_path,
+        Some(1),
+        "Google Calendar draft `google_calendar.conference` supports only `google_meet`",
+        Some("remove `google_calendar.conference` or set it to `google_meet`".to_string()),
+    ));
+    false
+}
+
+fn property_value_to_json(value: &PropertyValue) -> Value {
+    match value {
+        PropertyValue::Null => Value::Null,
+        PropertyValue::Bool(value) => Value::Bool(*value),
+        PropertyValue::Number(value) => value
+            .parse::<serde_json::Number>()
+            .map(Value::Number)
+            .unwrap_or_else(|_| Value::String(value.clone())),
+        PropertyValue::String(value) => Value::String(value.clone()),
+        PropertyValue::List(values) => Value::Array(
+            values
+                .iter()
+                .map(|value| Value::String(value.clone()))
+                .collect(),
+        ),
+        PropertyValue::Array(values) => {
+            Value::Array(values.iter().map(property_value_to_json).collect())
+        }
+        PropertyValue::Object(values) => Value::Object(
+            values
+                .iter()
+                .map(|(key, value)| (key.clone(), property_value_to_json(value)))
+                .collect::<Map<_, _>>(),
+        ),
+    }
+}
+
+fn string_property<'a>(
+    properties: &'a BTreeMap<String, PropertyValue>,
+    key: &str,
+) -> Option<&'a String> {
+    match properties.get(key) {
+        Some(PropertyValue::String(value)) => Some(value),
+        _ => None,
+    }
+}
+
+fn non_blank_string_property(
+    properties: &BTreeMap<String, PropertyValue>,
+    key: &str,
+) -> Option<String> {
+    non_blank_string_property_from_map(properties, key)
+}
+
+fn non_blank_string_property_from_map(
+    properties: &BTreeMap<String, PropertyValue>,
+    key: &str,
+) -> Option<String> {
+    string_property(properties, key)
+        .and_then(|value| non_blank(value))
+        .map(ToOwned::to_owned)
+}
+
+fn bool_property(properties: &BTreeMap<String, PropertyValue>, key: &str) -> Option<bool> {
+    match properties.get(key) {
+        Some(PropertyValue::Bool(value)) => Some(*value),
+        _ => None,
+    }
+}
+
+fn i64_property(properties: &BTreeMap<String, PropertyValue>, key: &str) -> Option<i64> {
+    match properties.get(key) {
+        Some(PropertyValue::Number(value)) => value.parse().ok(),
+        _ => None,
+    }
+}
+
+fn non_blank(value: &str) -> Option<&str> {
+    let value = value.trim();
+    (!value.is_empty()).then_some(value)
+}
+
+fn event_id_or_fallback(event: &CalendarEvent) -> &str {
+    event
+        .id
+        .as_deref()
+        .map(str::trim)
+        .filter(|id| !id.is_empty())
+        .unwrap_or("missing-event-id")
+}
+
+fn event_filename(event: &CalendarEvent, event_id: &str) -> String {
+    let title = event
+        .summary
+        .as_deref()
+        .map(str::trim)
+        .filter(|title| !title.is_empty())
+        .unwrap_or("untitled");
+    format!(
+        "{}-{}-{}.md",
+        compact_start_prefix(&event.sort_start_key()),
+        safe_slug(title),
+        safe_slug(event_id)
+    )
+}
+
+fn compact_start_prefix(sort_start_key: &str) -> String {
+    let mut digits = sort_start_key
+        .chars()
+        .filter(|ch| ch.is_ascii_digit())
+        .take(14)
+        .collect::<String>();
+    while digits.len() < 14 {
+        digits.push('0');
+    }
+    format!("{}-{}", &digits[..8], &digits[8..14])
+}
+
+fn safe_slug(value: &str) -> String {
+    let mut slug = String::new();
+    let mut last_was_dash = false;
+    for ch in value.chars().flat_map(char::to_lowercase) {
+        if ch.is_ascii_alphanumeric() {
+            slug.push(ch);
+            last_was_dash = false;
+        } else if !last_was_dash {
+            slug.push('-');
+            last_was_dash = true;
+        }
+    }
+    let slug = slug.trim_matches('-');
+    if slug.is_empty() {
+        "untitled".to_string()
+    } else {
+        slug.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+    use std::sync::{Arc, Mutex};
+
+    use locality_connector::{
+        ApplyPlanRequest, ChildContainer, Connector, EnumerateRequest, FetchRequest,
+        ListChildrenRequest, ObserveRequest,
+    };
+    use locality_core::LocalityError;
+    use locality_core::journal::{JournalApplyEffect, PushId, PushOperationId};
+    use locality_core::model::{CanonicalDocument, EntityKind, MountId, RemoteId};
+    use locality_core::planner::{PropertyValue, PushOperation, PushOperationKind, PushPlan};
+    use locality_core::push::RemotePrecondition;
+    use serde_json::json;
+
+    use super::{GoogleCalendarConfig, GoogleCalendarConnector};
+    use crate::client::GoogleCalendarApi;
+    use crate::dto::{CalendarEvent, CalendarEventCreateRequest, CalendarEventList, EventDateTime};
+    use crate::settings::GoogleCalendarMountSettings;
+
+    #[test]
+    fn enumerate_projects_events_draft_and_primary_events_only() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let settings = GoogleCalendarMountSettings::with_date_window("2026-07-01", "2026-07-31")
+            .expect("settings");
+        let connector = GoogleCalendarConnector::with_api(
+            GoogleCalendarConfig::new("token").with_settings(settings),
+            api.clone(),
+        );
+
+        let entries = connector
+            .enumerate(EnumerateRequest {
+                mount_id: MountId::new("calendar-main"),
+                cursor: None,
+            })
+            .expect("enumerate");
+
+        let paths = entries
+            .iter()
+            .map(|entry| entry.path.clone())
+            .collect::<Vec<_>>();
+        assert!(paths.contains(&std::path::PathBuf::from("events")));
+        assert!(paths.contains(&std::path::PathBuf::from("draft")));
+        assert!(paths.contains(&std::path::PathBuf::from(
+            "events/20260720-100000-design-review-event-1.md"
+        )));
+        assert!(
+            !paths
+                .iter()
+                .any(|path| path.starts_with("draft") && path.components().count() > 1)
+        );
+
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(
+            calls.list_events,
+            vec![ListEventsCall {
+                calendar_id: "primary".to_string(),
+                time_min: "2026-07-01T00:00:00Z".to_string(),
+                time_max: "2026-07-31T00:00:00Z".to_string(),
+                page_token: None,
+            }]
+        );
+    }
+
+    #[test]
+    fn list_children_for_draft_folder_returns_no_remote_entries() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector = GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api);
+
+        let result = connector
+            .list_children(ListChildrenRequest {
+                mount_id: MountId::new("calendar-main"),
+                container: ChildContainer::DirectoryChildren(RemoteId::new(
+                    "google-calendar-folder:draft",
+                )),
+                parent_path: "draft".into(),
+            })
+            .expect("list draft");
+
+        assert!(result.entries.is_empty());
+        assert!(result.is_complete());
+    }
+
+    #[test]
+    fn list_children_for_root_returns_only_events_and_draft_folders() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+
+        let result = connector
+            .list_children(ListChildrenRequest {
+                mount_id: MountId::new("calendar-main"),
+                container: ChildContainer::Root,
+                parent_path: "calendar".into(),
+            })
+            .expect("list root");
+
+        assert!(result.is_complete());
+        assert_eq!(result.entries.len(), 2);
+        assert_eq!(
+            result
+                .entries
+                .iter()
+                .map(|entry| entry.path.clone())
+                .collect::<Vec<_>>(),
+            vec![
+                std::path::PathBuf::from("calendar/events"),
+                std::path::PathBuf::from("calendar/draft"),
+            ]
+        );
+        assert!(api.calls.lock().expect("calls").list_events.is_empty());
+    }
+
+    #[test]
+    fn fetch_render_and_observe_primary_event() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+        let remote_id = RemoteId::new("google-calendar-event:primary:event-1");
+
+        let native = connector
+            .fetch(FetchRequest {
+                remote_id: remote_id.clone(),
+            })
+            .expect("fetch");
+        assert_eq!(native.remote_id, remote_id);
+        assert_eq!(native.kind, "google_calendar_event");
+
+        let rendered = connector.render(&native).expect("render");
+        assert!(rendered.frontmatter.contains("event_id: \"event-1\""));
+        assert_eq!(rendered.body, "Agenda\n");
+
+        let observation = connector
+            .observe(ObserveRequest {
+                mount_id: MountId::new("calendar-main"),
+                remote_id: RemoteId::new("google-calendar-event:primary:event-1"),
+            })
+            .expect("observe");
+
+        assert_eq!(
+            observation.parent_remote_id,
+            Some(RemoteId::new("google-calendar-folder:events"))
+        );
+        assert_eq!(observation.title, "Design review");
+        assert_eq!(
+            observation.projected_path,
+            std::path::PathBuf::from("events/20260720-100000-design-review-event-1.md")
+        );
+        assert!(observation.raw_metadata_json.contains("\"event-1\""));
+
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(
+            calls.get_events,
+            vec![
+                ("primary".to_string(), "event-1".to_string()),
+                ("primary".to_string(), "event-1".to_string())
+            ]
+        );
+    }
+
+    #[test]
+    fn fetch_rejects_non_primary_event_remote_id_without_api_call() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+
+        let error = connector
+            .fetch(FetchRequest {
+                remote_id: RemoteId::new("google-calendar-event:team-calendar:event-1"),
+            })
+            .expect_err("non-primary calendar should be rejected");
+
+        assert_eq!(
+            error,
+            LocalityError::Unsupported("google calendar non-primary calendar id")
+        );
+        assert!(api.calls.lock().expect("calls").get_events.is_empty());
+    }
+
+    #[test]
+    fn observe_rejects_non_primary_event_remote_id_without_api_call() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+
+        let error = connector
+            .observe(ObserveRequest {
+                mount_id: MountId::new("calendar-main"),
+                remote_id: RemoteId::new("google-calendar-event:team-calendar:event-1"),
+            })
+            .expect_err("non-primary calendar should be rejected");
+
+        assert_eq!(
+            error,
+            LocalityError::Unsupported("google calendar non-primary calendar id")
+        );
+        assert!(api.calls.lock().expect("calls").get_events.is_empty());
+    }
+
+    #[test]
+    fn observe_cancelled_event_returns_deleted_observation() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        {
+            let mut cancelled = event_fixture("event-1");
+            cancelled.status = Some("cancelled".to_string());
+            api.calls
+                .lock()
+                .expect("calls")
+                .event_overrides
+                .insert("event-1".to_string(), cancelled);
+        }
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+
+        let observation = connector
+            .observe(ObserveRequest {
+                mount_id: MountId::new("calendar-main"),
+                remote_id: RemoteId::new("google-calendar-event:primary:event-1"),
+            })
+            .expect("observe");
+
+        assert!(observation.deleted);
+        assert_eq!(
+            observation.parent_remote_id,
+            Some(RemoteId::new("google-calendar-folder:events"))
+        );
+        assert_eq!(
+            observation.projected_path,
+            std::path::PathBuf::from("events/20260720-100000-design-review-event-1.md")
+        );
+        assert!(observation.raw_metadata_json.contains("\"cancelled\""));
+    }
+
+    #[test]
+    fn pagination_follows_tokens_and_skips_cancelled_events() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        {
+            let mut calls = api.calls.lock().expect("calls");
+            calls.pages.insert(
+                None,
+                CalendarEventList {
+                    items: vec![
+                        event_fixture("event-1"),
+                        CalendarEvent {
+                            id: Some("cancelled-1".to_string()),
+                            status: Some("cancelled".to_string()),
+                            ..event_fixture("cancelled-1")
+                        },
+                    ],
+                    next_page_token: Some("page-2".to_string()),
+                    next_sync_token: None,
+                },
+            );
+            calls.pages.insert(
+                Some("page-2".to_string()),
+                CalendarEventList {
+                    items: vec![event_fixture("event-2")],
+                    next_page_token: None,
+                    next_sync_token: None,
+                },
+            );
+        }
+        let settings = GoogleCalendarMountSettings::with_date_window("2026-07-01", "2026-07-31")
+            .expect("settings");
+        let connector = GoogleCalendarConnector::with_api(
+            GoogleCalendarConfig::new("token").with_settings(settings),
+            api.clone(),
+        );
+
+        let result = connector
+            .list_children(ListChildrenRequest {
+                mount_id: MountId::new("calendar-main"),
+                container: ChildContainer::DirectoryChildren(RemoteId::new(
+                    "google-calendar-folder:events",
+                )),
+                parent_path: "events".into(),
+            })
+            .expect("list events");
+
+        assert!(result.entries.iter().any(|entry| {
+            entry.remote_id == RemoteId::new("google-calendar-event:primary:event-1")
+        }));
+        assert!(result.entries.iter().any(|entry| {
+            entry.remote_id == RemoteId::new("google-calendar-event:primary:event-2")
+        }));
+        assert!(!result.entries.iter().any(|entry| {
+            entry.remote_id == RemoteId::new("google-calendar-event:primary:cancelled-1")
+        }));
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(
+            calls
+                .list_events
+                .iter()
+                .map(|call| call.page_token.clone())
+                .collect::<Vec<_>>(),
+            vec![None, Some("page-2".to_string())]
+        );
+    }
+
+    #[test]
+    fn pagination_detects_repeated_page_token() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        {
+            let mut calls = api.calls.lock().expect("calls");
+            calls.pages.insert(
+                None,
+                CalendarEventList {
+                    items: vec![event_fixture("event-1")],
+                    next_page_token: Some("same-token".to_string()),
+                    next_sync_token: None,
+                },
+            );
+            calls.pages.insert(
+                Some("same-token".to_string()),
+                CalendarEventList {
+                    items: vec![event_fixture("event-2")],
+                    next_page_token: Some("same-token".to_string()),
+                    next_sync_token: None,
+                },
+            );
+        }
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+
+        let error = connector
+            .list_children(ListChildrenRequest {
+                mount_id: MountId::new("calendar-main"),
+                container: ChildContainer::DirectoryChildren(RemoteId::new(
+                    "google-calendar-folder:events",
+                )),
+                parent_path: "events".into(),
+            })
+            .expect_err("repeated page token should fail");
+
+        match error {
+            LocalityError::Io(message) => {
+                assert!(message.contains("repeated page token"));
+                assert!(message.contains("same-token"));
+            }
+            other => panic!("expected io error, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn parse_returns_google_calendar_draft_native_entity() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector = GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api);
+
+        let parsed = connector
+            .parse(&CanonicalDocument::new(
+                r#"summary: Design review
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+google_calendar:
+  conference: google_meet
+"#,
+                "Agenda\n",
+            ))
+            .expect("parse");
+
+        assert_eq!(
+            parsed.remote_id,
+            RemoteId::new("google-calendar-draft:local")
+        );
+        assert_eq!(parsed.native.remote_id, parsed.remote_id);
+        assert_eq!(parsed.native.kind, "google_calendar_draft");
+        let raw: serde_json::Value = serde_json::from_slice(&parsed.native.raw).expect("raw json");
+        assert_eq!(
+            raw.pointer("/create_request/summary"),
+            Some(&json!("Design review"))
+        );
+        assert_eq!(
+            raw.pointer("/create_request/description"),
+            Some(&json!("Agenda\n"))
+        );
+        assert_eq!(raw.pointer("/create_google_meet"), Some(&json!(true)));
+    }
+
+    #[test]
+    fn capabilities_advertise_oauth_remote_observation_lazy_children_and_create_only() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector = GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api);
+
+        let capabilities = connector.capabilities();
+
+        assert!(!capabilities.supports_block_updates);
+        assert!(!capabilities.supports_databases);
+        assert!(capabilities.supports_oauth);
+        assert!(capabilities.supports_remote_observation);
+        assert!(capabilities.supports_lazy_child_enumeration);
+        assert!(!capabilities.supports_media_download);
+        assert!(!capabilities.supports_undo);
+        assert!(!capabilities.supports_batch_observation);
+        assert_eq!(
+            connector.supported_push_operations(),
+            [PushOperationKind::CreateEntity].into_iter().collect()
+        );
+    }
+
+    #[test]
+    fn apply_create_entity_inserts_primary_event_with_send_updates_and_meet() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+        let operation_id = PushOperationId("op-1".to_string());
+        let plan = draft_create_plan("draft/design-review.md");
+
+        let result = connector
+            .apply(ApplyPlanRequest {
+                push_id: &PushId("push-1".to_string()),
+                mount_id: &MountId::new("calendar-main"),
+                plan: &plan,
+                operation_ids: std::slice::from_ref(&operation_id),
+                remote_preconditions: &[] as &[RemotePrecondition],
+                local_root: None,
+            })
+            .expect("apply");
+
+        let created_remote_id = RemoteId::new("google-calendar-event:primary:created-event");
+        assert_eq!(result.changed_remote_ids, vec![created_remote_id.clone()]);
+        assert_eq!(
+            result.effects,
+            vec![JournalApplyEffect::CreatedEntity {
+                operation_id,
+                operation_index: 0,
+                parent_id: RemoteId::new("google-calendar-folder:events"),
+                entity_id: created_remote_id,
+            }]
+        );
+
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(calls.insert_events.len(), 1);
+        let (calendar_id, request, create_conference) = &calls.insert_events[0];
+        assert_eq!(calendar_id, "primary");
+        assert_eq!(request.summary, "Explicit summary");
+        assert_eq!(request.id.as_deref(), Some("loc707573682d313a6f702d31"));
+        assert_eq!(request.description.as_deref(), Some("Agenda\n"));
+        assert_eq!(
+            request.start.date_time.as_deref(),
+            Some("2026-07-20T10:00:00-07:00")
+        );
+        assert_eq!(
+            request.end.date_time.as_deref(),
+            Some("2026-07-20T10:30:00-07:00")
+        );
+        assert_eq!(request.attendees.len(), 1);
+        assert_eq!(
+            request.attendees[0].email.as_deref(),
+            Some("ann@example.com")
+        );
+        assert_eq!(request.attendees[0].optional, Some(true));
+        assert_eq!(request.attendees[0].additional_guests, Some(2));
+        assert!(request.conference_data.is_some());
+        assert!(*create_conference);
+    }
+
+    #[test]
+    fn apply_create_entity_uses_frontmatter_description_and_preserves_extra_fields() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+        let mut plan = draft_create_plan("draft/design-review.md");
+        let PushOperation::CreateEntity {
+            properties, body, ..
+        } = &mut plan.operations[0]
+        else {
+            panic!("expected create entity operation");
+        };
+        body.clear();
+        properties.insert(
+            "description".to_string(),
+            PropertyValue::String("Frontmatter description".to_string()),
+        );
+        properties.insert(
+            "colorId".to_string(),
+            PropertyValue::String("7".to_string()),
+        );
+
+        connector
+            .apply(ApplyPlanRequest {
+                push_id: &PushId("push-1".to_string()),
+                mount_id: &MountId::new("calendar-main"),
+                plan: &plan,
+                operation_ids: &[PushOperationId("op-1".to_string())],
+                remote_preconditions: &[] as &[RemotePrecondition],
+                local_root: None,
+            })
+            .expect("apply");
+
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(calls.insert_events.len(), 1);
+        let (_, request, _) = &calls.insert_events[0];
+        assert_eq!(
+            request.description.as_deref(),
+            Some("Frontmatter description")
+        );
+        assert_eq!(request.extra.get("colorId"), Some(&json!("7")));
+    }
+
+    #[test]
+    fn apply_create_entity_recovers_existing_event_by_deterministic_id_without_reinsert() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+        let push_id = PushId("push-1".to_string());
+        let operation_id = PushOperationId("op-1".to_string());
+        let event_id = super::locality_event_id(&push_id, &operation_id);
+        assert_eq!(event_id, "loc707573682d313a6f702d31");
+        {
+            let mut calls = api.calls.lock().expect("calls");
+            calls
+                .event_overrides
+                .insert(event_id.clone(), event_fixture("previous-event"));
+        }
+        let plan = draft_create_plan("draft/design-review.md");
+
+        let result = connector
+            .apply(ApplyPlanRequest {
+                push_id: &push_id,
+                mount_id: &MountId::new("calendar-main"),
+                plan: &plan,
+                operation_ids: std::slice::from_ref(&operation_id),
+                remote_preconditions: &[] as &[RemotePrecondition],
+                local_root: None,
+            })
+            .expect("apply");
+
+        assert_eq!(
+            result.changed_remote_ids,
+            vec![RemoteId::new(
+                "google-calendar-event:primary:previous-event"
+            )]
+        );
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(calls.insert_events.len(), 0);
+        assert_eq!(calls.get_events, vec![("primary".to_string(), event_id)]);
+    }
+
+    #[test]
+    fn apply_rejects_invalid_draft_source_paths() {
+        for source_path in [
+            "draft/nested/design-review.md",
+            "draft/design-review.txt",
+            "draft/design-review",
+        ] {
+            let api = Arc::new(FakeGoogleCalendarApi::default());
+            let connector =
+                GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+            let plan = draft_create_plan(source_path);
+
+            let result = connector.apply(ApplyPlanRequest {
+                push_id: &PushId("push-1".to_string()),
+                mount_id: &MountId::new("calendar-main"),
+                plan: &plan,
+                operation_ids: &[PushOperationId("op-1".to_string())],
+                remote_preconditions: &[] as &[RemotePrecondition],
+                local_root: None,
+            });
+            let error = result.unwrap_err();
+
+            assert_eq!(
+                error,
+                LocalityError::Unsupported("google calendar draft source path")
+            );
+            let calls = api.calls.lock().expect("calls");
+            assert!(calls.get_events.is_empty(), "{source_path}");
+            assert!(calls.insert_events.is_empty(), "{source_path}");
+        }
+    }
+
+    #[test]
+    fn apply_propagates_get_event_errors_during_idempotency_recovery() {
+        let api = Arc::new(FakeGoogleCalendarApi::default());
+        let connector =
+            GoogleCalendarConnector::with_api(GoogleCalendarConfig::new("token"), api.clone());
+        let push_id = PushId("push-1".to_string());
+        let operation_id = PushOperationId("op-1".to_string());
+        let event_id = super::locality_event_id(&push_id, &operation_id);
+        {
+            let mut calls = api.calls.lock().expect("calls");
+            calls.get_errors.insert(
+                event_id.clone(),
+                LocalityError::Io("google calendar lookup failed".to_string()),
+            );
+        }
+        let plan = draft_create_plan("draft/design-review.md");
+
+        let error = connector
+            .apply(ApplyPlanRequest {
+                push_id: &push_id,
+                mount_id: &MountId::new("calendar-main"),
+                plan: &plan,
+                operation_ids: std::slice::from_ref(&operation_id),
+                remote_preconditions: &[] as &[RemotePrecondition],
+                local_root: None,
+            })
+            .expect_err("lookup error should propagate");
+
+        assert_eq!(
+            error,
+            LocalityError::Io("google calendar lookup failed".to_string())
+        );
+        let calls = api.calls.lock().expect("calls");
+        assert_eq!(calls.get_events, vec![("primary".to_string(), event_id)]);
+        assert!(calls.insert_events.is_empty());
+    }
+
+    #[test]
+    fn config_debug_redacts_access_token() {
+        let debug = format!("{:?}", GoogleCalendarConfig::new("secret-access-token"));
+
+        assert!(debug.contains("<redacted>"));
+        assert!(!debug.contains("secret-access-token"));
+    }
+
+    #[test]
+    fn connector_debug_redacts_access_token() {
+        let connector = GoogleCalendarConnector::new(GoogleCalendarConfig::new(
+            "connector-secret-access-token",
+        ));
+
+        let debug = format!("{connector:?}");
+
+        assert!(debug.contains("<redacted>"));
+        assert!(!debug.contains("connector-secret-access-token"));
+    }
+
+    fn draft_create_plan(source_path: &str) -> PushPlan {
+        PushPlan::new(
+            vec![RemoteId::new("google-calendar-folder:draft")],
+            vec![PushOperation::CreateEntity {
+                parent_id: RemoteId::new("google-calendar-folder:draft"),
+                parent_kind: Some(EntityKind::Directory),
+                parent_workspace: false,
+                title: "Design review".to_string(),
+                properties: BTreeMap::from([
+                    (
+                        "summary".to_string(),
+                        PropertyValue::String("Explicit summary".to_string()),
+                    ),
+                    (
+                        "start".to_string(),
+                        PropertyValue::Object(BTreeMap::from([
+                            (
+                                "dateTime".to_string(),
+                                PropertyValue::String("2026-07-20T10:00:00-07:00".to_string()),
+                            ),
+                            (
+                                "timeZone".to_string(),
+                                PropertyValue::String("America/Los_Angeles".to_string()),
+                            ),
+                        ])),
+                    ),
+                    (
+                        "end".to_string(),
+                        PropertyValue::Object(BTreeMap::from([
+                            (
+                                "dateTime".to_string(),
+                                PropertyValue::String("2026-07-20T10:30:00-07:00".to_string()),
+                            ),
+                            (
+                                "timeZone".to_string(),
+                                PropertyValue::String("America/Los_Angeles".to_string()),
+                            ),
+                        ])),
+                    ),
+                    (
+                        "google_calendar".to_string(),
+                        PropertyValue::Object(BTreeMap::from([(
+                            "conference".to_string(),
+                            PropertyValue::String("google_meet".to_string()),
+                        )])),
+                    ),
+                    (
+                        "attendees".to_string(),
+                        PropertyValue::Array(vec![PropertyValue::Object(BTreeMap::from([
+                            (
+                                "email".to_string(),
+                                PropertyValue::String("ann@example.com".to_string()),
+                            ),
+                            ("optional".to_string(), PropertyValue::Bool(true)),
+                            (
+                                "additionalGuests".to_string(),
+                                PropertyValue::Number("2".to_string()),
+                            ),
+                        ]))]),
+                    ),
+                ]),
+                body: "Agenda\n".to_string(),
+                source_path: source_path.into(),
+            }],
+        )
+    }
+
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    struct ListEventsCall {
+        calendar_id: String,
+        time_min: String,
+        time_max: String,
+        page_token: Option<String>,
+    }
+
+    #[derive(Default, Debug)]
+    struct FakeGoogleCalendarApi {
+        calls: Mutex<FakeCalls>,
+    }
+
+    #[derive(Debug)]
+    struct FakeCalls {
+        list_events: Vec<ListEventsCall>,
+        get_events: Vec<(String, String)>,
+        insert_events: Vec<(String, CalendarEventCreateRequest, bool)>,
+        pages: BTreeMap<Option<String>, CalendarEventList>,
+        event_overrides: BTreeMap<String, CalendarEvent>,
+        get_errors: BTreeMap<String, LocalityError>,
+    }
+
+    impl Default for FakeCalls {
+        fn default() -> Self {
+            Self {
+                list_events: Vec::new(),
+                get_events: Vec::new(),
+                insert_events: Vec::new(),
+                pages: BTreeMap::from([(
+                    None,
+                    CalendarEventList {
+                        items: vec![event_fixture("event-1")],
+                        next_page_token: None,
+                        next_sync_token: None,
+                    },
+                )]),
+                event_overrides: BTreeMap::new(),
+                get_errors: BTreeMap::new(),
+            }
+        }
+    }
+
+    impl GoogleCalendarApi for FakeGoogleCalendarApi {
+        fn list_events(
+            &self,
+            calendar_id: &str,
+            time_min: &str,
+            time_max: &str,
+            page_token: Option<&str>,
+        ) -> locality_core::LocalityResult<CalendarEventList> {
+            let mut calls = self.calls.lock().expect("calls");
+            calls.list_events.push(ListEventsCall {
+                calendar_id: calendar_id.to_string(),
+                time_min: time_min.to_string(),
+                time_max: time_max.to_string(),
+                page_token: page_token.map(str::to_string),
+            });
+            Ok(calls
+                .pages
+                .get(&page_token.map(str::to_string))
+                .cloned()
+                .unwrap_or_default())
+        }
+
+        fn get_event(
+            &self,
+            calendar_id: &str,
+            event_id: &str,
+        ) -> locality_core::LocalityResult<CalendarEvent> {
+            let mut calls = self.calls.lock().expect("calls");
+            calls
+                .get_events
+                .push((calendar_id.to_string(), event_id.to_string()));
+            if let Some(error) = calls.get_errors.get(event_id).cloned() {
+                return Err(error);
+            }
+            if let Some(event) = calls.event_overrides.get(event_id).cloned() {
+                return Ok(event);
+            }
+            if event_id.starts_with("loc") {
+                return Err(LocalityError::RemoteNotFound(format!(
+                    "google calendar event `{event_id}` not found"
+                )));
+            }
+            Ok(event_fixture(event_id))
+        }
+
+        fn insert_event(
+            &self,
+            calendar_id: &str,
+            request: CalendarEventCreateRequest,
+            create_conference: bool,
+        ) -> locality_core::LocalityResult<CalendarEvent> {
+            self.calls.lock().expect("calls").insert_events.push((
+                calendar_id.to_string(),
+                request,
+                create_conference,
+            ));
+            Ok(event_fixture("created-event"))
+        }
+    }
+
+    fn event_fixture(id: &str) -> CalendarEvent {
+        CalendarEvent {
+            id: Some(id.to_string()),
+            etag: Some(format!("\"{id}-etag\"")),
+            status: Some("confirmed".to_string()),
+            html_link: Some(format!(
+                "https://calendar.google.com/calendar/event?eid={id}"
+            )),
+            updated: Some("2026-07-20T17:30:00Z".to_string()),
+            summary: Some("Design review".to_string()),
+            description: Some("Agenda\n".to_string()),
+            location: Some("Room 12".to_string()),
+            start: Some(EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:00:00-07:00".to_string()),
+                time_zone: Some("America/Los_Angeles".to_string()),
+            }),
+            end: Some(EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:30:00-07:00".to_string()),
+                time_zone: Some("America/Los_Angeles".to_string()),
+            }),
+            ..CalendarEvent::default()
+        }
+    }
+}
diff --git a/crates/locality-google-calendar/src/dto.rs b/crates/locality-google-calendar/src/dto.rs
new file mode 100644
index 00000000..909043a2
--- /dev/null
+++ b/crates/locality-google-calendar/src/dto.rs
@@ -0,0 +1,294 @@
+use std::collections::BTreeMap;
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CalendarEventList {
+    #[serde(default)]
+    pub items: Vec<CalendarEvent>,
+    pub next_page_token: Option<String>,
+    pub next_sync_token: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CalendarEvent {
+    pub kind: Option<String>,
+    pub etag: Option<String>,
+    pub id: Option<String>,
+    pub status: Option<String>,
+    pub html_link: Option<String>,
+    pub created: Option<String>,
+    pub updated: Option<String>,
+    pub summary: Option<String>,
+    pub description: Option<String>,
+    pub location: Option<String>,
+    pub color_id: Option<String>,
+    pub creator: Option<Value>,
+    pub organizer: Option<Value>,
+    pub start: Option<EventDateTime>,
+    pub end: Option<EventDateTime>,
+    pub end_time_unspecified: Option<bool>,
+    #[serde(default)]
+    pub recurrence: Vec<String>,
+    pub recurring_event_id: Option<String>,
+    pub original_start_time: Option<EventDateTime>,
+    pub transparency: Option<String>,
+    pub visibility: Option<String>,
+    #[serde(rename = "iCalUID")]
+    pub i_cal_uid: Option<String>,
+    pub sequence: Option<i64>,
+    #[serde(default)]
+    pub attendees: Vec<EventAttendee>,
+    pub attendees_omitted: Option<bool>,
+    pub extended_properties: Option<Value>,
+    pub hangout_link: Option<String>,
+    pub conference_data: Option<Value>,
+    pub reminders: Option<Value>,
+    pub source: Option<Value>,
+    #[serde(default)]
+    pub attachments: Vec<Value>,
+    pub event_type: Option<String>,
+    pub working_location_properties: Option<Value>,
+    pub out_of_office_properties: Option<Value>,
+    pub focus_time_properties: Option<Value>,
+    pub birthday_properties: Option<Value>,
+    #[serde(flatten)]
+    pub extra: BTreeMap<String, Value>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EventDateTime {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub date: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub date_time: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub time_zone: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EventAttendee {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub email: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_status: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub optional: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub comment: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub additional_guests: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resource: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub organizer: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub self_: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub async_operation: Option<String>,
+    #[serde(default, flatten)]
+    pub extra: BTreeMap<String, Value>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CalendarEventCreateRequest {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    pub summary: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub location: Option<String>,
+    pub start: EventDateTime,
+    pub end: EventDateTime,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub attendees: Vec<EventAttendee>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub recurrence: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reminders: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub transparency: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub visibility: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub conference_data: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extended_properties: Option<Value>,
+    #[serde(flatten)]
+    pub extra: BTreeMap<String, Value>,
+}
+
+impl CalendarEvent {
+    pub fn remote_version(&self) -> String {
+        format!(
+            "google-calendar:{}:{}:{}",
+            self.id.as_deref().unwrap_or(""),
+            self.updated.as_deref().unwrap_or(""),
+            self.etag.as_deref().unwrap_or("")
+        )
+    }
+
+    pub fn title(&self) -> String {
+        self.summary
+            .as_ref()
+            .filter(|summary| !summary.trim().is_empty())
+            .cloned()
+            .unwrap_or_else(|| "(no title)".to_string())
+    }
+
+    pub fn sort_start_key(&self) -> String {
+        self.start
+            .as_ref()
+            .map(EventDateTime::sort_key)
+            .unwrap_or_else(|| "0000-00-00T00:00:00Z".to_string())
+    }
+}
+
+impl EventDateTime {
+    pub fn sort_key(&self) -> String {
+        self.date_time
+            .clone()
+            .or_else(|| self.date.as_ref().map(|date| format!("{date}T00:00:00Z")))
+            .unwrap_or_else(|| "0000-00-00T00:00:00Z".to_string())
+    }
+
+    pub fn is_present(&self) -> bool {
+        self.date
+            .as_ref()
+            .is_some_and(|value| !value.trim().is_empty())
+            || self
+                .date_time
+                .as_ref()
+                .is_some_and(|value| !value.trim().is_empty())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::{CalendarEvent, CalendarEventCreateRequest, EventAttendee, EventDateTime};
+
+    #[test]
+    fn event_uses_google_ical_uid_field_spelling() {
+        let event: CalendarEvent =
+            serde_json::from_value(json!({"id": "event-1", "iCalUID": "ical@example.com"}))
+                .expect("event");
+
+        assert_eq!(event.i_cal_uid.as_deref(), Some("ical@example.com"));
+
+        let encoded = serde_json::to_value(&event).expect("json");
+
+        assert_eq!(encoded.get("iCalUID"), Some(&json!("ical@example.com")));
+        assert!(!encoded.as_object().expect("object").contains_key("iCalUid"));
+    }
+
+    #[test]
+    fn attendee_preserves_async_operation_and_unknown_fields() {
+        let attendee: EventAttendee = serde_json::from_value(json!({
+            "email": "ann@example.com",
+            "asyncOperation": "move",
+            "futureNested": {
+                "id": "future-1"
+            }
+        }))
+        .expect("attendee");
+
+        assert_eq!(attendee.async_operation.as_deref(), Some("move"));
+        assert_eq!(
+            attendee.extra.get("futureNested"),
+            Some(&json!({"id": "future-1"}))
+        );
+
+        let encoded = serde_json::to_value(&attendee).expect("json");
+
+        assert_eq!(encoded.get("asyncOperation"), Some(&json!("move")));
+        assert_eq!(
+            encoded.get("futureNested"),
+            Some(&json!({"id": "future-1"}))
+        );
+    }
+
+    #[test]
+    fn create_request_omits_unset_optional_fields() {
+        let request = CalendarEventCreateRequest {
+            id: Some("locality-event-1".to_string()),
+            summary: "Locality invite test".to_string(),
+            description: Some("Testing Calendar invite creation from Locality.".to_string()),
+            location: Some("Test location".to_string()),
+            start: EventDateTime {
+                date: None,
+                date_time: Some("2026-07-21T15:00:00+03:00".to_string()),
+                time_zone: Some("Africa/Cairo".to_string()),
+            },
+            end: EventDateTime {
+                date: None,
+                date_time: Some("2026-07-21T15:30:00+03:00".to_string()),
+                time_zone: Some("Africa/Cairo".to_string()),
+            },
+            attendees: vec![EventAttendee {
+                email: Some("mohammed18200118@gmail.com".to_string()),
+                ..EventAttendee::default()
+            }],
+            conference_data: Some(json!({
+                "createRequest": {
+                    "requestId": "conference-request-1",
+                    "conferenceSolutionKey": { "type": "hangoutsMeet" }
+                }
+            })),
+            extended_properties: Some(json!({
+                "private": {
+                    "locality_event_id": "locality-event-1"
+                }
+            })),
+            ..CalendarEventCreateRequest::default()
+        };
+
+        let encoded = serde_json::to_value(&request).expect("json");
+
+        assert_eq!(
+            encoded,
+            json!({
+                "id": "locality-event-1",
+                "summary": "Locality invite test",
+                "description": "Testing Calendar invite creation from Locality.",
+                "location": "Test location",
+                "start": {
+                    "dateTime": "2026-07-21T15:00:00+03:00",
+                    "timeZone": "Africa/Cairo"
+                },
+                "end": {
+                    "dateTime": "2026-07-21T15:30:00+03:00",
+                    "timeZone": "Africa/Cairo"
+                },
+                "attendees": [
+                    {
+                        "email": "mohammed18200118@gmail.com"
+                    }
+                ],
+                "conferenceData": {
+                    "createRequest": {
+                        "requestId": "conference-request-1",
+                        "conferenceSolutionKey": { "type": "hangoutsMeet" }
+                    }
+                },
+                "extendedProperties": {
+                    "private": {
+                        "locality_event_id": "locality-event-1"
+                    }
+                }
+            })
+        );
+    }
+}
diff --git a/crates/locality-google-calendar/src/lib.rs b/crates/locality-google-calendar/src/lib.rs
new file mode 100644
index 00000000..5ddecf75
--- /dev/null
+++ b/crates/locality-google-calendar/src/lib.rs
@@ -0,0 +1,31 @@
+pub mod client;
+pub mod connector;
+pub mod dto;
+pub mod oauth;
+pub mod render;
+pub mod settings;
+
+pub use connector::{GoogleCalendarConfig, GoogleCalendarConnector};
+pub use oauth::{
+    DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL, DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+    GOOGLE_CALENDAR_CONNECTOR_ID, GOOGLE_CALENDAR_OAUTH_SCOPES,
+    HttpGoogleCalendarOAuthBrokerClient, StoredGoogleCalendarCredential,
+};
+pub use settings::{
+    GoogleCalendarDate, GoogleCalendarDateWindow, GoogleCalendarMountSettings,
+    GoogleCalendarSettings,
+};
+
+#[cfg(test)]
+mod tests {
+    use super::{GoogleCalendarDate, GoogleCalendarSettings};
+
+    #[test]
+    fn settings_reexports_include_date_and_settings_types() {
+        let date = GoogleCalendarDate::parse("2026-07-01").expect("valid date");
+        let settings = GoogleCalendarSettings::default();
+
+        assert_eq!(date.as_str(), "2026-07-01");
+        assert_eq!(settings.date_window, None);
+    }
+}
diff --git a/crates/locality-google-calendar/src/oauth.rs b/crates/locality-google-calendar/src/oauth.rs
new file mode 100644
index 00000000..496d55c0
--- /dev/null
+++ b/crates/locality-google-calendar/src/oauth.rs
@@ -0,0 +1,848 @@
+use std::collections::BTreeSet;
+use std::fmt;
+use std::sync::OnceLock;
+
+use locality_connector::ConnectorCapabilities;
+use locality_connector::oauth_broker::{
+    OAuthBrokerCodeExchange, OAuthBrokerRefresh, OAuthBrokerStart, OAuthBrokerStartResponse,
+    OAuthBrokerToken,
+};
+use locality_core::{LocalityError, LocalityResult};
+use reqwest::blocking::Client;
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+
+pub const GOOGLE_CALENDAR_CONNECTOR_ID: &str = "google-calendar";
+pub const DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL: &str =
+    "https://afs-oauth-broker.saurabh-b07.workers.dev";
+pub const DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI: &str =
+    "http://localhost:8757/oauth/google-calendar/callback";
+pub const GOOGLE_CALENDAR_OAUTH_SCOPES: &[&str] = &[
+    "openid",
+    "email",
+    "profile",
+    "https://www.googleapis.com/auth/calendar.events",
+];
+const REQUIRED_GOOGLE_CALENDAR_API_SCOPES: &[&str] =
+    &["https://www.googleapis.com/auth/calendar.events"];
+
+static REQWEST_CRYPTO_PROVIDER: OnceLock<()> = OnceLock::new();
+
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct StoredGoogleCalendarCredential {
+    pub kind: String,
+    pub connector: String,
+    pub access_token: String,
+    pub token_type: Option<String>,
+    pub oauth_client_id: Option<String>,
+    pub oauth_broker_url: Option<String>,
+    pub account_id: Option<String>,
+    pub account_label: Option<String>,
+    pub workspace_id: Option<String>,
+    pub workspace_name: Option<String>,
+    pub scopes: Vec<String>,
+    pub refresh_token_handle: Option<String>,
+    pub acquired_at: u64,
+    pub expires_at: Option<u64>,
+}
+
+impl fmt::Debug for StoredGoogleCalendarCredential {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StoredGoogleCalendarCredential")
+            .field("kind", &self.kind)
+            .field("connector", &self.connector)
+            .field("access_token", &"<redacted>")
+            .field("token_type", &self.token_type)
+            .field("oauth_client_id", &self.oauth_client_id)
+            .field("oauth_broker_url", &self.oauth_broker_url)
+            .field("account_id", &self.account_id)
+            .field("account_label", &self.account_label)
+            .field("workspace_id", &self.workspace_id)
+            .field("workspace_name", &self.workspace_name)
+            .field("scopes", &self.scopes)
+            .field(
+                "refresh_token_handle",
+                &self.refresh_token_handle.as_ref().map(|_| "<redacted>"),
+            )
+            .field("acquired_at", &self.acquired_at)
+            .field("expires_at", &self.expires_at)
+            .finish()
+    }
+}
+
+impl StoredGoogleCalendarCredential {
+    pub fn from_broker_token(
+        token: OAuthBrokerToken,
+        client_id: String,
+        broker_url: String,
+        acquired_at: u64,
+    ) -> Self {
+        let expires_at = token
+            .expires_in
+            .and_then(|expires_in| acquired_at.checked_add(expires_in));
+        Self {
+            kind: "oauth".to_string(),
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            access_token: token.access_token,
+            token_type: token.token_type,
+            oauth_client_id: Some(client_id),
+            oauth_broker_url: Some(broker_url),
+            account_id: token.account_id,
+            account_label: token.account_label,
+            workspace_id: token.workspace_id,
+            workspace_name: token.workspace_name,
+            scopes: token.scopes,
+            refresh_token_handle: token.refresh_token_handle,
+            acquired_at,
+            expires_at,
+        }
+    }
+
+    pub fn refreshed(
+        &self,
+        token: OAuthBrokerToken,
+        acquired_at: u64,
+    ) -> Result<Self, GoogleCalendarOAuthScopeError> {
+        let expires_at = token
+            .expires_in
+            .and_then(|expires_in| acquired_at.checked_add(expires_in));
+        let scopes = if token.scopes.is_empty() {
+            self.scopes.clone()
+        } else {
+            validate_google_calendar_oauth_scopes(&token.scopes)?;
+            token.scopes
+        };
+        Ok(Self {
+            kind: "oauth".to_string(),
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            access_token: token.access_token,
+            token_type: token.token_type.or_else(|| self.token_type.clone()),
+            oauth_client_id: self.oauth_client_id.clone(),
+            oauth_broker_url: self.oauth_broker_url.clone(),
+            account_id: token.account_id.or_else(|| self.account_id.clone()),
+            account_label: token.account_label.or_else(|| self.account_label.clone()),
+            workspace_id: token.workspace_id.or_else(|| self.workspace_id.clone()),
+            workspace_name: token.workspace_name.or_else(|| self.workspace_name.clone()),
+            scopes,
+            refresh_token_handle: token
+                .refresh_token_handle
+                .or_else(|| self.refresh_token_handle.clone()),
+            acquired_at,
+            expires_at,
+        })
+    }
+
+    pub fn expires_soon(&self, now: u64) -> bool {
+        self.expires_at
+            .is_some_and(|expires_at| expires_at <= now.saturating_add(60))
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum GoogleCalendarOAuthScopeError {
+    MissingRequiredScope(&'static str),
+}
+
+impl fmt::Display for GoogleCalendarOAuthScopeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::MissingRequiredScope(scope) => write!(
+                f,
+                "Google Calendar OAuth broker response missing required Google Calendar OAuth scope `{scope}`; reconnect with the default Google Calendar OAuth broker configuration"
+            ),
+        }
+    }
+}
+
+impl std::error::Error for GoogleCalendarOAuthScopeError {}
+
+pub fn validate_google_calendar_oauth_scopes(
+    scopes: &[String],
+) -> Result<(), GoogleCalendarOAuthScopeError> {
+    let granted = scopes.iter().map(String::as_str).collect::<BTreeSet<_>>();
+    for required in REQUIRED_GOOGLE_CALENDAR_API_SCOPES {
+        if !granted.contains(required) {
+            return Err(GoogleCalendarOAuthScopeError::MissingRequiredScope(
+                required,
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Clone, Debug)]
+pub struct HttpGoogleCalendarOAuthBrokerClient {
+    base_url: String,
+    client: Client,
+}
+
+impl HttpGoogleCalendarOAuthBrokerClient {
+    pub fn new(base_url: impl Into<String>) -> Self {
+        Self {
+            base_url: base_url.into().trim_end_matches('/').to_string(),
+            client: google_calendar_http_client(),
+        }
+    }
+
+    pub fn start(&self, request: &OAuthBrokerStart) -> LocalityResult<OAuthBrokerStartResponse> {
+        self.post_json("/v1/oauth/google-calendar/start", request)
+    }
+
+    pub fn exchange_code(
+        &self,
+        request: &OAuthBrokerCodeExchange,
+    ) -> LocalityResult<OAuthBrokerToken> {
+        self.post_json("/v1/oauth/google-calendar/exchange", request)
+    }
+
+    pub fn refresh_token(&self, request: &OAuthBrokerRefresh) -> LocalityResult<OAuthBrokerToken> {
+        self.post_json("/v1/oauth/google-calendar/refresh", request)
+    }
+
+    fn post_json<T, B>(&self, path: &str, body: &B) -> LocalityResult<T>
+    where
+        T: DeserializeOwned,
+        B: Serialize + ?Sized,
+    {
+        let response = self
+            .client
+            .post(format!("{}{}", self.base_url, path))
+            .json(body)
+            .send()
+            .map_err(|error| {
+                LocalityError::Io(format!(
+                    "google calendar oauth broker request failed: {error}"
+                ))
+            })?;
+        let status = response.status();
+        if !status.is_success() {
+            let body = response
+                .text()
+                .unwrap_or_else(|error| format!("<failed to read error body: {error}>"));
+            return Err(LocalityError::Io(format!(
+                "google calendar oauth broker returned HTTP {status}: {body}"
+            )));
+        }
+        response.json().map_err(|error| {
+            LocalityError::Io(format!(
+                "google calendar oauth broker response decode failed: {error}"
+            ))
+        })
+    }
+}
+
+pub fn google_calendar_capabilities_json() -> Result<String, serde_json::Error> {
+    let capabilities = ConnectorCapabilities {
+        supports_block_updates: false,
+        supports_databases: false,
+        supports_oauth: true,
+        supports_remote_observation: true,
+        supports_entity_body_updates: false,
+        supports_lazy_child_enumeration: true,
+        supports_media_download: false,
+        supports_undo: false,
+        supports_batch_observation: false,
+    };
+    serde_json::to_string(&capabilities)
+}
+
+fn google_calendar_http_client() -> Client {
+    ensure_reqwest_crypto_provider();
+    Client::new()
+}
+
+fn ensure_reqwest_crypto_provider() {
+    REQWEST_CRYPTO_PROVIDER.get_or_init(|| {
+        let _ = rustls::crypto::ring::default_provider().install_default();
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Read, Write};
+    use std::net::{TcpListener, TcpStream};
+    use std::sync::mpsc;
+    use std::thread;
+
+    use locality_connector::ConnectorCapabilities;
+    use locality_connector::oauth_broker::{
+        OAuthBrokerCodeExchange, OAuthBrokerRefresh, OAuthBrokerStart, OAuthBrokerToken,
+    };
+    use locality_core::LocalityError;
+    use serde_json::{Value, json};
+
+    use super::{
+        DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL, DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+        GOOGLE_CALENDAR_CONNECTOR_ID, GOOGLE_CALENDAR_OAUTH_SCOPES, GoogleCalendarOAuthScopeError,
+        HttpGoogleCalendarOAuthBrokerClient, StoredGoogleCalendarCredential,
+        google_calendar_capabilities_json, validate_google_calendar_oauth_scopes,
+    };
+
+    fn calendar_scopes() -> Vec<String> {
+        GOOGLE_CALENDAR_OAUTH_SCOPES
+            .iter()
+            .map(|scope| scope.to_string())
+            .collect()
+    }
+
+    fn calendar_broker_token(scopes: Vec<String>) -> OAuthBrokerToken {
+        OAuthBrokerToken {
+            access_token: "access-token".to_string(),
+            token_type: Some("Bearer".to_string()),
+            expires_in: Some(3600),
+            refresh_token_handle: Some("handle-1".to_string()),
+            account_id: Some("acct-1".to_string()),
+            account_label: Some("ann@example.com".to_string()),
+            workspace_id: Some("primary".to_string()),
+            workspace_name: Some("Primary calendar".to_string()),
+            scopes,
+        }
+    }
+
+    #[test]
+    fn oauth_constants_match_google_calendar_broker_contract() {
+        assert_eq!(GOOGLE_CALENDAR_CONNECTOR_ID, "google-calendar");
+        assert_eq!(
+            DEFAULT_GOOGLE_CALENDAR_OAUTH_BROKER_URL,
+            "https://afs-oauth-broker.saurabh-b07.workers.dev"
+        );
+        assert_eq!(
+            DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+            "http://localhost:8757/oauth/google-calendar/callback"
+        );
+        assert_eq!(
+            GOOGLE_CALENDAR_OAUTH_SCOPES,
+            &[
+                "openid",
+                "email",
+                "profile",
+                "https://www.googleapis.com/auth/calendar.events",
+            ]
+        );
+    }
+
+    #[test]
+    fn google_calendar_scope_validation_allows_calendar_events_scope_only() {
+        validate_google_calendar_oauth_scopes(&vec![
+            "https://www.googleapis.com/auth/calendar.events".to_string(),
+        ])
+        .expect("calendar events scope is sufficient");
+    }
+
+    #[test]
+    fn google_calendar_scope_validation_rejects_missing_calendar_events_scope() {
+        let error = validate_google_calendar_oauth_scopes(&[
+            "openid".to_string(),
+            "email".to_string(),
+            "profile".to_string(),
+        ])
+        .expect_err("missing calendar events scope");
+
+        assert_eq!(
+            error,
+            GoogleCalendarOAuthScopeError::MissingRequiredScope(
+                "https://www.googleapis.com/auth/calendar.events"
+            )
+        );
+        assert!(
+            error
+                .to_string()
+                .contains("missing required Google Calendar OAuth scope")
+        );
+    }
+
+    #[test]
+    fn stored_capabilities_match_google_calendar_connector_support() {
+        let capabilities: ConnectorCapabilities =
+            serde_json::from_str(&google_calendar_capabilities_json().expect("capabilities json"))
+                .expect("decode capabilities");
+
+        assert!(capabilities.supports_oauth);
+        assert!(capabilities.supports_remote_observation);
+        assert!(capabilities.supports_lazy_child_enumeration);
+        assert!(!capabilities.supports_block_updates);
+        assert!(!capabilities.supports_databases);
+        assert!(!capabilities.supports_media_download);
+        assert!(!capabilities.supports_undo);
+        assert!(!capabilities.supports_batch_observation);
+    }
+
+    #[test]
+    fn broker_credential_stores_token_metadata_and_refresh_handle_without_secret() {
+        let stored = StoredGoogleCalendarCredential::from_broker_token(
+            calendar_broker_token(calendar_scopes()),
+            "client-id".to_string(),
+            "https://auth.example.test".to_string(),
+            100,
+        );
+
+        assert_eq!(stored.kind, "oauth");
+        assert_eq!(stored.connector, GOOGLE_CALENDAR_CONNECTOR_ID);
+        assert_eq!(stored.access_token, "access-token");
+        assert_eq!(stored.token_type.as_deref(), Some("Bearer"));
+        assert_eq!(stored.oauth_client_id.as_deref(), Some("client-id"));
+        assert_eq!(
+            stored.oauth_broker_url.as_deref(),
+            Some("https://auth.example.test")
+        );
+        assert_eq!(stored.account_id.as_deref(), Some("acct-1"));
+        assert_eq!(stored.account_label.as_deref(), Some("ann@example.com"));
+        assert_eq!(stored.workspace_id.as_deref(), Some("primary"));
+        assert_eq!(stored.workspace_name.as_deref(), Some("Primary calendar"));
+        assert_eq!(stored.scopes, calendar_scopes());
+        assert_eq!(stored.refresh_token_handle.as_deref(), Some("handle-1"));
+        assert_eq!(stored.acquired_at, 100);
+        assert_eq!(stored.expires_at, Some(3700));
+
+        let json = serde_json::to_string(&stored).expect("serialize stored credential");
+        assert!(!json.contains("\"refresh_token\":"));
+        assert!(!json.contains("client_secret"));
+    }
+
+    #[test]
+    fn stored_credential_debug_redacts_token_and_refresh_handle() {
+        let mut credential = StoredGoogleCalendarCredential::from_broker_token(
+            calendar_broker_token(calendar_scopes()),
+            "client-id".to_string(),
+            "https://auth.example.test".to_string(),
+            100,
+        );
+        credential.access_token = "secret-access-token".to_string();
+        credential.refresh_token_handle = Some("secret-refresh-handle".to_string());
+
+        let debug = format!("{credential:?}");
+
+        assert!(!debug.contains("secret-access-token"));
+        assert!(!debug.contains("secret-refresh-handle"));
+        assert!(debug.contains("<redacted>"));
+    }
+
+    #[test]
+    fn refreshed_broker_credential_preserves_scopes_and_falls_back_metadata() {
+        let stored = StoredGoogleCalendarCredential::from_broker_token(
+            calendar_broker_token(calendar_scopes()),
+            "client-id".to_string(),
+            "https://auth.example.test".to_string(),
+            100,
+        );
+
+        let refreshed = stored
+            .refreshed(
+                OAuthBrokerToken {
+                    access_token: "new-access-token".to_string(),
+                    token_type: None,
+                    expires_in: Some(7200),
+                    refresh_token_handle: Some("handle-2".to_string()),
+                    account_id: None,
+                    account_label: None,
+                    workspace_id: None,
+                    workspace_name: None,
+                    scopes: vec![],
+                },
+                200,
+            )
+            .expect("refresh with omitted scopes");
+
+        assert_eq!(refreshed.access_token, "new-access-token");
+        assert_eq!(refreshed.token_type.as_deref(), Some("Bearer"));
+        assert_eq!(refreshed.oauth_client_id.as_deref(), Some("client-id"));
+        assert_eq!(
+            refreshed.oauth_broker_url.as_deref(),
+            Some("https://auth.example.test")
+        );
+        assert_eq!(refreshed.account_id.as_deref(), Some("acct-1"));
+        assert_eq!(refreshed.account_label.as_deref(), Some("ann@example.com"));
+        assert_eq!(refreshed.workspace_id.as_deref(), Some("primary"));
+        assert_eq!(
+            refreshed.workspace_name.as_deref(),
+            Some("Primary calendar")
+        );
+        assert_eq!(refreshed.scopes, stored.scopes);
+        assert_eq!(refreshed.refresh_token_handle.as_deref(), Some("handle-2"));
+        assert_eq!(refreshed.acquired_at, 200);
+        assert_eq!(refreshed.expires_at, Some(7400));
+    }
+
+    #[test]
+    fn refreshed_broker_credential_rejects_invalid_non_empty_scopes() {
+        let stored = StoredGoogleCalendarCredential::from_broker_token(
+            calendar_broker_token(calendar_scopes()),
+            "client-id".to_string(),
+            "https://auth.example.test".to_string(),
+            100,
+        );
+
+        let error = stored
+            .refreshed(
+                OAuthBrokerToken {
+                    access_token: "new-access-token".to_string(),
+                    token_type: Some("Bearer".to_string()),
+                    expires_in: Some(3600),
+                    refresh_token_handle: Some("handle-2".to_string()),
+                    account_id: None,
+                    account_label: None,
+                    workspace_id: None,
+                    workspace_name: None,
+                    scopes: vec!["openid".to_string()],
+                },
+                200,
+            )
+            .expect_err("invalid refreshed scopes");
+
+        assert_eq!(
+            error,
+            GoogleCalendarOAuthScopeError::MissingRequiredScope(
+                "https://www.googleapis.com/auth/calendar.events"
+            )
+        );
+    }
+
+    #[test]
+    fn expires_soon_uses_sixty_second_threshold() {
+        let mut stored = StoredGoogleCalendarCredential::from_broker_token(
+            calendar_broker_token(calendar_scopes()),
+            "client-id".to_string(),
+            "https://auth.example.test".to_string(),
+            100,
+        );
+
+        stored.expires_at = Some(160);
+        assert!(stored.expires_soon(100));
+
+        stored.expires_at = Some(161);
+        assert!(!stored.expires_soon(100));
+
+        stored.expires_at = None;
+        assert!(!stored.expires_soon(u64::MAX));
+    }
+
+    #[test]
+    fn oauth_broker_start_posts_google_calendar_path_and_decodes_response() {
+        let (base_url, request_rx, server) = spawn_response_server(
+            "HTTP/1.1 200 OK",
+            json!({
+                "connector": GOOGLE_CALENDAR_CONNECTOR_ID,
+                "client_id": "client-1",
+                "authorization_url": "https://accounts.example.test/auth",
+                "redirect_uri": DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI,
+                "session": "session-1",
+                "state": "state-1",
+                "expires_in": 300,
+            })
+            .to_string(),
+        );
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(format!("{base_url}/"));
+
+        let response = client
+            .start(&OAuthBrokerStart {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                redirect_uri: DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string(),
+            })
+            .expect("start response");
+
+        assert_eq!(response.connector, GOOGLE_CALENDAR_CONNECTOR_ID);
+        assert_eq!(response.client_id, "client-1");
+        assert_eq!(
+            response.authorization_url,
+            "https://accounts.example.test/auth"
+        );
+        assert_eq!(
+            response.redirect_uri,
+            DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI
+        );
+        assert_eq!(response.session, "session-1");
+        assert_eq!(response.state, "state-1");
+        assert_eq!(response.expires_in, 300);
+        let request = request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert_eq!(request.method, "POST");
+        assert_eq!(request.target, "/v1/oauth/google-calendar/start");
+        assert_eq!(request.header("content-type"), Some("application/json"));
+        let body: Value = serde_json::from_str(&request.body).expect("json body");
+        assert_eq!(body["connector"], json!(GOOGLE_CALENDAR_CONNECTOR_ID));
+        assert_eq!(
+            body["redirect_uri"],
+            json!(DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI)
+        );
+    }
+
+    #[test]
+    fn oauth_broker_exchange_posts_google_calendar_path_and_decodes_token() {
+        let (base_url, request_rx, server) = spawn_response_server(
+            "HTTP/1.1 200 OK",
+            json!({
+                "access_token": "access-2",
+                "token_type": "Bearer",
+                "expires_in": 3600,
+                "refresh_token_handle": "handle-2",
+                "account_id": "acct-2",
+                "account_label": "sam@example.com",
+                "workspace_id": "primary",
+                "workspace_name": "Primary calendar",
+                "scopes": ["https://www.googleapis.com/auth/calendar.events"],
+            })
+            .to_string(),
+        );
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(base_url);
+
+        let token = client
+            .exchange_code(&OAuthBrokerCodeExchange {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                session: "session-2".to_string(),
+                state: "state-2".to_string(),
+                code: "code-2".to_string(),
+                redirect_uri: DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string(),
+            })
+            .expect("exchange token");
+
+        assert_eq!(token.access_token, "access-2");
+        assert_eq!(token.token_type.as_deref(), Some("Bearer"));
+        assert_eq!(token.expires_in, Some(3600));
+        assert_eq!(token.refresh_token_handle.as_deref(), Some("handle-2"));
+        assert_eq!(token.account_id.as_deref(), Some("acct-2"));
+        assert_eq!(token.account_label.as_deref(), Some("sam@example.com"));
+        assert_eq!(token.workspace_id.as_deref(), Some("primary"));
+        assert_eq!(token.workspace_name.as_deref(), Some("Primary calendar"));
+        assert_eq!(
+            token.scopes,
+            vec!["https://www.googleapis.com/auth/calendar.events".to_string()]
+        );
+        let request = request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert_eq!(request.method, "POST");
+        assert_eq!(request.target, "/v1/oauth/google-calendar/exchange");
+        let body: Value = serde_json::from_str(&request.body).expect("json body");
+        assert_eq!(body["connector"], json!(GOOGLE_CALENDAR_CONNECTOR_ID));
+        assert_eq!(body["session"], json!("session-2"));
+        assert_eq!(body["state"], json!("state-2"));
+        assert_eq!(body["code"], json!("code-2"));
+        assert_eq!(
+            body["redirect_uri"],
+            json!(DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI)
+        );
+    }
+
+    #[test]
+    fn oauth_broker_refresh_posts_google_calendar_path_and_decodes_token() {
+        let (base_url, request_rx, server) = spawn_response_server(
+            "HTTP/1.1 200 OK",
+            json!({
+                "access_token": "access-3",
+                "token_type": "Bearer",
+                "expires_in": 1800,
+                "refresh_token_handle": "handle-3",
+                "account_id": "acct-3",
+                "account_label": "lee@example.com",
+                "workspace_id": "primary",
+                "workspace_name": "Primary calendar",
+                "scope": "openid email profile https://www.googleapis.com/auth/calendar.events",
+            })
+            .to_string(),
+        );
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(base_url);
+
+        let token = client
+            .refresh_token(&OAuthBrokerRefresh {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                refresh_token_handle: Some("handle-2".to_string()),
+            })
+            .expect("refresh token");
+
+        assert_eq!(token.access_token, "access-3");
+        assert_eq!(token.expires_in, Some(1800));
+        assert_eq!(token.refresh_token_handle.as_deref(), Some("handle-3"));
+        assert_eq!(token.account_id.as_deref(), Some("acct-3"));
+        assert_eq!(token.account_label.as_deref(), Some("lee@example.com"));
+        assert_eq!(
+            token.scopes,
+            vec![
+                "openid".to_string(),
+                "email".to_string(),
+                "profile".to_string(),
+                "https://www.googleapis.com/auth/calendar.events".to_string(),
+            ]
+        );
+        let request = request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert_eq!(request.method, "POST");
+        assert_eq!(request.target, "/v1/oauth/google-calendar/refresh");
+        let body: Value = serde_json::from_str(&request.body).expect("json body");
+        assert_eq!(body["connector"], json!(GOOGLE_CALENDAR_CONNECTOR_ID));
+        assert_eq!(body["refresh_token_handle"], json!("handle-2"));
+    }
+
+    #[test]
+    fn oauth_broker_non_success_status_maps_to_io_error_with_body() {
+        let (base_url, request_rx, server) =
+            spawn_response_server("HTTP/1.1 503 Service Unavailable", "broker unavailable");
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(base_url);
+
+        let error = client
+            .start(&OAuthBrokerStart {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                redirect_uri: DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string(),
+            })
+            .expect_err("status should fail");
+
+        request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert!(matches!(
+            error,
+            LocalityError::Io(message)
+                if message.contains(
+                    "google calendar oauth broker returned HTTP 503 Service Unavailable: broker unavailable"
+                )
+        ));
+    }
+
+    #[test]
+    fn oauth_broker_invalid_success_json_maps_to_decode_error() {
+        let (base_url, request_rx, server) = spawn_response_server("HTTP/1.1 200 OK", "not-json");
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(base_url);
+
+        let error = client
+            .start(&OAuthBrokerStart {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                redirect_uri: DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string(),
+            })
+            .expect_err("decode should fail");
+
+        request_rx.recv().expect("request");
+        server.join().expect("server exits");
+        assert!(matches!(
+            error,
+            LocalityError::Io(message)
+                if message.contains("google calendar oauth broker response decode failed")
+        ));
+    }
+
+    #[test]
+    fn oauth_broker_send_failure_maps_to_request_error() {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind unused port");
+        let base_url = format!("http://{}", listener.local_addr().expect("local addr"));
+        drop(listener);
+        let client = HttpGoogleCalendarOAuthBrokerClient::new(base_url);
+
+        let error = client
+            .start(&OAuthBrokerStart {
+                connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+                redirect_uri: DEFAULT_GOOGLE_CALENDAR_OAUTH_REDIRECT_URI.to_string(),
+            })
+            .expect_err("request should fail");
+
+        assert!(matches!(
+            error,
+            LocalityError::Io(message)
+                if message.contains("google calendar oauth broker request failed")
+        ));
+    }
+
+    #[derive(Debug)]
+    struct CapturedRequest {
+        method: String,
+        target: String,
+        headers: Vec<(String, String)>,
+        body: String,
+    }
+
+    impl CapturedRequest {
+        fn parse(raw: String) -> Self {
+            let (header_block, body) = raw.split_once("\r\n\r\n").unwrap_or((raw.as_str(), ""));
+            let mut lines = header_block.lines();
+            let request_line = lines.next().unwrap_or_default();
+            let mut request_parts = request_line.split_whitespace();
+            let method = request_parts.next().unwrap_or_default().to_string();
+            let target = request_parts.next().unwrap_or_default().to_string();
+            let headers = lines
+                .filter_map(|line| line.split_once(':'))
+                .map(|(name, value)| (name.trim().to_ascii_lowercase(), value.trim().to_string()))
+                .collect();
+
+            Self {
+                method,
+                target,
+                headers,
+                body: body.to_string(),
+            }
+        }
+
+        fn header(&self, name: &str) -> Option<&str> {
+            let name = name.to_ascii_lowercase();
+            self.headers
+                .iter()
+                .find(|(header_name, _)| header_name == &name)
+                .map(|(_, value)| value.as_str())
+        }
+    }
+
+    fn spawn_response_server(
+        status_line: &'static str,
+        body: impl Into<String>,
+    ) -> (
+        String,
+        mpsc::Receiver<CapturedRequest>,
+        thread::JoinHandle<()>,
+    ) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("bind test server");
+        let base_url = format!("http://{}", listener.local_addr().expect("local addr"));
+        let body = body.into();
+        let (request_tx, request_rx) = mpsc::channel();
+        let server = thread::spawn(move || {
+            let (mut stream, _) = listener.accept().expect("accept request");
+            let request = CapturedRequest::parse(read_http_request(&mut stream));
+            request_tx.send(request).expect("send request");
+            let response = format!(
+                "{status_line}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                body.len()
+            );
+            stream
+                .write_all(response.as_bytes())
+                .expect("write response");
+        });
+        (base_url, request_rx, server)
+    }
+
+    fn read_http_request(stream: &mut TcpStream) -> String {
+        let mut request = Vec::new();
+        let mut buffer = [0_u8; 4096];
+        let headers_end = loop {
+            let bytes_read = stream.read(&mut buffer).expect("read request");
+            if bytes_read == 0 {
+                break request.len();
+            }
+            request.extend_from_slice(&buffer[..bytes_read]);
+            if let Some(headers_end) = find_headers_end(&request) {
+                break headers_end;
+            }
+        };
+        let content_length = content_length(&request[..headers_end]);
+        while request.len() < headers_end + content_length {
+            let bytes_read = stream.read(&mut buffer).expect("read request body");
+            if bytes_read == 0 {
+                break;
+            }
+            request.extend_from_slice(&buffer[..bytes_read]);
+        }
+        String::from_utf8(request).expect("utf8 request")
+    }
+
+    fn find_headers_end(request: &[u8]) -> Option<usize> {
+        request
+            .windows(4)
+            .position(|window| window == b"\r\n\r\n")
+            .map(|index| index + 4)
+    }
+
+    fn content_length(headers: &[u8]) -> usize {
+        String::from_utf8_lossy(headers)
+            .lines()
+            .find_map(|line| {
+                let (name, value) = line.split_once(':')?;
+                name.eq_ignore_ascii_case("content-length")
+                    .then(|| value.trim().parse().ok())
+                    .flatten()
+            })
+            .unwrap_or(0)
+    }
+}
diff --git a/crates/locality-google-calendar/src/render.rs b/crates/locality-google-calendar/src/render.rs
new file mode 100644
index 00000000..8c0e7732
--- /dev/null
+++ b/crates/locality-google-calendar/src/render.rs
@@ -0,0 +1,1151 @@
+use std::collections::BTreeMap;
+use std::path::PathBuf;
+
+use locality_core::model::{CanonicalDocument, RemoteId};
+use locality_core::shadow::{ShadowDocument, segment_markdown_body};
+use locality_core::validation::ValidationIssue;
+use locality_core::{LocalityError, LocalityResult};
+use serde::{Deserialize, Deserializer};
+use serde_json::{Map, Value};
+
+use crate::dto::{CalendarEvent, CalendarEventCreateRequest, EventAttendee, EventDateTime};
+use crate::oauth::GOOGLE_CALENDAR_CONNECTOR_ID;
+
+pub const GOOGLE_CALENDAR_EVENT_NATIVE_KIND: &str = "google_calendar_event";
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct GoogleCalendarRenderedEntity {
+    pub document: CanonicalDocument,
+    pub shadow: ShadowDocument,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct GoogleCalendarDraftDocument {
+    pub summary: String,
+    pub description: Option<String>,
+    pub location: Option<String>,
+    pub start: EventDateTime,
+    pub end: EventDateTime,
+    pub attendees: Vec<EventAttendee>,
+    pub recurrence: Vec<String>,
+    pub reminders: Option<Value>,
+    pub transparency: Option<String>,
+    pub visibility: Option<String>,
+    pub create_google_meet: bool,
+    pub extra: BTreeMap<String, Value>,
+}
+
+impl GoogleCalendarDraftDocument {
+    pub fn into_create_request(
+        self,
+        event_id: String,
+        conference_request_id: String,
+    ) -> CalendarEventCreateRequest {
+        let conference_data = self.create_google_meet.then(|| {
+            serde_json::json!({
+                "createRequest": {
+                    "requestId": conference_request_id,
+                    "conferenceSolutionKey": { "type": "hangoutsMeet" }
+                }
+            })
+        });
+        let mut extended_private = Map::new();
+        extended_private.insert(
+            "locality_event_id".to_string(),
+            Value::String(event_id.clone()),
+        );
+        let extended_properties = Some(serde_json::json!({
+            "private": Value::Object(extended_private)
+        }));
+        CalendarEventCreateRequest {
+            id: Some(event_id),
+            summary: self.summary,
+            description: self.description,
+            location: self.location,
+            start: self.start,
+            end: self.end,
+            attendees: self.attendees,
+            recurrence: self.recurrence,
+            reminders: self.reminders,
+            transparency: self.transparency,
+            visibility: self.visibility,
+            conference_data,
+            extended_properties,
+            extra: self.extra,
+        }
+    }
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct RawDraftFrontmatter {
+    title: Option<String>,
+    summary: Option<String>,
+    description: Option<String>,
+    location: Option<String>,
+    start: Option<RawDraftEventDateTime>,
+    end: Option<RawDraftEventDateTime>,
+    attendees: Option<Vec<EventAttendee>>,
+    recurrence: Option<Vec<String>>,
+    reminders: Option<Value>,
+    transparency: Option<String>,
+    visibility: Option<String>,
+    google_calendar: Option<RawGoogleCalendarDraftFrontmatter>,
+    #[serde(flatten)]
+    extra: BTreeMap<String, Value>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct RawDraftEventDateTime {
+    #[serde(default, deserialize_with = "deserialize_present_value")]
+    date: Option<Value>,
+    #[serde(default, deserialize_with = "deserialize_present_value")]
+    date_time: Option<Value>,
+    time_zone: Option<String>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct RawGoogleCalendarDraftFrontmatter {
+    #[serde(default, deserialize_with = "deserialize_present_value")]
+    conference: Option<Value>,
+}
+
+pub fn render_google_calendar_event(
+    calendar_id: &str,
+    remote_id: &RemoteId,
+    event: &CalendarEvent,
+) -> LocalityResult<GoogleCalendarRenderedEntity> {
+    let body = event
+        .description
+        .clone()
+        .map(escape_locality_directive_lines)
+        .unwrap_or_default();
+    let frontmatter = event_frontmatter(calendar_id, remote_id, event)?;
+    let native_block_ids = segment_markdown_body(&body, 1)
+        .into_iter()
+        .filter(|block| !block.is_directive())
+        .enumerate()
+        .map(|(index, _)| RemoteId::new(format!("{}:body:{index}", remote_id.as_str())))
+        .collect::<Vec<_>>();
+    let shadow =
+        ShadowDocument::from_synced_body(remote_id.clone(), body.clone(), 1, native_block_ids)
+            .map_err(|error| LocalityError::InvalidState(error.to_string()))?
+            .with_frontmatter(frontmatter.clone());
+    Ok(GoogleCalendarRenderedEntity {
+        document: CanonicalDocument::new(frontmatter, body),
+        shadow,
+    })
+}
+
+pub fn parse_google_calendar_draft_document(
+    document: &CanonicalDocument,
+) -> LocalityResult<GoogleCalendarDraftDocument> {
+    let raw = if document.frontmatter.trim().is_empty() {
+        RawDraftFrontmatter::default()
+    } else {
+        yaml_serde::from_str::<RawDraftFrontmatter>(&document.frontmatter).map_err(|error| {
+            LocalityError::Validation(vec![ValidationIssue::new(
+                "google_calendar_draft_frontmatter_invalid",
+                PathBuf::new(),
+                Some(1),
+                format!("Google Calendar draft frontmatter is invalid: {error}"),
+                Some("fix the YAML frontmatter".to_string()),
+            )])
+        })?
+    };
+
+    let mut issues = Vec::new();
+    let summary = first_non_blank([raw.summary.as_deref(), raw.title.as_deref()]);
+    if summary.is_empty() {
+        issues.push(ValidationIssue::new(
+            "google_calendar_draft_missing_summary",
+            PathBuf::new(),
+            Some(1),
+            "Google Calendar draft requires `summary` or `title` frontmatter",
+            Some("add `summary: \"Event title\"` to the frontmatter".to_string()),
+        ));
+    }
+    let start = match raw.start {
+        Some(start) => Some(start),
+        None => {
+            issues.push(ValidationIssue::new(
+                "google_calendar_draft_missing_start",
+                PathBuf::new(),
+                Some(1),
+                "Google Calendar draft requires `start` frontmatter",
+                Some("add a Google Calendar `start` object".to_string()),
+            ));
+            None
+        }
+    };
+    let end = match raw.end {
+        Some(end) => Some(end),
+        None => {
+            issues.push(ValidationIssue::new(
+                "google_calendar_draft_missing_end",
+                PathBuf::new(),
+                Some(1),
+                "Google Calendar draft requires `end` frontmatter",
+                Some("add a Google Calendar `end` object".to_string()),
+            ));
+            None
+        }
+    };
+    let start_shape = start
+        .as_ref()
+        .and_then(|start| validate_event_datetime_shape("start", start, &mut issues));
+    let end_shape = end
+        .as_ref()
+        .and_then(|end| validate_event_datetime_shape("end", end, &mut issues));
+    if let (Some(start_shape), Some(end_shape)) = (start_shape, end_shape)
+        && start_shape != end_shape
+    {
+        issues.push(ValidationIssue::new(
+            "google_calendar_draft_mixed_date_shapes",
+            PathBuf::new(),
+            Some(1),
+            "Google Calendar draft `start` and `end` must both use `date` or both use `dateTime`",
+            Some(
+                "use `date` for both all-day boundaries or `dateTime` for both timed boundaries"
+                    .to_string(),
+            ),
+        ));
+    }
+    let create_google_meet = validate_conference(raw.google_calendar.as_ref(), &mut issues);
+    if !issues.is_empty() {
+        return Err(LocalityError::Validation(issues));
+    }
+    let start = start
+        .expect("validated start frontmatter")
+        .into_event_datetime();
+    let end = end
+        .expect("validated end frontmatter")
+        .into_event_datetime();
+
+    Ok(GoogleCalendarDraftDocument {
+        summary,
+        description: if document.body.is_empty() {
+            raw.description
+        } else {
+            Some(document.body.clone())
+        },
+        location: raw.location,
+        start,
+        end,
+        attendees: raw.attendees.unwrap_or_default(),
+        recurrence: raw.recurrence.unwrap_or_default(),
+        reminders: raw.reminders,
+        transparency: raw.transparency,
+        visibility: raw.visibility,
+        create_google_meet,
+        extra: raw
+            .extra
+            .into_iter()
+            .filter(|(key, _)| !matches!(key.as_str(), "loc" | "google_calendar"))
+            .collect(),
+    })
+}
+
+impl RawDraftEventDateTime {
+    fn into_event_datetime(self) -> EventDateTime {
+        EventDateTime {
+            date: raw_string_value(self.date),
+            date_time: raw_string_value(self.date_time),
+            time_zone: self.time_zone,
+        }
+    }
+}
+
+fn raw_string_value(value: Option<Value>) -> Option<String> {
+    match value {
+        Some(Value::String(value)) => Some(value),
+        _ => None,
+    }
+}
+
+fn first_non_blank<const N: usize>(values: [Option<&str>; N]) -> String {
+    values
+        .into_iter()
+        .flatten()
+        .map(str::trim)
+        .find(|value| !value.is_empty())
+        .unwrap_or_default()
+        .to_string()
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EventDateTimeShape {
+    Date,
+    DateTime,
+}
+
+fn validate_event_datetime_shape(
+    field: &str,
+    value: &RawDraftEventDateTime,
+    issues: &mut Vec<ValidationIssue>,
+) -> Option<EventDateTimeShape> {
+    let date = validate_event_datetime_field(field, "date", value.date.as_ref(), issues);
+    let date_time =
+        validate_event_datetime_field(field, "dateTime", value.date_time.as_ref(), issues);
+    if date.invalid || date_time.invalid {
+        return None;
+    }
+    let has_date = date.present;
+    let has_date_time = date_time.present;
+
+    match (has_date, has_date_time) {
+        (true, false) => Some(EventDateTimeShape::Date),
+        (false, true) => Some(EventDateTimeShape::DateTime),
+        _ => {
+            issues.push(ValidationIssue::new(
+                format!("google_calendar_draft_invalid_{field}_shape"),
+                PathBuf::new(),
+                Some(1),
+                format!(
+                    "Google Calendar draft `{field}` must include exactly one of `date` or `dateTime`"
+                ),
+                Some(format!("set either `{field}.date` or `{field}.dateTime`, not both")),
+            ));
+            None
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+struct EventDateTimeFieldValidation {
+    present: bool,
+    invalid: bool,
+}
+
+fn validate_event_datetime_field(
+    field: &str,
+    component: &str,
+    value: Option<&Value>,
+    issues: &mut Vec<ValidationIssue>,
+) -> EventDateTimeFieldValidation {
+    let Some(value) = value else {
+        return EventDateTimeFieldValidation::default();
+    };
+
+    match value {
+        Value::String(value) if !value.trim().is_empty() => EventDateTimeFieldValidation {
+            present: true,
+            invalid: false,
+        },
+        Value::String(_) => {
+            issues.push(ValidationIssue::new(
+                format!(
+                    "google_calendar_draft_blank_{}_{}",
+                    field,
+                    date_component_code(component)
+                ),
+                PathBuf::new(),
+                Some(1),
+                format!("Google Calendar draft `{field}.{component}` must not be blank"),
+                Some(format!(
+                    "remove `{field}.{component}` or set a non-empty {component}"
+                )),
+            ));
+            EventDateTimeFieldValidation {
+                present: false,
+                invalid: true,
+            }
+        }
+        _ => {
+            issues.push(ValidationIssue::new(
+                format!(
+                    "google_calendar_draft_invalid_{}_{}",
+                    field,
+                    date_component_code(component)
+                ),
+                PathBuf::new(),
+                Some(1),
+                format!("Google Calendar draft `{field}.{component}` must be a non-empty string"),
+                Some(format!(
+                    "remove `{field}.{component}` or set a non-empty string"
+                )),
+            ));
+            EventDateTimeFieldValidation {
+                present: false,
+                invalid: true,
+            }
+        }
+    }
+}
+
+fn date_component_code(component: &str) -> &str {
+    match component {
+        "dateTime" => "date_time",
+        _ => component,
+    }
+}
+
+fn validate_conference(
+    google_calendar: Option<&RawGoogleCalendarDraftFrontmatter>,
+    issues: &mut Vec<ValidationIssue>,
+) -> bool {
+    let Some(conference) = google_calendar.and_then(|calendar| calendar.conference.as_ref()) else {
+        return false;
+    };
+    if matches!(conference, Value::String(value) if value.trim() == "google_meet") {
+        return true;
+    }
+
+    issues.push(ValidationIssue::new(
+        "google_calendar_draft_unsupported_conference",
+        PathBuf::new(),
+        Some(1),
+        "Google Calendar draft `google_calendar.conference` supports only `google_meet`",
+        Some("remove `google_calendar.conference` or set it to `google_meet`".to_string()),
+    ));
+    false
+}
+
+fn deserialize_present_value<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    Value::deserialize(deserializer).map(Some)
+}
+
+fn event_frontmatter(
+    calendar_id: &str,
+    remote_id: &RemoteId,
+    event: &CalendarEvent,
+) -> LocalityResult<String> {
+    let version = event.remote_version();
+    let title = event.title();
+    let mut root = serde_json::Map::new();
+    root.insert(
+        "loc".to_string(),
+        serde_json::json!({
+            "id": remote_id.as_str(),
+            "type": "page",
+            "connector": GOOGLE_CALENDAR_CONNECTOR_ID,
+            "synced_at": version,
+            "remote_edited_at": event.remote_version()
+        }),
+    );
+    root.insert("title".to_string(), Value::String(title.clone()));
+    root.insert("summary".to_string(), Value::String(title));
+    if let Some(start) = &event.start {
+        root.insert(
+            "start".to_string(),
+            serde_json::to_value(start).map_err(json_error)?,
+        );
+    }
+    if let Some(end) = &event.end {
+        root.insert(
+            "end".to_string(),
+            serde_json::to_value(end).map_err(json_error)?,
+        );
+    }
+    if let Some(location) = &event.location {
+        root.insert("location".to_string(), Value::String(location.clone()));
+    }
+    root.insert(
+        "google_calendar".to_string(),
+        serde_json::json!({
+            "calendar_id": calendar_id,
+            "event_id": event.id.as_deref().unwrap_or(""),
+            "status": event.status.as_deref().unwrap_or(""),
+            "html_link": event.html_link.as_deref().unwrap_or(""),
+            "event": serde_json::to_value(event).map_err(json_error)?
+        }),
+    );
+    let value = Value::Object(root);
+    yaml_serde::to_string(&value)
+        .map(|yaml| quote_yaml_frontmatter_strings(yaml.trim_start_matches("---\n")))
+        .map_err(|error| {
+            LocalityError::Io(format!(
+                "google calendar frontmatter encode failed: {error}"
+            ))
+        })
+}
+
+fn json_error(error: serde_json::Error) -> LocalityError {
+    LocalityError::Io(format!("google calendar event JSON encode failed: {error}"))
+}
+
+fn escape_locality_directive_lines(value: String) -> String {
+    let mut escaped = String::with_capacity(value.len());
+    let mut line_start = 0;
+
+    while line_start < value.len() {
+        let Some((line_end, terminator_end)) = next_line_bounds(&value, line_start) else {
+            escape_locality_directive_line(&value[line_start..], &mut escaped);
+            break;
+        };
+
+        escape_locality_directive_line(&value[line_start..line_end], &mut escaped);
+        escaped.push_str(&value[line_end..terminator_end]);
+        line_start = terminator_end;
+    }
+
+    escaped
+}
+
+fn next_line_bounds(value: &str, line_start: usize) -> Option<(usize, usize)> {
+    for (offset, ch) in value[line_start..].char_indices() {
+        let index = line_start + offset;
+        match ch {
+            '\n' => return Some((index, index + ch.len_utf8())),
+            '\r' => {
+                let terminator_end = if value[index + ch.len_utf8()..].starts_with('\n') {
+                    index + "\r\n".len()
+                } else {
+                    index + ch.len_utf8()
+                };
+                return Some((index, terminator_end));
+            }
+            _ => {}
+        }
+    }
+
+    None
+}
+
+fn escape_locality_directive_line(line: &str, output: &mut String) {
+    let Some((index, _)) = line
+        .char_indices()
+        .find(|(_, ch)| !matches!(ch, ' ' | '\t'))
+    else {
+        output.push_str(line);
+        return;
+    };
+
+    if locality_directive_marker_needs_escape(&line[index..]) {
+        output.push_str(&line[..index]);
+        output.push('\\');
+        output.push_str(&line[index..]);
+    } else {
+        output.push_str(line);
+    }
+}
+
+fn locality_directive_marker_needs_escape(value: &str) -> bool {
+    value.starts_with("::loc") || value.starts_with("::afs")
+}
+
+fn quote_yaml_frontmatter_strings(yaml: &str) -> String {
+    let lines = yaml.lines().collect::<Vec<_>>();
+    let mut output = String::with_capacity(yaml.len());
+    let mut index = 0;
+    while index < lines.len() {
+        let line = lines[index];
+        if let Some((key, value)) = split_yaml_mapping_separator(line) {
+            let scalar = value.trim();
+            let key_name = key.trim().trim_start_matches("- ").trim();
+            if matches!(scalar, "|" | "|-" | "|+") {
+                let (text, next_index) = collect_yaml_block_scalar(&lines, index);
+                output.push_str(key);
+                output.push_str(": ");
+                output.push_str(&yaml_scalar(&text));
+                output.push('\n');
+                index = next_index;
+                continue;
+            }
+            if key_name != "connector" && should_quote_yaml_scalar(scalar) {
+                output.push_str(key);
+                output.push_str(": ");
+                output.push_str(&yaml_scalar(scalar));
+                output.push('\n');
+                index += 1;
+                continue;
+            }
+        }
+        output.push_str(line);
+        output.push('\n');
+        index += 1;
+    }
+    output
+}
+
+fn split_yaml_mapping_separator(line: &str) -> Option<(&str, &str)> {
+    let mut chars = line.char_indices().peekable();
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+
+    while let Some((index, ch)) = chars.next() {
+        if in_single_quote {
+            if ch == '\'' {
+                if chars.peek().is_some_and(|(_, next)| *next == '\'') {
+                    chars.next();
+                } else {
+                    in_single_quote = false;
+                }
+            }
+            continue;
+        }
+        if in_double_quote {
+            match ch {
+                '\\' => {
+                    chars.next();
+                }
+                '"' => {
+                    in_double_quote = false;
+                }
+                _ => {}
+            }
+            continue;
+        }
+
+        match ch {
+            '\'' => in_single_quote = true,
+            '"' => in_double_quote = true,
+            ':' => {
+                let value_start = index + ch.len_utf8();
+                let rest = &line[value_start..];
+                if rest.chars().next().is_none_or(|next| next.is_whitespace()) {
+                    return Some((&line[..index], rest));
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
+fn collect_yaml_block_scalar(lines: &[&str], start: usize) -> (String, usize) {
+    let key_indent = leading_space_count(lines[start]);
+    let mut index = start + 1;
+    let block_indent = lines[index..]
+        .iter()
+        .find(|line| !line.trim().is_empty())
+        .map(|line| leading_space_count(line))
+        .unwrap_or(key_indent + 2);
+    let mut block_lines = Vec::new();
+    while index < lines.len() {
+        let line = lines[index];
+        if !line.trim().is_empty() && leading_space_count(line) <= key_indent {
+            break;
+        }
+        block_lines.push(line.get(block_indent..).unwrap_or_default());
+        index += 1;
+    }
+
+    let mut text = block_lines.join("\n");
+    if lines[start].trim_end().ends_with('|') || lines[start].trim_end().ends_with("|+") {
+        text.push('\n');
+    }
+    (text, index)
+}
+
+fn leading_space_count(line: &str) -> usize {
+    line.bytes().take_while(|byte| *byte == b' ').count()
+}
+
+fn should_quote_yaml_scalar(value: &str) -> bool {
+    !value.is_empty()
+        && !matches!(value, "|" | "|-" | "|+")
+        && !matches!(value, "null" | "true" | "false" | "[]" | "{}")
+        && !value.starts_with('"')
+        && !value.starts_with('\'')
+        && !value.starts_with('[')
+        && !value.starts_with('{')
+        && value.parse::<i64>().is_err()
+        && value.parse::<f64>().is_err()
+}
+
+fn yaml_scalar(value: &str) -> String {
+    let mut escaped = String::with_capacity(value.len());
+    for ch in value.chars() {
+        match ch {
+            '\\' => escaped.push_str("\\\\"),
+            '"' => escaped.push_str("\\\""),
+            '\n' => escaped.push_str("\\n"),
+            '\r' => escaped.push_str("\\r"),
+            '\t' => escaped.push_str("\\t"),
+            ch if ch.is_control() => escaped.push_str(&format!("\\u{:04X}", u32::from(ch))),
+            ch => escaped.push(ch),
+        }
+    }
+
+    format!("\"{}\"", escaped)
+}
+
+#[cfg(test)]
+mod tests {
+    use locality_core::LocalityError;
+    use locality_core::model::RemoteId;
+    use serde_json::json;
+
+    use super::{
+        GoogleCalendarDraftDocument, parse_google_calendar_draft_document,
+        render_google_calendar_event,
+    };
+    use crate::dto::{CalendarEvent, EventDateTime};
+
+    #[test]
+    fn render_event_includes_full_event_yaml_and_uses_description_as_body() {
+        let event = CalendarEvent {
+            id: Some("event-1".to_string()),
+            etag: Some("\"etag-1\"".to_string()),
+            status: Some("confirmed".to_string()),
+            html_link: Some("https://calendar.google.com/calendar/event?eid=event-1".to_string()),
+            updated: Some("2026-07-20T17:30:00Z".to_string()),
+            summary: Some("Design review".to_string()),
+            description: Some("Agenda\n".to_string()),
+            location: Some("Room 12".to_string()),
+            start: Some(EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:00:00-07:00".to_string()),
+                time_zone: Some("America/Los_Angeles".to_string()),
+            }),
+            end: Some(EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:30:00-07:00".to_string()),
+                time_zone: Some("America/Los_Angeles".to_string()),
+            }),
+            ..CalendarEvent::default()
+        };
+
+        let rendered = render_google_calendar_event(
+            "primary",
+            &RemoteId::new("google-calendar-event:primary:event-1"),
+            &event,
+        )
+        .expect("render");
+
+        assert_eq!(rendered.document.body, "Agenda\n");
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("connector: google-calendar")
+        );
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("summary: \"Design review\"")
+        );
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("event_id: \"event-1\"")
+        );
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("html_link: \"https://calendar.google.com/calendar/event?eid=event-1\"")
+        );
+        assert!(rendered.document.frontmatter.contains("event:"));
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("description: \"Agenda\\n\"")
+        );
+        assert!(
+            rendered
+                .document
+                .frontmatter
+                .contains("dateTime: \"2026-07-20T10:00:00-07:00\"")
+        );
+        assert!(
+            rendered
+                .shadow
+                .frontmatter
+                .contains("event_id: \"event-1\"")
+        );
+    }
+
+    #[test]
+    fn render_event_escapes_literal_locality_directives_in_remote_description() {
+        let event = CalendarEvent {
+            id: Some("event-directives".to_string()),
+            summary: Some("Directive text".to_string()),
+            description: Some(
+                "::loc{id=x type=paragraph}\n  ::afs{id=y type=paragraph}\n".to_string(),
+            ),
+            ..CalendarEvent::default()
+        };
+
+        let rendered = render_google_calendar_event(
+            "primary",
+            &RemoteId::new("google-calendar-event:primary:event-directives"),
+            &event,
+        )
+        .expect("render");
+
+        assert_eq!(
+            rendered.document.body,
+            "\\::loc{id=x type=paragraph}\n  \\::afs{id=y type=paragraph}\n"
+        );
+        assert_eq!(rendered.shadow.rendered_body, rendered.document.body);
+        assert_eq!(rendered.shadow.blocks.len(), 1);
+        assert!(rendered.document.frontmatter.contains(
+            "description: \"::loc{id=x type=paragraph}\\n  ::afs{id=y type=paragraph}\\n\""
+        ));
+    }
+
+    #[test]
+    fn render_event_preserves_colon_recurrence_values_as_yaml_strings() {
+        let event = CalendarEvent {
+            id: Some("event-recurrence".to_string()),
+            summary: Some("Weekly sync".to_string()),
+            recurrence: vec!["RRULE:FREQ=WEEKLY;COUNT=2".to_string()],
+            ..CalendarEvent::default()
+        };
+
+        let rendered = render_google_calendar_event(
+            "primary",
+            &RemoteId::new("google-calendar-event:primary:event-recurrence"),
+            &event,
+        )
+        .expect("render");
+        let frontmatter: serde_json::Value =
+            yaml_serde::from_str(&rendered.document.frontmatter).expect("frontmatter yaml");
+
+        assert_eq!(
+            frontmatter.pointer("/google_calendar/event/recurrence/0"),
+            Some(&json!("RRULE:FREQ=WEEKLY;COUNT=2"))
+        );
+    }
+
+    #[test]
+    fn render_event_preserves_quoted_extra_sequence_values_with_colon_space() {
+        let mut event = CalendarEvent {
+            id: Some("event-extra".to_string()),
+            summary: Some("Extra field".to_string()),
+            ..CalendarEvent::default()
+        };
+        event
+            .extra
+            .insert("futureArray".to_string(), json!(["foo: bar"]));
+
+        let rendered = render_google_calendar_event(
+            "primary",
+            &RemoteId::new("google-calendar-event:primary:event-extra"),
+            &event,
+        )
+        .expect("render");
+        let frontmatter: serde_json::Value =
+            yaml_serde::from_str(&rendered.document.frontmatter).expect("frontmatter yaml");
+
+        assert_eq!(
+            frontmatter.pointer("/google_calendar/event/futureArray/0"),
+            Some(&json!("foo: bar"))
+        );
+    }
+
+    #[test]
+    fn parse_draft_accepts_native_timed_event_shape_and_google_meet_flag() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Design review
+location: Room 12
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+  timeZone: America/Los_Angeles
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+  timeZone: America/Los_Angeles
+attendees:
+  - email: ann@example.com
+google_calendar:
+  conference: google_meet
+"#,
+            "Agenda\n",
+        );
+
+        let draft = parse_google_calendar_draft_document(&document).expect("parse draft");
+
+        assert_eq!(draft.summary, "Design review");
+        assert_eq!(draft.description.as_deref(), Some("Agenda\n"));
+        assert_eq!(draft.location.as_deref(), Some("Room 12"));
+        assert_eq!(
+            draft.start.date_time.as_deref(),
+            Some("2026-07-20T10:00:00-07:00")
+        );
+        assert_eq!(
+            draft.end.date_time.as_deref(),
+            Some("2026-07-20T10:30:00-07:00")
+        );
+        assert_eq!(draft.attendees[0].email.as_deref(), Some("ann@example.com"));
+        assert!(draft.create_google_meet);
+    }
+
+    #[test]
+    fn parse_draft_uses_title_when_summary_is_blank() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: " "
+title: Design review
+start:
+  dateTime: "2026-07-20T10:00:00Z"
+end:
+  dateTime: "2026-07-20T10:30:00Z"
+"#,
+            "",
+        );
+
+        let draft = parse_google_calendar_draft_document(&document).expect("parse draft");
+
+        assert_eq!(draft.summary, "Design review");
+    }
+
+    #[test]
+    fn parse_draft_accepts_all_day_event_shape() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Offsite
+start:
+  date: "2026-07-20"
+end:
+  date: "2026-07-21"
+"#,
+            "",
+        );
+
+        let draft = parse_google_calendar_draft_document(&document).expect("parse draft");
+
+        assert_eq!(draft.summary, "Offsite");
+        assert_eq!(draft.start.date.as_deref(), Some("2026-07-20"));
+        assert_eq!(draft.end.date.as_deref(), Some("2026-07-21"));
+    }
+
+    #[test]
+    fn parse_draft_rejects_date_time_with_both_date_and_datetime() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Ambiguous
+start:
+  date: "2026-07-20"
+  dateTime: "2026-07-20T10:00:00-07:00"
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `start` must include exactly one of `date` or `dateTime`"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_blank_present_date_time_field() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Ambiguous
+start:
+  date: ""
+  dateTime: "2026-07-20T10:00:00Z"
+end:
+  dateTime: "2026-07-20T10:30:00Z"
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `start.date` must not be blank"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_null_present_date_field() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Ambiguous
+start:
+  date:
+  dateTime: "2026-07-20T10:00:00Z"
+end:
+  dateTime: "2026-07-20T10:30:00Z"
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `start.date` must be a non-empty string"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_null_present_date_time_field() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Ambiguous
+start:
+  date: "2026-07-20"
+  dateTime:
+end:
+  date: "2026-07-21"
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `start.dateTime` must be a non-empty string"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_mixed_all_day_and_timed_shapes() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Mixed
+start:
+  date: "2026-07-20"
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `start` and `end` must both use `date` or both use `dateTime`"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_unsupported_conference_value() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Design review
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+google_calendar:
+  conference: Google_Meet
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `google_calendar.conference` supports only `google_meet`"
+        ));
+    }
+
+    #[test]
+    fn parse_draft_rejects_blank_conference_value() {
+        let document = locality_core::model::CanonicalDocument::new(
+            r#"summary: Design review
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+google_calendar:
+  conference:
+"#,
+            "",
+        );
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft `google_calendar.conference` supports only `google_meet`"
+        ));
+    }
+
+    #[test]
+    fn draft_into_create_request_adds_google_meet_and_locality_event_id() {
+        let draft = GoogleCalendarDraftDocument {
+            summary: "Design review".to_string(),
+            description: Some("Agenda\n".to_string()),
+            location: Some("Room 12".to_string()),
+            start: EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:00:00-07:00".to_string()),
+                time_zone: None,
+            },
+            end: EventDateTime {
+                date: None,
+                date_time: Some("2026-07-20T10:30:00-07:00".to_string()),
+                time_zone: None,
+            },
+            attendees: Vec::new(),
+            recurrence: Vec::new(),
+            reminders: None,
+            transparency: None,
+            visibility: None,
+            create_google_meet: true,
+            extra: Default::default(),
+        };
+
+        let request = draft.into_create_request(
+            "locality-event-1".to_string(),
+            "conference-request-1".to_string(),
+        );
+
+        assert_eq!(
+            request.conference_data,
+            Some(json!({
+                "createRequest": {
+                    "requestId": "conference-request-1",
+                    "conferenceSolutionKey": { "type": "hangoutsMeet" }
+                }
+            }))
+        );
+        assert_eq!(
+            request.extended_properties,
+            Some(json!({
+                "private": {
+                    "locality_event_id": "locality-event-1"
+                }
+            }))
+        );
+    }
+
+    #[test]
+    fn parse_draft_reports_validation_for_missing_summary_start_and_end() {
+        let document = locality_core::model::CanonicalDocument::new("location: Room 12\n", "");
+
+        let messages = validation_messages(
+            parse_google_calendar_draft_document(&document).expect_err("invalid draft"),
+        );
+
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft requires `summary` or `title` frontmatter"
+        ));
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft requires `start` frontmatter"
+        ));
+        assert!(has_message(
+            &messages,
+            "Google Calendar draft requires `end` frontmatter"
+        ));
+    }
+
+    fn validation_messages(error: LocalityError) -> Vec<String> {
+        let LocalityError::Validation(issues) = error else {
+            panic!("expected validation error");
+        };
+        issues.into_iter().map(|issue| issue.message).collect()
+    }
+
+    fn has_message(messages: &[String], expected: &str) -> bool {
+        messages.iter().any(|message| message == expected)
+    }
+}
diff --git a/crates/locality-google-calendar/src/settings.rs b/crates/locality-google-calendar/src/settings.rs
new file mode 100644
index 00000000..674fc9ab
--- /dev/null
+++ b/crates/locality-google-calendar/src/settings.rs
@@ -0,0 +1,304 @@
+use std::fmt;
+
+use chrono::{Datelike, Duration, NaiveDate, Utc};
+use locality_core::{LocalityError, LocalityResult};
+use serde::{Deserialize, Deserializer, Serialize, de};
+
+const DEFAULT_PAST_DAYS: i64 = 30;
+const DEFAULT_FUTURE_DAYS: i64 = 180;
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct GoogleCalendarMountSettings {
+    pub google_calendar: GoogleCalendarSettings,
+}
+
+impl Default for GoogleCalendarMountSettings {
+    fn default() -> Self {
+        Self {
+            google_calendar: GoogleCalendarSettings::default(),
+        }
+    }
+}
+
+impl GoogleCalendarMountSettings {
+    pub fn from_json(value: &str) -> LocalityResult<Self> {
+        if value.trim().is_empty() {
+            return Ok(Self::default());
+        }
+        serde_json::from_str::<Self>(value).map_err(|error| {
+            LocalityError::Validation(vec![locality_core::validation::ValidationIssue::new(
+                "google_calendar_mount_settings_invalid",
+                std::path::PathBuf::new(),
+                Some(1),
+                format!("Google Calendar mount settings JSON is invalid: {error}"),
+                Some("remount Google Calendar with valid --after/--before options".to_string()),
+            )])
+        })
+    }
+
+    pub fn to_json(&self) -> LocalityResult<String> {
+        serde_json::to_string(self).map_err(|error| {
+            LocalityError::Io(format!("google calendar settings encode failed: {error}"))
+        })
+    }
+
+    pub fn with_date_window(after: &str, before: &str) -> LocalityResult<Self> {
+        Ok(Self {
+            google_calendar: GoogleCalendarSettings {
+                date_window: Some(GoogleCalendarDateWindow::new(after, before)?),
+            },
+        })
+    }
+
+    pub fn effective_date_window(&self) -> GoogleCalendarDateWindow {
+        self.google_calendar
+            .date_window
+            .clone()
+            .unwrap_or_else(GoogleCalendarDateWindow::default_for_now)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct GoogleCalendarSettings {
+    pub date_window: Option<GoogleCalendarDateWindow>,
+}
+
+impl Default for GoogleCalendarSettings {
+    fn default() -> Self {
+        Self { date_window: None }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
+pub struct GoogleCalendarDateWindow {
+    after: GoogleCalendarDate,
+    before: GoogleCalendarDate,
+}
+
+impl<'de> Deserialize<'de> for GoogleCalendarDateWindow {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct RawGoogleCalendarDateWindow {
+            after: String,
+            before: String,
+        }
+
+        let raw = RawGoogleCalendarDateWindow::deserialize(deserializer)?;
+        Self::new(&raw.after, &raw.before).map_err(|error| de::Error::custom(error_message(error)))
+    }
+}
+
+impl GoogleCalendarDateWindow {
+    pub fn new(after: &str, before: &str) -> LocalityResult<Self> {
+        let after = GoogleCalendarDate::parse(after)?;
+        let before = GoogleCalendarDate::parse(before)?;
+        if before <= after {
+            return Err(settings_validation(
+                "google_calendar_mount_date_window_order",
+                "`--before` must be later than `--after`",
+                "choose a before date after the after date",
+            ));
+        }
+        Ok(Self { after, before })
+    }
+
+    pub fn default_for_unix_day(unix_day: i64) -> Self {
+        let day = unix_epoch()
+            .checked_add_signed(Duration::days(unix_day))
+            .expect("unix day within chrono range");
+        let after = day
+            .checked_sub_signed(Duration::days(DEFAULT_PAST_DAYS))
+            .expect("default after date within chrono range");
+        let before = day
+            .checked_add_signed(Duration::days(DEFAULT_FUTURE_DAYS))
+            .expect("default before date within chrono range");
+        Self {
+            after: GoogleCalendarDate::from_naive(after),
+            before: GoogleCalendarDate::from_naive(before),
+        }
+    }
+
+    pub fn default_for_now() -> Self {
+        let today = Utc::now().date_naive();
+        let epoch = unix_epoch();
+        let unix_day = today.signed_duration_since(epoch).num_days();
+        Self::default_for_unix_day(unix_day)
+    }
+
+    pub fn after(&self) -> &GoogleCalendarDate {
+        &self.after
+    }
+
+    pub fn before(&self) -> &GoogleCalendarDate {
+        &self.before
+    }
+
+    pub fn time_min_rfc3339(&self) -> String {
+        self.after.rfc3339_midnight()
+    }
+
+    pub fn time_max_rfc3339(&self) -> String {
+        self.before.rfc3339_midnight()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize)]
+pub struct GoogleCalendarDate(String);
+
+impl<'de> Deserialize<'de> for GoogleCalendarDate {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = String::deserialize(deserializer)?;
+        Self::parse(&value).map_err(|error| de::Error::custom(error_message(error)))
+    }
+}
+
+impl GoogleCalendarDate {
+    pub fn parse(value: &str) -> LocalityResult<Self> {
+        let bytes = value.as_bytes();
+        let valid = bytes.len() == 10
+            && bytes[4] == b'-'
+            && bytes[7] == b'-'
+            && bytes
+                .iter()
+                .enumerate()
+                .all(|(index, byte)| matches!(index, 4 | 7) || byte.is_ascii_digit());
+        if !valid {
+            return Err(settings_validation(
+                "google_calendar_mount_date_invalid",
+                format!("Google Calendar date `{value}` must use YYYY-MM-DD"),
+                "use a date such as 2026-07-15",
+            ));
+        }
+        let year = value[0..4].parse::<i32>().unwrap_or(0);
+        let month = value[5..7].parse::<u32>().unwrap_or(0);
+        let day = value[8..10].parse::<u32>().unwrap_or(0);
+        if year == 0 || NaiveDate::from_ymd_opt(year, month, day).is_none() {
+            return Err(settings_validation(
+                "google_calendar_mount_date_invalid",
+                format!("Google Calendar date `{value}` is not a calendar date"),
+                "use a valid calendar date",
+            ));
+        }
+        Ok(Self(value.to_string()))
+    }
+
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+
+    fn from_naive(date: NaiveDate) -> Self {
+        Self(format!(
+            "{:04}-{:02}-{:02}",
+            date.year(),
+            date.month(),
+            date.day()
+        ))
+    }
+
+    fn rfc3339_midnight(&self) -> String {
+        format!("{}T00:00:00Z", self.0)
+    }
+}
+
+impl fmt::Display for GoogleCalendarDate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+fn unix_epoch() -> NaiveDate {
+    NaiveDate::from_ymd_opt(1970, 1, 1).expect("valid unix epoch")
+}
+
+fn settings_validation(
+    code: &'static str,
+    message: impl Into<String>,
+    suggestion: &'static str,
+) -> LocalityError {
+    LocalityError::Validation(vec![locality_core::validation::ValidationIssue::new(
+        code,
+        std::path::PathBuf::new(),
+        Some(1),
+        message,
+        Some(suggestion.to_string()),
+    )])
+}
+
+fn error_message(error: LocalityError) -> String {
+    match error {
+        LocalityError::Validation(issues) => issues
+            .into_iter()
+            .map(|issue| issue.message)
+            .collect::<Vec<_>>()
+            .join("; "),
+        other => other.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{GoogleCalendarDateWindow, GoogleCalendarMountSettings, GoogleCalendarSettings};
+
+    #[test]
+    fn explicit_date_window_serializes_to_mount_settings_json() {
+        let settings = GoogleCalendarMountSettings::with_date_window("2026-07-01", "2026-07-31")
+            .expect("valid date window");
+
+        assert_eq!(
+            settings.to_json().expect("json"),
+            r#"{"google_calendar":{"date_window":{"after":"2026-07-01","before":"2026-07-31"}}}"#
+        );
+        assert_eq!(
+            settings
+                .google_calendar
+                .date_window
+                .as_ref()
+                .expect("window")
+                .time_min_rfc3339(),
+            "2026-07-01T00:00:00Z"
+        );
+        assert_eq!(
+            settings
+                .google_calendar
+                .date_window
+                .as_ref()
+                .expect("window")
+                .time_max_rfc3339(),
+            "2026-07-31T00:00:00Z"
+        );
+    }
+
+    #[test]
+    fn default_date_window_uses_thirty_days_back_and_one_hundred_eighty_days_forward() {
+        let window = GoogleCalendarDateWindow::default_for_unix_day(20650);
+
+        assert_eq!(window.after().as_str(), "2026-06-16");
+        assert_eq!(window.before().as_str(), "2027-01-12");
+        assert_eq!(window.time_min_rfc3339(), "2026-06-16T00:00:00Z");
+        assert_eq!(window.time_max_rfc3339(), "2027-01-12T00:00:00Z");
+    }
+
+    #[test]
+    fn default_settings_store_no_date_window_and_effective_window_uses_current_default() {
+        let settings = GoogleCalendarMountSettings::default();
+
+        assert_eq!(GoogleCalendarSettings::default().date_window, None);
+        assert_eq!(settings.google_calendar.date_window, None);
+    }
+
+    #[test]
+    fn date_window_rejects_partial_invalid_and_reversed_dates() {
+        assert!(GoogleCalendarMountSettings::with_date_window("2026/07/01", "2026-07-31").is_err());
+        assert!(GoogleCalendarMountSettings::with_date_window("2026-02-30", "2026-07-31").is_err());
+        assert!(GoogleCalendarMountSettings::with_date_window("2026-07-31", "2026-07-31").is_err());
+        assert!(GoogleCalendarMountSettings::with_date_window("2026-08-01", "2026-07-31").is_err());
+    }
+}
diff --git a/crates/locality-store/tests/sqlite.rs b/crates/locality-store/tests/sqlite.rs
index 4c3fc02b..b2ec5097 100644
--- a/crates/locality-store/tests/sqlite.rs
+++ b/crates/locality-store/tests/sqlite.rs
@@ -1788,6 +1788,38 @@ fn sqlite_store_blocks_components_that_require_newer_readers() {
     assert!(matches!(error, StoreError::StateCompatibility(_)));
 }
 
+#[test]
+fn sqlite_store_blocks_newer_journal_component_versions() {
+    let fixture = SqliteFixture::new();
+    let store = fixture.open();
+    let connection = Connection::open(&store.db_path).expect("raw connection");
+    connection
+        .execute(
+            "UPDATE state_components
+             SET version = 999
+             WHERE component_id = 'durable:journals'",
+            [],
+        )
+        .expect("bump journal component");
+    drop(connection);
+    drop(store);
+
+    let report =
+        SqliteStateStore::inspect_compatibility(fixture.state_root.clone()).expect("inspect state");
+    assert_eq!(report.status, StateCompatibilityStatus::NeedsUpdate);
+    assert_eq!(
+        report.issues,
+        vec![StateCompatibilityIssue::NewerComponent {
+            component_id: "durable:journals".to_string(),
+            found: 999,
+            supported: 3,
+        }]
+    );
+
+    let error = SqliteStateStore::open(fixture.state_root.clone()).expect_err("open blocked");
+    assert!(matches!(error, StoreError::StateCompatibility(_)));
+}
+
 #[test]
 fn sqlite_store_blocks_unknown_required_components() {
     let fixture = SqliteFixture::new();
diff --git a/crates/localityd/Cargo.toml b/crates/localityd/Cargo.toml
index 460dba8c..34c9b48f 100644
--- a/crates/localityd/Cargo.toml
+++ b/crates/localityd/Cargo.toml
@@ -21,6 +21,7 @@ locality-store.workspace = true
 locality-connector.workspace = true
 locality-notion.workspace = true
 locality-google-docs.workspace = true
+locality-google-calendar.workspace = true
 locality-gmail.workspace = true
 locality-granola.workspace = true
 locality-linear.workspace = true
diff --git a/crates/localityd/src/google_calendar.rs b/crates/localityd/src/google_calendar.rs
new file mode 100644
index 00000000..e37242a1
--- /dev/null
+++ b/crates/localityd/src/google_calendar.rs
@@ -0,0 +1,505 @@
+use std::path::{Component, Path};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use locality_connector::oauth_broker::OAuthBrokerRefresh;
+use locality_connector::{Connector, FetchRequest};
+use locality_core::canonical::parse_canonical_markdown;
+use locality_core::diff::property_value_from_frontmatter;
+use locality_core::hydration::HydrationRequest;
+use locality_core::model::RemoteId;
+use locality_core::planner::PropertyValue;
+use locality_core::shadow::{ShadowDocument, segment_markdown_body};
+use locality_core::validation::{ValidationIssue, ValidationReport};
+use locality_core::{LocalityError, LocalityResult};
+use locality_google_calendar::oauth::GoogleCalendarOAuthScopeError;
+use locality_google_calendar::{
+    GOOGLE_CALENDAR_CONNECTOR_ID, GoogleCalendarConfig, GoogleCalendarConnector,
+    GoogleCalendarMountSettings, HttpGoogleCalendarOAuthBrokerClient,
+    StoredGoogleCalendarCredential,
+};
+use locality_store::{
+    ConnectionRecord, ConnectionRepository, ConnectorProfileRepository, CredentialError,
+    CredentialStore, MountConfig,
+};
+
+use crate::hydration::{HydratedEntity, HydrationSource};
+use crate::notion::ConnectorResolveError;
+use crate::source::{SourceAdapter, SourcePushValidator, SourceValidationContext};
+
+pub const GOOGLE_CALENDAR_CONNECT_COMMAND: &str = "loc connect google-calendar";
+
+pub fn resolve_google_calendar_connector_for_mount<S>(
+    store: &S,
+    credentials: &dyn CredentialStore,
+    mount: &MountConfig,
+) -> Result<GoogleCalendarConnector, ConnectorResolveError>
+where
+    S: ConnectionRepository + ConnectorProfileRepository + ?Sized,
+{
+    if mount.connector != GOOGLE_CALENDAR_CONNECTOR_ID {
+        return Err(ConnectorResolveError::UnsupportedConnector(
+            mount.connector.clone(),
+        ));
+    }
+
+    if let Some(connection_id) = &mount.connection_id {
+        let connection = store
+            .get_connection(connection_id)
+            .map_err(|error| ConnectorResolveError::CredentialStoreUnavailable(error.to_string()))?
+            .ok_or_else(|| ConnectorResolveError::MissingConnection {
+                message: format!("connection `{}` was not found", connection_id.0),
+                suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+            })?;
+        validate_connection_profile(store, &connection)?;
+        return connector_from_connection(credentials, &connection, mount);
+    }
+
+    let active = active_google_calendar_connections(store)?;
+    if active.len() == 1 {
+        validate_connection_profile(store, &active[0])?;
+        return connector_from_connection(credentials, &active[0], mount);
+    }
+
+    let message = if active.is_empty() {
+        "missing Google Calendar connection; run `loc connect google-calendar`".to_string()
+    } else {
+        "mount has no connection_id and multiple Google Calendar connections exist".to_string()
+    };
+    Err(ConnectorResolveError::MissingConnection {
+        message,
+        suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+    })
+}
+
+fn connector_from_connection(
+    credentials: &dyn CredentialStore,
+    connection: &ConnectionRecord,
+    mount: &MountConfig,
+) -> Result<GoogleCalendarConnector, ConnectorResolveError> {
+    if connection.connector != GOOGLE_CALENDAR_CONNECTOR_ID {
+        return Err(ConnectorResolveError::UnsupportedConnector(
+            connection.connector.clone(),
+        ));
+    }
+
+    if connection.status != "active" {
+        return Err(ConnectorResolveError::ConnectionRevoked {
+            connection_id: connection.connection_id.0.clone(),
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        });
+    }
+
+    if connection.auth_kind != "oauth" {
+        return Err(ConnectorResolveError::AuthRequired {
+            connection_id: connection.connection_id.0.clone(),
+            message: Some(format!(
+                "Google Calendar connection `{}` must use OAuth credentials",
+                connection.connection_id.0
+            )),
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        });
+    }
+
+    let token = connection_access_token(credentials, connection)?;
+    Ok(GoogleCalendarConnector::new(
+        google_calendar_config_from_mount(token, mount)?,
+    ))
+}
+
+fn google_calendar_config_from_mount(
+    token: String,
+    mount: &MountConfig,
+) -> Result<GoogleCalendarConfig, ConnectorResolveError> {
+    let settings =
+        GoogleCalendarMountSettings::from_json(&mount.settings_json).map_err(|error| {
+            ConnectorResolveError::CredentialStoreUnavailable(format!(
+                "Google Calendar mount `{}` settings are invalid: {}",
+                mount.mount_id.0,
+                google_calendar_settings_error_message(error)
+            ))
+        })?;
+    Ok(GoogleCalendarConfig::new(token).with_settings(settings))
+}
+
+fn google_calendar_settings_error_message(error: LocalityError) -> String {
+    match error {
+        LocalityError::Validation(issues) => issues
+            .into_iter()
+            .map(|issue| issue.message)
+            .collect::<Vec<_>>()
+            .join("; "),
+        other => other.to_string(),
+    }
+}
+
+fn connection_access_token(
+    credentials: &dyn CredentialStore,
+    connection: &ConnectionRecord,
+) -> Result<String, ConnectorResolveError> {
+    let secret = credentials
+        .get(&connection.secret_ref)
+        .map_err(|error| credential_error(connection, error))?;
+    let mut stored = serde_json::from_str::<StoredGoogleCalendarCredential>(&secret)
+        .map_err(|error| ConnectorResolveError::CredentialStoreUnavailable(error.to_string()))?;
+    if stored.expires_soon(timestamp_secs()) {
+        let refreshed = refresh_oauth_credential(connection, &stored)?;
+        stored = stored
+            .refreshed(refreshed, timestamp_secs())
+            .map_err(|error| google_calendar_refresh_scope_error(connection, error))?;
+        let secret = serde_json::to_string(&stored).map_err(|error| {
+            ConnectorResolveError::CredentialStoreUnavailable(error.to_string())
+        })?;
+        credentials
+            .put(&connection.secret_ref, &secret)
+            .map_err(|error| credential_error(connection, error))?;
+    }
+    Ok(stored.access_token)
+}
+
+fn refresh_oauth_credential(
+    connection: &ConnectionRecord,
+    stored: &StoredGoogleCalendarCredential,
+) -> Result<locality_connector::oauth_broker::OAuthBrokerToken, ConnectorResolveError> {
+    let Some(refresh_token_handle) = stored.refresh_token_handle.clone() else {
+        return Err(ConnectorResolveError::AuthRequired {
+            connection_id: connection.connection_id.0.clone(),
+            message: None,
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        });
+    };
+    let Some(broker_url) = stored.oauth_broker_url.clone() else {
+        return Err(ConnectorResolveError::AuthRequired {
+            connection_id: connection.connection_id.0.clone(),
+            message: None,
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        });
+    };
+
+    HttpGoogleCalendarOAuthBrokerClient::new(broker_url.clone())
+        .refresh_token(&OAuthBrokerRefresh {
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            refresh_token_handle: Some(refresh_token_handle),
+        })
+        .map_err(|error| google_calendar_refresh_error(connection, &broker_url, error))
+}
+
+fn google_calendar_refresh_scope_error(
+    connection: &ConnectionRecord,
+    error: GoogleCalendarOAuthScopeError,
+) -> ConnectorResolveError {
+    ConnectorResolveError::AuthRequired {
+        connection_id: connection.connection_id.0.clone(),
+        message: Some(format!(
+            "Google Calendar credential for connection `{}` could not be refreshed through OAuth broker: {error}",
+            connection.connection_id.0
+        )),
+        suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+    }
+}
+
+fn google_calendar_refresh_error(
+    connection: &ConnectionRecord,
+    broker_url: &str,
+    error: LocalityError,
+) -> ConnectorResolveError {
+    let hint = if is_loopback_broker_url(broker_url) {
+        "reconnect with the default hosted broker or keep the local broker running"
+    } else {
+        "reconnect to issue a fresh Google Calendar refresh handle"
+    };
+    ConnectorResolveError::AuthRequired {
+        connection_id: connection.connection_id.0.clone(),
+        message: Some(format!(
+            "Google Calendar credential for connection `{}` could not be refreshed through OAuth broker at `{broker_url}`: {error}; {hint}",
+            connection.connection_id.0
+        )),
+        suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+    }
+}
+
+fn is_loopback_broker_url(url: &str) -> bool {
+    let Some(authority) = url
+        .strip_prefix("http://")
+        .or_else(|| url.strip_prefix("https://"))
+    else {
+        return false;
+    };
+    let host_port = authority
+        .split(['/', '?', '#'])
+        .next()
+        .unwrap_or(authority)
+        .to_ascii_lowercase();
+    let host = if host_port.starts_with('[') {
+        host_port
+            .split(']')
+            .next()
+            .map(|value| format!("{value}]"))
+            .unwrap_or(host_port)
+    } else {
+        host_port
+            .split(':')
+            .next()
+            .unwrap_or(host_port.as_str())
+            .to_string()
+    };
+    matches!(host.as_str(), "localhost" | "127.0.0.1" | "[::1]")
+}
+
+fn active_google_calendar_connections<S>(
+    store: &S,
+) -> Result<Vec<ConnectionRecord>, ConnectorResolveError>
+where
+    S: ConnectionRepository + ?Sized,
+{
+    let connections = store
+        .list_connections()
+        .map_err(|error| ConnectorResolveError::CredentialStoreUnavailable(error.to_string()))?;
+    Ok(connections
+        .into_iter()
+        .filter(|connection| {
+            connection.connector == GOOGLE_CALENDAR_CONNECTOR_ID
+                && connection.status == "active"
+                && connection.auth_kind == "oauth"
+        })
+        .collect())
+}
+
+fn validate_connection_profile<S>(
+    store: &S,
+    connection: &ConnectionRecord,
+) -> Result<(), ConnectorResolveError>
+where
+    S: ConnectorProfileRepository + ?Sized,
+{
+    let Some(profile_id) = &connection.profile_id else {
+        return Ok(());
+    };
+    let profile = store
+        .get_connector_profile(profile_id)
+        .map_err(|error| ConnectorResolveError::CredentialStoreUnavailable(error.to_string()))?
+        .ok_or_else(|| ConnectorResolveError::AuthProfileUnavailable {
+            profile_id: profile_id.0.clone(),
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        })?;
+    if profile.status != "active"
+        || profile.connector != connection.connector
+        || profile.auth_kind != connection.auth_kind
+    {
+        return Err(ConnectorResolveError::AuthProfileUnavailable {
+            profile_id: profile.profile_id.0,
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        });
+    }
+    Ok(())
+}
+
+fn credential_error(
+    connection: &ConnectionRecord,
+    error: CredentialError,
+) -> ConnectorResolveError {
+    match error {
+        CredentialError::NotFound(_) => ConnectorResolveError::AuthRequired {
+            connection_id: connection.connection_id.0.clone(),
+            message: None,
+            suggested_command: GOOGLE_CALENDAR_CONNECT_COMMAND.to_string(),
+        },
+        CredentialError::Unavailable(message) | CredentialError::Io(message) => {
+            ConnectorResolveError::CredentialStoreUnavailable(message)
+        }
+    }
+}
+
+fn timestamp_secs() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|duration| duration.as_secs())
+        .unwrap_or(0)
+}
+
+impl SourcePushValidator for GoogleCalendarConnector {
+    fn validate_changed_frontmatter(
+        &self,
+        context: SourceValidationContext<'_>,
+    ) -> LocalityResult<ValidationReport> {
+        validate_google_calendar_changed_frontmatter(context)
+    }
+
+    fn validate_create_frontmatter(
+        &self,
+        context: SourceValidationContext<'_>,
+    ) -> LocalityResult<ValidationReport> {
+        validate_google_calendar_create_frontmatter(context)
+    }
+}
+
+impl SourceAdapter for GoogleCalendarConnector {}
+
+pub(crate) fn validate_google_calendar_changed_frontmatter(
+    context: SourceValidationContext<'_>,
+) -> LocalityResult<ValidationReport> {
+    let mut report = ValidationReport::clean();
+    if first_path_component(context.relative_path) == Some("events") {
+        report.push(ValidationIssue::new(
+            "google_calendar_events_read_only",
+            context.relative_path,
+            Some(1),
+            "Google Calendar event files are read-only",
+            Some("create a new Markdown file directly under draft/ to create an event".to_string()),
+        ));
+    }
+    Ok(report)
+}
+
+pub(crate) fn validate_google_calendar_create_frontmatter(
+    context: SourceValidationContext<'_>,
+) -> LocalityResult<ValidationReport> {
+    let mut report = ValidationReport::clean();
+
+    if !is_direct_draft_child(context.relative_path) {
+        report.push(ValidationIssue::new(
+            "google_calendar_create_outside_draft",
+            context.relative_path,
+            Some(1),
+            "Google Calendar creates are only supported directly inside draft/",
+            Some("move the new event Markdown file directly under draft/".to_string()),
+        ));
+    }
+
+    if !frontmatter_property_non_empty(&context.parsed.frontmatter.properties, "start") {
+        report.push(ValidationIssue::new(
+            "google_calendar_draft_missing_start",
+            context.relative_path,
+            Some(1),
+            "Google Calendar draft requires `start` frontmatter",
+            Some("add start frontmatter with date or dateTime".to_string()),
+        ));
+    }
+
+    if !frontmatter_property_non_empty(&context.parsed.frontmatter.properties, "end") {
+        report.push(ValidationIssue::new(
+            "google_calendar_draft_missing_end",
+            context.relative_path,
+            Some(1),
+            "Google Calendar draft requires `end` frontmatter",
+            Some("add end frontmatter with date or dateTime".to_string()),
+        ));
+    }
+
+    let has_summary = frontmatter_string(&context.parsed.frontmatter.properties, "summary")
+        .as_deref()
+        .is_some_and(|summary| !summary.trim().is_empty())
+        || context
+            .parsed
+            .frontmatter
+            .title
+            .as_deref()
+            .is_some_and(|title| !title.trim().is_empty());
+    if !has_summary {
+        report.push(ValidationIssue::new(
+            "google_calendar_draft_missing_summary",
+            context.relative_path,
+            Some(1),
+            "Google Calendar draft requires `summary` or `title` frontmatter",
+            Some("add `summary: \"Event title\"` or a non-empty `title`".to_string()),
+        ));
+    }
+
+    Ok(report)
+}
+
+fn frontmatter_property_non_empty(
+    properties: &locality_core::canonical::FrontmatterProperties,
+    key: &str,
+) -> bool {
+    properties
+        .get(key)
+        .map(property_value_from_frontmatter)
+        .is_some_and(property_value_non_empty)
+}
+
+fn property_value_non_empty(value: PropertyValue) -> bool {
+    match value {
+        PropertyValue::Null => false,
+        PropertyValue::String(value) | PropertyValue::Number(value) => !value.trim().is_empty(),
+        PropertyValue::List(values) => values.iter().any(|value| !value.trim().is_empty()),
+        PropertyValue::Array(values) => values.into_iter().any(property_value_non_empty),
+        PropertyValue::Object(values) => !values.is_empty(),
+        PropertyValue::Bool(_) => true,
+    }
+}
+
+fn frontmatter_string(
+    properties: &locality_core::canonical::FrontmatterProperties,
+    key: &str,
+) -> Option<String> {
+    properties
+        .get(key)
+        .map(property_value_from_frontmatter)
+        .and_then(|value| match value {
+            PropertyValue::String(value) => Some(value),
+            _ => None,
+        })
+}
+
+fn first_path_component(path: &Path) -> Option<&str> {
+    path.components()
+        .next()
+        .and_then(|component| match component {
+            Component::Normal(value) => value.to_str(),
+            _ => None,
+        })
+}
+
+fn is_direct_draft_child(path: &Path) -> bool {
+    let mut components = path.components();
+    matches!(
+        components.next(),
+        Some(Component::Normal(component)) if component == "draft"
+    ) && matches!(components.next(), Some(Component::Normal(_)))
+        && components.next().is_none()
+}
+
+impl HydrationSource for GoogleCalendarConnector {
+    fn fetch_render(&self, request: &HydrationRequest) -> LocalityResult<HydratedEntity> {
+        let native = self.fetch(FetchRequest {
+            remote_id: request.remote_id.clone(),
+        })?;
+        let document = self.render(&native)?;
+        let block_ids: Vec<RemoteId> = segment_markdown_body(&document.body, 1)
+            .into_iter()
+            .filter(|block| !block.is_directive())
+            .enumerate()
+            .map(|(index, _)| RemoteId::new(format!("{}:body:{index}", request.remote_id.0)))
+            .collect();
+        let shadow = ShadowDocument::from_synced_body(
+            request.remote_id.clone(),
+            document.body.clone(),
+            1,
+            block_ids,
+        )
+        .map_err(|error| LocalityError::InvalidState(error.to_string()))?
+        .with_frontmatter(document.frontmatter.clone());
+        let frontmatter = if document.frontmatter.ends_with('\n') {
+            document.frontmatter.clone()
+        } else {
+            format!("{}\n", document.frontmatter)
+        };
+        let remote_edited_at =
+            parse_canonical_markdown(&format!("---\n{frontmatter}---\n{}", document.body))
+                .ok()
+                .and_then(|parsed| parsed.frontmatter.loc.and_then(|loc| loc.remote_edited_at));
+        Ok(HydratedEntity {
+            document,
+            shadow,
+            remote_edited_at,
+            assets: Vec::new(),
+        })
+    }
+
+    fn fetch_database_schema_yaml(
+        &self,
+        _database_id: &RemoteId,
+    ) -> LocalityResult<Option<String>> {
+        Ok(None)
+    }
+}
diff --git a/crates/localityd/src/lib.rs b/crates/localityd/src/lib.rs
index e5b2f2e1..0ea6b299 100644
--- a/crates/localityd/src/lib.rs
+++ b/crates/localityd/src/lib.rs
@@ -6,6 +6,7 @@ pub mod execution;
 pub mod file_provider;
 pub mod freshness;
 pub mod gmail;
+pub mod google_calendar;
 pub mod google_docs;
 pub mod granola;
 pub mod hydration;
diff --git a/crates/localityd/src/push.rs b/crates/localityd/src/push.rs
index d15fcbbd..ae457bf4 100644
--- a/crates/localityd/src/push.rs
+++ b/crates/localityd/src/push.rs
@@ -645,7 +645,7 @@ fn resumable_plan_matches(journal: &JournalEntry, plan: &PushPlan, connector: &s
         return true;
     }
 
-    connector == "gmail"
+    create_only_effects_may_change_parent_for_connector(connector)
         && resumable_created_entity_effects(journal)
         && plan.operations.iter().all(is_create_operation)
         && journal.plan.operations.iter().all(is_create_operation)
@@ -689,7 +689,7 @@ fn resumable_entity_effect_ids(journal: &JournalEntry, connector: &str) -> Optio
                     return None;
                 }
                 if parent_id != planned_parent_id
-                    && !gmail_create_only_effects_may_change_parent(connector, &journal.plan)
+                    && !create_only_effects_may_change_parent(connector, &journal.plan)
                 {
                     return None;
                 }
@@ -743,14 +743,18 @@ fn resumable_entity_effect_ids(journal: &JournalEntry, connector: &str) -> Optio
     (seen_operations.len() == journal.plan.operations.len()).then_some(changed_remote_ids)
 }
 
-fn gmail_create_only_effects_may_change_parent(connector: &str, plan: &PushPlan) -> bool {
-    connector == "gmail"
+fn create_only_effects_may_change_parent(connector: &str, plan: &PushPlan) -> bool {
+    create_only_effects_may_change_parent_for_connector(connector)
         && plan
             .operations
             .iter()
             .all(|operation| matches!(operation, PushOperation::CreateEntity { .. }))
 }
 
+fn create_only_effects_may_change_parent_for_connector(connector: &str) -> bool {
+    matches!(connector, "gmail" | "google-calendar")
+}
+
 fn journal_created_entity_sources_match(journal: &JournalEntry, plan: &PushPlan) -> bool {
     let mut current_sources = plan_create_entity_sources(plan);
 
@@ -869,22 +873,24 @@ fn create_operation_source(operation: &PushOperation) -> Option<(&RemoteId, &Pat
 }
 
 fn auto_save_block_reason_for_prepared(prepared: &PreparedPush) -> Option<String> {
-    gmail_auto_save_block_reason(prepared).or_else(|| auto_save_block_reason(&prepared.pipeline))
+    draft_create_auto_save_block_reason(prepared)
+        .or_else(|| auto_save_block_reason(&prepared.pipeline))
 }
 
-fn gmail_auto_save_block_reason(prepared: &PreparedPush) -> Option<String> {
-    if prepared.mount.connector != "gmail" {
-        return None;
-    }
+fn draft_create_auto_save_block_reason(prepared: &PreparedPush) -> Option<String> {
     let plan = prepared.pipeline.plan.as_ref()?;
-    if plan
+    if !plan
         .operations
         .iter()
         .any(|operation| matches!(operation, PushOperation::CreateEntity { .. }))
     {
-        return Some("Gmail draft sends require review".to_string());
+        return None;
+    }
+    match prepared.mount.connector.as_str() {
+        "gmail" => Some("Gmail draft sends require review".to_string()),
+        "google-calendar" => Some("Google Calendar event creates require review".to_string()),
+        _ => None,
     }
-    None
 }
 
 fn created_entity_id(report: &PushJobReport) -> Option<RemoteId> {
@@ -3393,12 +3399,14 @@ fn create_entity_title_required(
     parsed: &locality_core::canonical::ParsedCanonicalDocument,
     mount: &MountConfig,
 ) -> bool {
-    mount.connector != "gmail"
-        && parsed
-            .frontmatter
-            .title
-            .as_ref()
-            .is_none_or(|title| title.trim().is_empty())
+    if matches!(mount.connector.as_str(), "gmail" | "google-calendar") {
+        return false;
+    }
+    parsed
+        .frontmatter
+        .title
+        .as_ref()
+        .is_none_or(|title| title.trim().is_empty())
 }
 
 fn create_entity_title(
@@ -3417,6 +3425,12 @@ fn create_entity_title(
     {
         return subject.trim().to_string();
     }
+    if mount.connector == "google-calendar"
+        && let Some(summary) = frontmatter_string(&parsed.frontmatter.properties, "summary")
+        && !summary.trim().is_empty()
+    {
+        return summary.trim().to_string();
+    }
     relative_path
         .file_stem()
         .and_then(|stem| stem.to_str())
@@ -3764,7 +3778,7 @@ where
                         entity_path,
                     )
                     .with_hydration(HydrationState::Stub);
-                    let rendered = self.source.fetch_render_with_repository(
+                    let mut rendered = self.source.fetch_render_with_repository(
                         &locality_core::hydration::HydrationRequest::new(
                             request.mount_id.clone(),
                             entity_id.clone(),
@@ -3774,7 +3788,7 @@ where
                         ),
                         &*self.store,
                     )?;
-                    entity.path = created_entity_reconcile_path_from_rendered(
+                    let rendered_path = created_entity_reconcile_path_from_rendered(
                         self.store,
                         request.mount_id,
                         &entity.path,
@@ -3783,6 +3797,21 @@ where
                         entity_id,
                         &rendered,
                     )?;
+                    if rendered_path != entity.path {
+                        entity.path = rendered_path;
+                        rendered = self.source.fetch_render_with_repository(
+                            &locality_core::hydration::HydrationRequest::new(
+                                request.mount_id.clone(),
+                                entity_id.clone(),
+                                entity.path.clone(),
+                                HydrationState::Hydrated,
+                                locality_core::hydration::HydrationReason::ExplicitPull,
+                            ),
+                            &*self.store,
+                        )?;
+                    } else {
+                        entity.path = rendered_path;
+                    }
                     effect_readback_ids.insert(entity_id.clone());
                     created_readbacks.push((*operation_index, entity_id.clone(), entity, rendered));
                 }
@@ -3989,6 +4018,9 @@ where
     if let Some(filename) = gmail_rendered_message_filename(entity_id, rendered) {
         return Ok(parent.path.join(filename));
     }
+    if let Some(filename) = google_calendar_rendered_event_filename(entity_id, rendered) {
+        return Ok(parent.path.join(filename));
+    }
 
     Ok(current_path.to_path_buf())
 }
@@ -4021,9 +4053,9 @@ fn gmail_rendered_message_filename(
 
     Some(format!(
         "{}-{}-{}.md",
-        gmail_safe_slug(internal_date),
-        gmail_safe_slug(title),
-        gmail_safe_slug(entity_id.as_str())
+        created_entity_safe_slug(internal_date),
+        created_entity_safe_slug(title),
+        created_entity_safe_slug(entity_id.as_str())
     ))
 }
 
@@ -4039,7 +4071,88 @@ fn gmail_internal_date<'a>(entity_id: &RemoteId, remote_version: &'a str) -> Opt
     })
 }
 
-fn gmail_safe_slug(value: &str) -> String {
+fn google_calendar_rendered_event_filename(
+    entity_id: &RemoteId,
+    rendered: &HydratedEntity,
+) -> Option<String> {
+    let rendered_markdown = render_canonical_markdown(&rendered.document);
+    let parsed = parse_canonical_markdown(&rendered_markdown).ok()?;
+    let event_id = google_calendar_frontmatter_event_id(&parsed.frontmatter.properties)
+        .or_else(|| google_calendar_event_id_from_remote_id(entity_id))?;
+    let start = google_calendar_start_value(&parsed.frontmatter.properties)?;
+    let summary = frontmatter_string(&parsed.frontmatter.properties, "summary");
+    let title = parsed
+        .frontmatter
+        .title
+        .as_deref()
+        .or(summary.as_deref())
+        .map(str::trim)
+        .filter(|title| !title.is_empty())
+        .unwrap_or("untitled");
+
+    Some(format!(
+        "{}-{}-{}.md",
+        google_calendar_compact_start_prefix(&start),
+        created_entity_safe_slug(title),
+        created_entity_safe_slug(&event_id)
+    ))
+}
+
+fn google_calendar_frontmatter_event_id(
+    properties: &locality_core::canonical::FrontmatterProperties,
+) -> Option<String> {
+    let PropertyValue::Object(google_calendar) = properties
+        .get("google_calendar")
+        .map(property_value_from_frontmatter)?
+    else {
+        return None;
+    };
+    match google_calendar.get("event_id") {
+        Some(PropertyValue::String(value)) if !value.trim().is_empty() => {
+            Some(value.trim().to_string())
+        }
+        _ => None,
+    }
+}
+
+fn google_calendar_start_value(
+    properties: &locality_core::canonical::FrontmatterProperties,
+) -> Option<String> {
+    let PropertyValue::Object(start) = properties
+        .get("start")
+        .map(property_value_from_frontmatter)?
+    else {
+        return None;
+    };
+    match start.get("dateTime").or_else(|| start.get("date")) {
+        Some(PropertyValue::String(value)) if !value.trim().is_empty() => {
+            Some(value.trim().to_string())
+        }
+        _ => None,
+    }
+}
+
+fn google_calendar_event_id_from_remote_id(entity_id: &RemoteId) -> Option<String> {
+    entity_id
+        .as_str()
+        .strip_prefix("google-calendar-event:")
+        .and_then(|rest| rest.split_once(':'))
+        .and_then(|(_, event_id)| (!event_id.is_empty()).then(|| event_id.to_string()))
+}
+
+fn google_calendar_compact_start_prefix(sort_start_key: &str) -> String {
+    let mut digits = sort_start_key
+        .chars()
+        .filter(|ch| ch.is_ascii_digit())
+        .take(14)
+        .collect::<String>();
+    while digits.len() < 14 {
+        digits.push('0');
+    }
+    format!("{}-{}", &digits[..8], &digits[8..14])
+}
+
+fn created_entity_safe_slug(value: &str) -> String {
     let mut slug = String::new();
     let mut last_was_dash = false;
     for ch in value.chars().flat_map(char::to_lowercase) {
@@ -4078,9 +4191,9 @@ fn remove_stale_created_entity_source_path(
         return Ok(true);
     }
 
-    // A Gmail draft may have been edited after the send succeeded but before
-    // reconciliation finished. Preserve that edited draft as a new pending send.
-    if mount.connector == "gmail"
+    // Draft creates may have been edited after apply succeeded but before
+    // reconciliation finished. Preserve edited drafts as new pending creates.
+    if preserves_edited_created_entity_source(mount)
         && !created_entity_source_matches_plan(
             mount,
             source_path,
@@ -4100,6 +4213,10 @@ fn remove_stale_created_entity_source_path(
     }
 }
 
+fn preserves_edited_created_entity_source(mount: &MountConfig) -> bool {
+    matches!(mount.connector.as_str(), "gmail" | "google-calendar")
+}
+
 fn created_entity_source_matches_plan(
     mount: &MountConfig,
     source_path: &Path,
diff --git a/crates/localityd/src/source.rs b/crates/localityd/src/source.rs
index 07393235..1f21301f 100644
--- a/crates/localityd/src/source.rs
+++ b/crates/localityd/src/source.rs
@@ -25,6 +25,7 @@ use locality_core::shadow::ShadowDocument;
 use locality_core::validation::ValidationReport;
 use locality_core::{LocalityError, LocalityResult};
 use locality_gmail::{GMAIL_CONNECTOR_ID, GmailConnector};
+use locality_google_calendar::{GOOGLE_CALENDAR_CONNECTOR_ID, GoogleCalendarConnector};
 use locality_google_docs::{GOOGLE_DOCS_CONNECTOR_ID, GoogleDocsConnector};
 use locality_granola::{GRANOLA_CONNECTOR_ID, GranolaConnector};
 use locality_linear::{LINEAR_CONNECTOR_ID, LinearConnector};
@@ -37,6 +38,7 @@ use locality_store::{
 
 use crate::file_provider;
 use crate::gmail::resolve_gmail_connector_for_mount;
+use crate::google_calendar::resolve_google_calendar_connector_for_mount;
 use crate::google_docs::resolve_google_docs_connector_for_mount;
 use crate::granola::resolve_granola_connector_for_mount;
 use crate::hydration::{HydratedEntity, HydrationRepository, HydrationSource};
@@ -50,6 +52,7 @@ const NOTION_AGENT_GUIDANCE: &str = include_str!("../../../templates/mount/AGENT
 pub enum ResolvedSource {
     Notion(NotionConnector),
     GoogleDocs(GoogleDocsConnector),
+    GoogleCalendar(GoogleCalendarConnector),
     Gmail(GmailConnector),
     Granola(GranolaConnector),
     Linear(LinearConnector),
@@ -60,6 +63,9 @@ impl ResolvedSource {
         match self {
             Self::Notion(source) => Self::Notion(source.with_execution_policy(policy)),
             Self::GoogleDocs(source) => Self::GoogleDocs(source.with_execution_policy(policy)),
+            Self::GoogleCalendar(source) => {
+                Self::GoogleCalendar(source.with_execution_policy(policy))
+            }
             Self::Gmail(source) => Self::Gmail(source.with_execution_policy(policy)),
             Self::Granola(source) => Self::Granola(source.with_execution_policy(policy)),
             Self::Linear(source) => Self::Linear(source.with_execution_policy(policy)),
@@ -108,6 +114,15 @@ const SOURCE_REGISTRY: &[SourceRegistration] = &[
         validate_changed_frontmatter: crate::google_docs::validate_google_docs_frontmatter,
         validate_create_frontmatter: crate::google_docs::validate_google_docs_frontmatter,
     },
+    SourceRegistration {
+        id: GOOGLE_CALENDAR_CONNECTOR_ID,
+        descriptor: google_calendar_source_descriptor,
+        resolve: resolve_google_calendar_source,
+        validate_changed_frontmatter:
+            crate::google_calendar::validate_google_calendar_changed_frontmatter,
+        validate_create_frontmatter:
+            crate::google_calendar::validate_google_calendar_create_frontmatter,
+    },
     SourceRegistration {
         id: GMAIL_CONNECTOR_ID,
         descriptor: gmail_source_descriptor,
@@ -262,6 +277,9 @@ pub fn source_write_decision_for_path(
     if mount.connector == "gmail" {
         return gmail_write_decision_for_path(relative_path);
     }
+    if mount.connector == GOOGLE_CALENDAR_CONNECTOR_ID {
+        return google_calendar_write_decision_for_path(relative_path);
+    }
     if mount.connector == GRANOLA_CONNECTOR_ID {
         return SourceWriteDecision::ReadOnly {
             reason: "Granola meetings are read-only",
@@ -288,6 +306,15 @@ pub fn source_create_decision_for_parent_path(
             }
         };
     }
+    if mount.connector == GOOGLE_CALENDAR_CONNECTOR_ID {
+        return if parent_path == Path::new("draft") {
+            SourceWriteDecision::Writable
+        } else {
+            SourceWriteDecision::ReadOnly {
+                reason: "Google Calendar creates are only supported directly inside draft/",
+            }
+        };
+    }
     if mount.connector == GRANOLA_CONNECTOR_ID {
         return SourceWriteDecision::ReadOnly {
             reason: "Granola meetings are read-only",
@@ -378,6 +405,25 @@ fn google_docs_source_descriptor() -> SourceDescriptor {
     }
 }
 
+fn google_calendar_source_descriptor() -> SourceDescriptor {
+    SourceDescriptor {
+        id: Cow::Borrowed(GOOGLE_CALENDAR_CONNECTOR_ID),
+        display_name: Cow::Borrowed("Google Calendar"),
+        default_mount_id: Cow::Borrowed("google-calendar-main"),
+        connect_command: Some(Cow::Borrowed("loc connect google-calendar")),
+        auth_env_var: None,
+        supports_oauth: true,
+        mount_guidance: Cow::Owned(google_calendar_mount_guidance()),
+        source_root_create_parent_kind: None,
+        create_entity_parent_kinds: vec![EntityKind::Directory],
+        move_entity_parent_kinds: Vec::new(),
+        periodic_discovery_interval: None,
+        body_diff_mode: BodyDiffMode::Block,
+        virtual_rename_policy: VirtualRenamePolicy::FilenameDerived,
+        max_background_discovery_workers: 4,
+    }
+}
+
 fn gmail_source_descriptor() -> SourceDescriptor {
     SourceDescriptor {
         id: Cow::Borrowed(GMAIL_CONNECTOR_ID),
@@ -433,6 +479,15 @@ fn resolve_google_docs_source(
         .map(ResolvedSource::GoogleDocs)
 }
 
+fn resolve_google_calendar_source(
+    store: &dyn SourceResolverStore,
+    credentials: &dyn CredentialStore,
+    mount: &MountConfig,
+) -> Result<ResolvedSource, ConnectorResolveError> {
+    resolve_google_calendar_connector_for_mount(store, credentials, mount)
+        .map(ResolvedSource::GoogleCalendar)
+}
+
 fn resolve_gmail_source(
     store: &dyn SourceResolverStore,
     credentials: &dyn CredentialStore,
@@ -513,6 +568,30 @@ fn gmail_write_decision_for_path(relative_path: &Path) -> SourceWriteDecision {
     }
 }
 
+fn google_calendar_write_decision_for_path(relative_path: &Path) -> SourceWriteDecision {
+    let mut components = relative_path.components();
+    match components.next().and_then(|component| match component {
+        std::path::Component::Normal(value) => value.to_str(),
+        _ => None,
+    }) {
+        Some("draft") => match components.next() {
+            None => SourceWriteDecision::Writable,
+            Some(std::path::Component::Normal(_)) if components.next().is_none() => {
+                SourceWriteDecision::Writable
+            }
+            _ => SourceWriteDecision::ReadOnly {
+                reason: "Google Calendar writes are only supported under draft/",
+            },
+        },
+        Some("events") => SourceWriteDecision::ReadOnly {
+            reason: "Google Calendar event files are read-only",
+        },
+        _ => SourceWriteDecision::ReadOnly {
+            reason: "Google Calendar writes are only supported under draft/",
+        },
+    }
+}
+
 fn generic_display_name(connector: &str) -> String {
     match connector {
         "linear" => "Linear".to_string(),
@@ -560,6 +639,17 @@ Gmail facts:\n\
     )
 }
 
+fn google_calendar_mount_guidance() -> String {
+    format!(
+        "{}\n\
+Google Calendar facts:\n\
+- This mount projects the primary calendar as events/ and draft/ folders.\n\
+- events/ is read-only. Create a Markdown file directly under draft/ to create an event.\n\
+- Draft creates require `start`, `end`, and either `summary` or `title` frontmatter.\n",
+        generic_mount_guidance("Google Calendar")
+    )
+}
+
 fn granola_mount_guidance() -> String {
     "# Locality Granola Mount\n\n\
 These instructions apply to every file under this mount.\n\n\
@@ -709,6 +799,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.kind(),
             Self::GoogleDocs(source) => source.kind(),
+            Self::GoogleCalendar(source) => source.kind(),
             Self::Gmail(source) => source.kind(),
             Self::Granola(source) => source.kind(),
             Self::Linear(source) => source.kind(),
@@ -719,6 +810,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.capabilities(),
             Self::GoogleDocs(source) => source.capabilities(),
+            Self::GoogleCalendar(source) => source.capabilities(),
             Self::Gmail(source) => source.capabilities(),
             Self::Granola(source) => source.capabilities(),
             Self::Linear(source) => source.capabilities(),
@@ -729,6 +821,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.supported_push_operations(),
             Self::GoogleDocs(source) => source.supported_push_operations(),
+            Self::GoogleCalendar(source) => source.supported_push_operations(),
             Self::Gmail(source) => source.supported_push_operations(),
             Self::Granola(source) => source.supported_push_operations(),
             Self::Linear(source) => source.supported_push_operations(),
@@ -739,6 +832,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.enumerate(request),
             Self::GoogleDocs(source) => source.enumerate(request),
+            Self::GoogleCalendar(source) => source.enumerate(request),
             Self::Gmail(source) => source.enumerate(request),
             Self::Granola(source) => source.enumerate(request),
             Self::Linear(source) => source.enumerate(request),
@@ -749,6 +843,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.observe(request),
             Self::GoogleDocs(source) => source.observe(request),
+            Self::GoogleCalendar(source) => source.observe(request),
             Self::Gmail(source) => source.observe(request),
             Self::Granola(source) => source.observe(request),
             Self::Linear(source) => source.observe(request),
@@ -759,6 +854,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.observe_batch(request),
             Self::GoogleDocs(source) => source.observe_batch(request),
+            Self::GoogleCalendar(source) => source.observe_batch(request),
             Self::Gmail(source) => source.observe_batch(request),
             Self::Granola(source) => source.observe_batch(request),
             Self::Linear(source) => source.observe_batch(request),
@@ -769,6 +865,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.list_children(request),
             Self::GoogleDocs(source) => source.list_children(request),
+            Self::GoogleCalendar(source) => source.list_children(request),
             Self::Gmail(source) => source.list_children(request),
             Self::Granola(source) => source.list_children(request),
             Self::Linear(source) => source.list_children(request),
@@ -779,6 +876,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.fetch(request),
             Self::GoogleDocs(source) => source.fetch(request),
+            Self::GoogleCalendar(source) => source.fetch(request),
             Self::Gmail(source) => source.fetch(request),
             Self::Granola(source) => source.fetch(request),
             Self::Linear(source) => source.fetch(request),
@@ -789,6 +887,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.render(entity),
             Self::GoogleDocs(source) => source.render(entity),
+            Self::GoogleCalendar(source) => source.render(entity),
             Self::Gmail(source) => source.render(entity),
             Self::Granola(source) => source.render(entity),
             Self::Linear(source) => source.render(entity),
@@ -799,6 +898,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.parse(document),
             Self::GoogleDocs(source) => source.parse(document),
+            Self::GoogleCalendar(source) => source.parse(document),
             Self::Gmail(source) => source.parse(document),
             Self::Granola(source) => source.parse(document),
             Self::Linear(source) => source.parse(document),
@@ -809,6 +909,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.check_concurrency(request),
             Self::GoogleDocs(source) => source.check_concurrency(request),
+            Self::GoogleCalendar(source) => source.check_concurrency(request),
             Self::Gmail(source) => source.check_concurrency(request),
             Self::Granola(source) => source.check_concurrency(request),
             Self::Linear(source) => source.check_concurrency(request),
@@ -819,6 +920,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.apply(request),
             Self::GoogleDocs(source) => source.apply(request),
+            Self::GoogleCalendar(source) => source.apply(request),
             Self::Gmail(source) => source.apply(request),
             Self::Granola(source) => source.apply(request),
             Self::Linear(source) => source.apply(request),
@@ -829,6 +931,7 @@ impl Connector for ResolvedSource {
         match self {
             Self::Notion(source) => source.apply_undo(request),
             Self::GoogleDocs(source) => source.apply_undo(request),
+            Self::GoogleCalendar(source) => source.apply_undo(request),
             Self::Gmail(source) => source.apply_undo(request),
             Self::Granola(source) => source.apply_undo(request),
             Self::Linear(source) => source.apply_undo(request),
@@ -841,6 +944,7 @@ impl HydrationSource for ResolvedSource {
         match self {
             Self::Notion(source) => source.fetch_render(request),
             Self::GoogleDocs(source) => source.fetch_render(request),
+            Self::GoogleCalendar(source) => source.fetch_render(request),
             Self::Gmail(source) => source.fetch_render(request),
             Self::Granola(source) => source.fetch_render(request),
             Self::Linear(source) => source.fetch_render(request),
@@ -855,6 +959,9 @@ impl HydrationSource for ResolvedSource {
         match self {
             Self::Notion(source) => source.fetch_render_with_repository(request, repository),
             Self::GoogleDocs(source) => source.fetch_render_with_repository(request, repository),
+            Self::GoogleCalendar(source) => {
+                source.fetch_render_with_repository(request, repository)
+            }
             Self::Gmail(source) => source.fetch_render_with_repository(request, repository),
             Self::Granola(source) => source.fetch_render_with_repository(request, repository),
             Self::Linear(source) => source.fetch_render_with_repository(request, repository),
@@ -865,6 +972,7 @@ impl HydrationSource for ResolvedSource {
         match self {
             Self::Notion(source) => source.fetch_database_schema_yaml(database_id),
             Self::GoogleDocs(source) => source.fetch_database_schema_yaml(database_id),
+            Self::GoogleCalendar(source) => source.fetch_database_schema_yaml(database_id),
             Self::Gmail(source) => source.fetch_database_schema_yaml(database_id),
             Self::Granola(source) => source.fetch_database_schema_yaml(database_id),
             Self::Linear(source) => source.fetch_database_schema_yaml(database_id),
@@ -919,6 +1027,7 @@ impl SourcePushValidator for ResolvedSource {
         match self {
             Self::Notion(source) => source.validate_changed_frontmatter(context),
             Self::GoogleDocs(source) => source.validate_changed_frontmatter(context),
+            Self::GoogleCalendar(source) => source.validate_changed_frontmatter(context),
             Self::Gmail(source) => source.validate_changed_frontmatter(context),
             Self::Granola(source) => source.validate_changed_frontmatter(context),
             Self::Linear(source) => source.validate_changed_frontmatter(context),
@@ -932,6 +1041,7 @@ impl SourcePushValidator for ResolvedSource {
         match self {
             Self::Notion(source) => source.validate_create_frontmatter(context),
             Self::GoogleDocs(source) => source.validate_create_frontmatter(context),
+            Self::GoogleCalendar(source) => source.validate_create_frontmatter(context),
             Self::Gmail(source) => source.validate_create_frontmatter(context),
             Self::Granola(source) => source.validate_create_frontmatter(context),
             Self::Linear(source) => source.validate_create_frontmatter(context),
@@ -947,6 +1057,7 @@ impl SourceAdapter for ResolvedSource {
         match self {
             Self::Notion(source) => Self::Notion(source.scoped_to_mount(mount)),
             Self::GoogleDocs(source) => Self::GoogleDocs(source.scoped_to_mount(mount)),
+            Self::GoogleCalendar(source) => Self::GoogleCalendar(source.scoped_to_mount(mount)),
             Self::Gmail(source) => Self::Gmail(source.scoped_to_mount(mount)),
             Self::Granola(source) => Self::Granola(source.scoped_to_mount(mount)),
             Self::Linear(source) => Self::Linear(source.scoped_to_mount(mount)),
@@ -957,6 +1068,9 @@ impl SourceAdapter for ResolvedSource {
         match self {
             Self::Notion(source) => SourceAdapter::database_schema_yaml(source, database_id),
             Self::GoogleDocs(source) => SourceAdapter::database_schema_yaml(source, database_id),
+            Self::GoogleCalendar(source) => {
+                SourceAdapter::database_schema_yaml(source, database_id)
+            }
             Self::Gmail(source) => SourceAdapter::database_schema_yaml(source, database_id),
             Self::Granola(source) => SourceAdapter::database_schema_yaml(source, database_id),
             Self::Linear(source) => SourceAdapter::database_schema_yaml(source, database_id),
diff --git a/crates/localityd/src/virtual_fs.rs b/crates/localityd/src/virtual_fs.rs
index 7a706853..6a78ba5a 100644
--- a/crates/localityd/src/virtual_fs.rs
+++ b/crates/localityd/src/virtual_fs.rs
@@ -4425,6 +4425,56 @@ mod tests {
         assert!(page_child.read_only);
     }
 
+    #[test]
+    fn google_calendar_folder_read_only_metadata_reflects_direct_draft_create_policy() {
+        let mount_id = MountId::new("google-calendar-main");
+        let mut store = InMemoryStateStore::new();
+        store
+            .save_mount(virtual_mount_with_connector(&mount_id, "google-calendar"))
+            .expect("save mount");
+        for (remote_id, title, path) in [
+            ("google-calendar-folder:draft", "draft", "draft"),
+            ("google-calendar-folder:events", "events", "events"),
+            (
+                "google-calendar-folder:draft/nested",
+                "nested",
+                "draft/nested",
+            ),
+        ] {
+            store
+                .save_entity(EntityRecord {
+                    mount_id: mount_id.clone(),
+                    remote_id: RemoteId::new(remote_id),
+                    kind: EntityKind::Directory,
+                    title: title.to_string(),
+                    path: path.into(),
+                    hydration: HydrationState::Stub,
+                    content_hash: None,
+                    remote_edited_at: Some(format!("folder:{path}")),
+                })
+                .expect("save folder");
+        }
+
+        assert!(
+            !virtual_fs_item(&store, &mount_id, "google-calendar-folder:draft")
+                .expect("draft item")
+                .item
+                .read_only
+        );
+        assert!(
+            virtual_fs_item(&store, &mount_id, "google-calendar-folder:events")
+                .expect("events item")
+                .item
+                .read_only
+        );
+        assert!(
+            virtual_fs_item(&store, &mount_id, "google-calendar-folder:draft/nested")
+                .expect("nested draft folder item")
+                .item
+                .read_only
+        );
+    }
+
     #[test]
     fn source_folder_read_only_metadata_reflects_create_parent_kinds() {
         let notion_mount_id = MountId::new("notion-main");
diff --git a/crates/localityd/tests/push_execution.rs b/crates/localityd/tests/push_execution.rs
index ad631c5d..f5f673e9 100644
--- a/crates/localityd/tests/push_execution.rs
+++ b/crates/localityd/tests/push_execution.rs
@@ -1049,6 +1049,418 @@ fn daemon_push_reconciles_sent_gmail_draft_create_to_sent_folder() {
     );
 }
 
+#[test]
+fn daemon_push_reconciles_google_calendar_draft_create_to_canonical_event_filename() {
+    let fixture = PushFixture::new();
+    let state_root = fixture.root.join(".state");
+    let source_path = Path::new("draft/design-review.md");
+    let content_root = virtual_fs_content_root(&state_root, &fixture.mount_id);
+    let cache_path =
+        virtual_fs_content_path(&state_root, &fixture.mount_id, source_path).expect("cache path");
+    fs::create_dir_all(cache_path.parent().expect("cache parent")).expect("cache parent");
+    fs::write(
+        &cache_path,
+        "---\ntitle: Design review\nsummary: Design review\nstart:\n  dateTime: \"2026-07-20T10:00:00-07:00\"\nend:\n  dateTime: \"2026-07-20T10:30:00-07:00\"\n---\nAgenda\n",
+    )
+    .expect("cache file");
+
+    let draft_folder_id = RemoteId::new("google-calendar-folder:draft");
+    let events_folder_id = RemoteId::new("google-calendar-folder:events");
+    let created_remote_id = RemoteId::new("google-calendar-event:primary:created-event");
+    let expected_path = PathBuf::from("events/20260720-100000-design-review-created-event.md");
+    let mut store = InMemoryStateStore::new();
+    store
+        .save_mount(
+            MountConfig::new(fixture.mount_id.clone(), "google-calendar", &fixture.root)
+                .projection(ProjectionMode::LinuxFuse),
+        )
+        .expect("save mount");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            draft_folder_id.clone(),
+            EntityKind::Directory,
+            "draft",
+            "draft",
+        ))
+        .expect("save draft folder");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            events_folder_id.clone(),
+            EntityKind::Directory,
+            "events",
+            "events",
+        ))
+        .expect("save events folder");
+    store
+        .save_virtual_mutation(virtual_mutation(
+            &fixture.mount_id,
+            "local:calendar-draft",
+            VirtualMutationKind::Create,
+            None,
+            Some(draft_folder_id),
+            "draft/design-review.md",
+            Some(cache_path),
+        ))
+        .expect("save mutation");
+    let source = FakePushSource::default()
+        .with_created_entity(
+            created_remote_id.clone(),
+            rendered_google_calendar_entity(
+                "google-calendar-event:primary:created-event",
+                "Design review",
+                "2026-07-20T10:00:00-07:00",
+                "Agenda",
+            ),
+        )
+        .with_apply_effects(vec![JournalApplyEffect::CreatedEntity {
+            operation_id: PushOperationId("create-calendar-draft".to_string()),
+            operation_index: 0,
+            parent_id: events_folder_id,
+            entity_id: created_remote_id.clone(),
+        }]);
+
+    let report = execute_push_job_with_content_root(
+        &mut store,
+        PushJob {
+            target_path: fixture.root.join(source_path),
+            assume_yes: true,
+            confirm_dangerous: false,
+        },
+        &source,
+        Some(&state_root),
+    )
+    .expect("push google calendar draft");
+
+    assert_eq!(report.action, PushJobAction::Reconciled);
+    let event = store
+        .get_entity(&fixture.mount_id, &created_remote_id)
+        .expect("get created event")
+        .expect("created event entity");
+    assert_eq!(event.path, expected_path);
+    let requested_paths = source.requested_paths();
+    assert_eq!(
+        requested_paths,
+        vec![
+            PathBuf::from("events/design-review.md"),
+            expected_path.clone()
+        ]
+    );
+    assert_eq!(requested_paths.last(), Some(&expected_path));
+    assert!(content_root.join(&expected_path).exists());
+    assert!(!content_root.join(source_path).exists());
+    assert!(
+        store
+            .find_virtual_mutation_by_path(&fixture.mount_id, source_path)
+            .expect("find mutation")
+            .is_none()
+    );
+}
+
+#[test]
+fn daemon_push_accepts_google_calendar_summary_only_draft_create() {
+    let fixture = PushFixture::new();
+    let state_root = fixture.root.join(".state");
+    let source_path = Path::new("draft/summary-only.md");
+    let cache_path =
+        virtual_fs_content_path(&state_root, &fixture.mount_id, source_path).expect("cache path");
+    fs::create_dir_all(cache_path.parent().expect("cache parent")).expect("cache parent");
+    fs::write(
+        &cache_path,
+        "---\nsummary: Summary only review\nstart:\n  dateTime: \"2026-07-20T10:00:00-07:00\"\nend:\n  dateTime: \"2026-07-20T10:30:00-07:00\"\n---\nAgenda\n",
+    )
+    .expect("cache file");
+
+    let draft_folder_id = RemoteId::new("google-calendar-folder:draft");
+    let events_folder_id = RemoteId::new("google-calendar-folder:events");
+    let created_remote_id = RemoteId::new("google-calendar-event:primary:summary-only-event");
+    let mut store = InMemoryStateStore::new();
+    store
+        .save_mount(
+            MountConfig::new(fixture.mount_id.clone(), "google-calendar", &fixture.root)
+                .projection(ProjectionMode::LinuxFuse),
+        )
+        .expect("save mount");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            draft_folder_id.clone(),
+            EntityKind::Directory,
+            "draft",
+            "draft",
+        ))
+        .expect("save draft folder");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            events_folder_id.clone(),
+            EntityKind::Directory,
+            "events",
+            "events",
+        ))
+        .expect("save events folder");
+    store
+        .save_virtual_mutation(virtual_mutation(
+            &fixture.mount_id,
+            "local:calendar-summary-only-draft",
+            VirtualMutationKind::Create,
+            None,
+            Some(draft_folder_id),
+            "draft/summary-only.md",
+            Some(cache_path),
+        ))
+        .expect("save mutation");
+    let source = FakePushSource::default()
+        .with_created_entity(
+            created_remote_id.clone(),
+            rendered_google_calendar_entity(
+                "google-calendar-event:primary:summary-only-event",
+                "Summary only review",
+                "2026-07-20T10:00:00-07:00",
+                "Agenda",
+            ),
+        )
+        .with_apply_effects(vec![JournalApplyEffect::CreatedEntity {
+            operation_id: PushOperationId("create-calendar-summary-only-draft".to_string()),
+            operation_index: 0,
+            parent_id: events_folder_id,
+            entity_id: created_remote_id,
+        }]);
+
+    let report = execute_push_job_with_content_root(
+        &mut store,
+        PushJob {
+            target_path: fixture.root.join(source_path),
+            assume_yes: true,
+            confirm_dangerous: false,
+        },
+        &source,
+        Some(&state_root),
+    )
+    .expect("push summary-only google calendar draft");
+
+    assert_eq!(report.action, PushJobAction::Reconciled);
+    let journal = store.list_journal().expect("journal");
+    assert_eq!(journal.len(), 1);
+    let PushOperation::CreateEntity { title, .. } = &journal[0].plan.operations[0] else {
+        panic!("expected create entity operation");
+    };
+    assert_eq!(title, "Summary only review");
+}
+
+#[test]
+fn daemon_push_preserves_edited_google_calendar_draft_after_create_reconcile_retry() {
+    let fixture = PushFixture::new();
+    let state_root = fixture.root.join(".state");
+    let source_path = Path::new("draft/design-review.md");
+    let content_root = virtual_fs_content_root(&state_root, &fixture.mount_id);
+    let cache_path =
+        virtual_fs_content_path(&state_root, &fixture.mount_id, source_path).expect("cache path");
+    fs::create_dir_all(cache_path.parent().expect("cache parent")).expect("cache parent");
+    let edited_draft = "---\nsummary: Follow-up design review\nstart:\n  dateTime: \"2026-07-20T10:00:00-07:00\"\nend:\n  dateTime: \"2026-07-20T10:30:00-07:00\"\n---\nUpdated agenda\n";
+    fs::write(
+        &cache_path,
+        "---\nsummary: Design review\nstart:\n  dateTime: \"2026-07-20T10:00:00-07:00\"\nend:\n  dateTime: \"2026-07-20T10:30:00-07:00\"\n---\nAgenda\n",
+    )
+    .expect("cache file");
+
+    let draft_folder_id = RemoteId::new("google-calendar-folder:draft");
+    let events_folder_id = RemoteId::new("google-calendar-folder:events");
+    let created_remote_id = RemoteId::new("google-calendar-event:primary:created-event");
+    let expected_path = PathBuf::from("events/20260720-100000-design-review-created-event.md");
+    let mut store = InMemoryStateStore::new();
+    store
+        .save_mount(
+            MountConfig::new(fixture.mount_id.clone(), "google-calendar", &fixture.root)
+                .projection(ProjectionMode::LinuxFuse),
+        )
+        .expect("save mount");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            draft_folder_id.clone(),
+            EntityKind::Directory,
+            "draft",
+            "draft",
+        ))
+        .expect("save draft folder");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            events_folder_id.clone(),
+            EntityKind::Directory,
+            "events",
+            "events",
+        ))
+        .expect("save events folder");
+    store
+        .save_virtual_mutation(virtual_mutation(
+            &fixture.mount_id,
+            "local:calendar-draft",
+            VirtualMutationKind::Create,
+            None,
+            Some(draft_folder_id),
+            "draft/design-review.md",
+            Some(cache_path.clone()),
+        ))
+        .expect("save mutation");
+    let source = FakePushSource::default()
+        .with_created_entity(
+            created_remote_id.clone(),
+            rendered_google_calendar_entity(
+                "google-calendar-event:primary:created-event",
+                "Design review",
+                "2026-07-20T10:00:00-07:00",
+                "Agenda",
+            ),
+        )
+        .with_created_fetch_failures(created_remote_id.clone(), 1)
+        .with_apply_effects(vec![JournalApplyEffect::CreatedEntity {
+            operation_id: PushOperationId("create-calendar-draft".to_string()),
+            operation_index: 0,
+            parent_id: events_folder_id,
+            entity_id: created_remote_id.clone(),
+        }]);
+    let job = || PushJob {
+        target_path: fixture.root.join(source_path),
+        assume_yes: true,
+        confirm_dangerous: false,
+    };
+
+    let first = execute_push_job_with_content_root(&mut store, job(), &source, Some(&state_root))
+        .expect("first push");
+
+    assert_eq!(first.action, PushJobAction::Failed);
+    assert_eq!(source.applied_count(), 1);
+    let first_push_id = first.push_id.expect("first push id");
+    fs::write(&cache_path, edited_draft).expect("edit stale draft");
+
+    let second = execute_push_job_with_content_root(&mut store, job(), &source, Some(&state_root))
+        .expect("retry push");
+
+    assert_eq!(second.action, PushJobAction::Reconciled);
+    assert_eq!(
+        source.applied_count(),
+        1,
+        "retry must not recreate Calendar event"
+    );
+    assert_eq!(second.push_id.as_ref(), Some(&first_push_id));
+    let event = store
+        .get_entity(&fixture.mount_id, &created_remote_id)
+        .expect("get created event")
+        .expect("created event entity");
+    assert_eq!(event.path, expected_path);
+    assert!(content_root.join(&expected_path).exists());
+    assert_eq!(
+        fs::read_to_string(content_root.join(source_path)).expect("preserved edited draft"),
+        edited_draft
+    );
+    assert!(
+        store
+            .find_virtual_mutation_by_path(&fixture.mount_id, source_path)
+            .expect("find mutation")
+            .is_some()
+    );
+}
+
+#[test]
+fn auto_save_push_blocks_google_calendar_draft_create_without_applying() {
+    let fixture = PushFixture::new();
+    let state_root = fixture.root.join(".state");
+    let source_path = Path::new("draft/design-review.md");
+    let cache_path =
+        virtual_fs_content_path(&state_root, &fixture.mount_id, source_path).expect("cache path");
+    fs::create_dir_all(cache_path.parent().expect("cache parent")).expect("cache parent");
+    fs::write(
+        &cache_path,
+        "---\nsummary: Design review\nstart:\n  dateTime: \"2026-07-20T10:00:00-07:00\"\nend:\n  dateTime: \"2026-07-20T10:30:00-07:00\"\n---\nAgenda\n",
+    )
+    .expect("cache file");
+
+    let draft_folder_id = RemoteId::new("google-calendar-folder:draft");
+    let created_remote_id = RemoteId::new("google-calendar-event:primary:created-event");
+    let mut store = InMemoryStateStore::new();
+    store
+        .save_mount(
+            MountConfig::new(fixture.mount_id.clone(), "google-calendar", &fixture.root)
+                .projection(ProjectionMode::LinuxFuse),
+        )
+        .expect("save mount");
+    store
+        .save_entity(EntityRecord::new(
+            fixture.mount_id.clone(),
+            draft_folder_id.clone(),
+            EntityKind::Directory,
+            "draft",
+            "draft",
+        ))
+        .expect("save draft folder");
+    store
+        .save_virtual_mutation(virtual_mutation(
+            &fixture.mount_id,
+            "local:calendar-draft",
+            VirtualMutationKind::Create,
+            None,
+            Some(draft_folder_id),
+            "draft/design-review.md",
+            Some(cache_path),
+        ))
+        .expect("save mutation");
+    store
+        .save_auto_save_enrollment(AutoSaveEnrollmentRecord::new(
+            fixture.mount_id.clone(),
+            source_path,
+            AutoSaveOrigin::LocalityCreated,
+            "now",
+        ))
+        .expect("save enrollment");
+    let source =
+        FakePushSource::default().with_apply_effects(vec![JournalApplyEffect::CreatedEntity {
+            operation_id: PushOperationId("create-calendar-draft".to_string()),
+            operation_index: 0,
+            parent_id: RemoteId::new("google-calendar-folder:events"),
+            entity_id: created_remote_id,
+        }]);
+
+    let report = execute_auto_save_push_job_with_content_root(
+        &mut store,
+        PushJob {
+            target_path: fixture.root.join(source_path),
+            assume_yes: false,
+            confirm_dangerous: false,
+        },
+        &source,
+        Some(&state_root),
+    )
+    .expect("auto-save google calendar draft");
+
+    assert_eq!(report.action, PushJobAction::NotReady);
+    assert_eq!(
+        source.applied_count(),
+        0,
+        "auto-save must not create Calendar events"
+    );
+    assert_eq!(
+        report.error.as_ref().expect("error").code,
+        "auto_save_blocked"
+    );
+    assert_eq!(
+        report.error.as_ref().expect("error").message,
+        "Google Calendar event creates require review"
+    );
+    let enrollment = store
+        .get_auto_save_enrollment(&fixture.mount_id, source_path)
+        .expect("get enrollment")
+        .expect("enrollment");
+    assert_eq!(enrollment.state, AutoSaveState::Blocked);
+    assert_eq!(
+        enrollment.last_reason.as_deref(),
+        Some("Google Calendar event creates require review")
+    );
+    assert!(store.list_journal().expect("journal").is_empty());
+}
+
 #[test]
 fn auto_save_push_blocks_gmail_draft_send_without_applying() {
     let fixture = PushFixture::new();
@@ -2732,6 +3144,31 @@ fn rendered_gmail_entity(
     }
 }
 
+fn rendered_google_calendar_entity(
+    remote_id: &str,
+    summary: &str,
+    start_date_time: &str,
+    plain_body: &str,
+) -> HydratedEntity {
+    let body = markdown_body(plain_body);
+    let event_id = remote_id
+        .strip_prefix("google-calendar-event:primary:")
+        .expect("primary event remote id");
+    let remote_version = format!("google-calendar:created-event:2026-07-20T17:30:00Z:\"etag\"");
+    let document = CanonicalDocument::new(
+        format!(
+            "loc:\n  id: {remote_id}\n  type: page\n  connector: google-calendar\n  synced_at: {remote_version}\n  remote_edited_at: {remote_version}\ntitle: {summary}\nsummary: {summary}\nstart:\n  dateTime: \"{start_date_time}\"\ngoogle_calendar:\n  calendar_id: primary\n  event_id: {event_id}\n"
+        ),
+        body.clone(),
+    );
+    HydratedEntity {
+        document,
+        shadow: shadow(remote_id, plain_body),
+        remote_edited_at: Some(remote_version),
+        assets: Vec::new(),
+    }
+}
+
 #[derive(Debug)]
 struct RacyNotionApi {
     remote: Mutex<RacyNotionRemote>,
diff --git a/crates/localityd/tests/source_descriptor.rs b/crates/localityd/tests/source_descriptor.rs
index 3d80f416..11ba91c3 100644
--- a/crates/localityd/tests/source_descriptor.rs
+++ b/crates/localityd/tests/source_descriptor.rs
@@ -6,6 +6,9 @@ use locality_core::push::BodyDiffMode;
 use locality_core::shadow::ShadowDocument;
 use locality_core::validation::ValidationIssue;
 use locality_gmail::{GMAIL_CONNECTOR_ID, GMAIL_OAUTH_SCOPES, StoredGmailCredential};
+use locality_google_calendar::{
+    GOOGLE_CALENDAR_CONNECTOR_ID, GOOGLE_CALENDAR_OAUTH_SCOPES, StoredGoogleCalendarCredential,
+};
 use locality_google_docs::{GOOGLE_DOCS_CONNECTOR_ID, StoredGoogleDocsCredential};
 use locality_granola::GRANOLA_CONNECTOR_ID;
 use locality_linear::LINEAR_CONNECTOR_ID;
@@ -67,6 +70,40 @@ fn google_docs_descriptor_comes_from_registry() {
     );
 }
 
+#[test]
+fn google_calendar_descriptor_comes_from_registry() {
+    let descriptor = source_descriptor("google-calendar");
+
+    assert_eq!(descriptor.id(), "google-calendar");
+    assert_eq!(descriptor.display_name(), "Google Calendar");
+    assert_eq!(descriptor.default_mount_id(), "google-calendar-main");
+    assert_eq!(
+        descriptor.connect_command(),
+        Some("loc connect google-calendar")
+    );
+    assert_eq!(descriptor.auth_env_var(), None);
+    assert!(descriptor.supports_oauth());
+    assert!(
+        descriptor
+            .mount_guidance()
+            .contains("Google Calendar facts")
+    );
+    assert!(descriptor.mount_guidance().contains("primary calendar"));
+    assert!(descriptor.mount_guidance().contains("events/"));
+    assert!(descriptor.mount_guidance().contains("draft/"));
+    assert!(descriptor.mount_guidance().contains("events/ is read-only"));
+    assert!(descriptor.mount_guidance().contains("`start`"));
+    assert!(descriptor.mount_guidance().contains("`end`"));
+    assert!(descriptor.mount_guidance().contains("`summary` or `title`"));
+    assert_eq!(descriptor.source_root_create_parent_kind(), None);
+    assert_eq!(
+        descriptor.create_entity_parent_kinds(),
+        &[EntityKind::Directory]
+    );
+    assert_eq!(descriptor.periodic_discovery_interval(), None);
+    assert_eq!(descriptor.max_background_discovery_workers(), 4);
+}
+
 #[test]
 fn gmail_descriptor_comes_from_registry() {
     let descriptor = source_descriptor("gmail");
@@ -122,6 +159,36 @@ fn granola_rejects_every_write_and_create_path() {
     );
 }
 
+#[test]
+fn google_calendar_write_policy_allows_only_direct_drafts() {
+    let mut mount = MountConfig::new(
+        MountId::new("google-calendar-main"),
+        GOOGLE_CALENDAR_CONNECTOR_ID,
+        "/tmp/locality/google-calendar",
+    );
+    mount.read_only = false;
+
+    assert!(
+        !source_write_decision_for_path(&mount, std::path::Path::new("events/foo.md"))
+            .is_writable()
+    );
+    assert!(source_write_decision_for_path(&mount, std::path::Path::new("draft")).is_writable());
+    assert!(
+        source_write_decision_for_path(&mount, std::path::Path::new("draft/foo.md")).is_writable()
+    );
+    assert!(
+        !source_write_decision_for_path(&mount, std::path::Path::new("draft/nested/foo.md"))
+            .is_writable()
+    );
+    assert!(
+        !source_create_decision_for_parent_path(&mount, std::path::Path::new("events"))
+            .is_writable()
+    );
+    assert!(
+        source_create_decision_for_parent_path(&mount, std::path::Path::new("draft")).is_writable()
+    );
+}
+
 #[test]
 fn linear_allows_existing_issue_edits_but_rejects_local_creates() {
     let mut mount = MountConfig::new(
@@ -177,7 +244,14 @@ fn linear_descriptor_comes_from_registry_and_uses_api_key_setup() {
 
 #[test]
 fn source_descriptors_declare_canonical_title_rename_policy() {
-    for connector in ["notion", "google-docs", "gmail", "granola", "custom"] {
+    for connector in [
+        "notion",
+        "google-docs",
+        "google-calendar",
+        "gmail",
+        "granola",
+        "custom",
+    ] {
         assert_eq!(
             source_descriptor(connector).virtual_rename_policy(),
             VirtualRenamePolicy::FilenameDerived,
@@ -198,6 +272,7 @@ fn source_descriptors_declare_canonical_title_rename_policy() {
 fn source_display_name_uses_descriptor_registry() {
     assert_eq!(source_display_name("notion"), "Notion");
     assert_eq!(source_display_name("google-docs"), "Google Docs");
+    assert_eq!(source_display_name("google-calendar"), "Google Calendar");
     assert_eq!(source_display_name("linear"), "Linear");
     assert_eq!(source_display_name("custom"), "custom");
 }
@@ -311,6 +386,55 @@ fn save_gmail_connection(
     (connection_id, secret_ref)
 }
 
+fn save_google_calendar_connection(store: &mut InMemoryStateStore) -> (ConnectionId, String) {
+    let profile_id = ConnectorProfileId::new("google-calendar-oauth-default");
+    let connection_id = ConnectionId::new("google-calendar-default");
+    let secret_ref = "connection:google-calendar-default".to_string();
+
+    store
+        .save_connector_profile(ConnectorProfileRecord {
+            profile_id: profile_id.clone(),
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            display_name: "Google Calendar OAuth".to_string(),
+            auth_kind: "oauth".to_string(),
+            scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+                .iter()
+                .map(|scope| scope.to_string())
+                .collect(),
+            capabilities_json: "{}".to_string(),
+            enabled_actions_json: "[]".to_string(),
+            connector_version: "1".to_string(),
+            status: "active".to_string(),
+            created_at: "2026-06-25T10:00:00Z".to_string(),
+            updated_at: "2026-06-25T10:00:00Z".to_string(),
+        })
+        .expect("save profile");
+    store
+        .save_connection(ConnectionRecord {
+            connection_id: connection_id.clone(),
+            profile_id: Some(profile_id),
+            connector: GOOGLE_CALENDAR_CONNECTOR_ID.to_string(),
+            display_name: "Google Calendar".to_string(),
+            account_label: Some("user@example.com".to_string()),
+            workspace_id: Some("primary".to_string()),
+            workspace_name: Some("Primary calendar".to_string()),
+            auth_kind: "oauth".to_string(),
+            secret_ref: secret_ref.clone(),
+            scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+                .iter()
+                .map(|scope| scope.to_string())
+                .collect(),
+            capabilities_json: "{}".to_string(),
+            status: "active".to_string(),
+            created_at: "2026-06-25T10:00:00Z".to_string(),
+            updated_at: "2026-06-25T10:00:00Z".to_string(),
+            expires_at: None,
+        })
+        .expect("save connection");
+
+    (connection_id, secret_ref)
+}
+
 fn stored_gmail_credential(access_token: &str) -> StoredGmailCredential {
     StoredGmailCredential::from_broker_token(
         OAuthBrokerToken {
@@ -330,6 +454,28 @@ fn stored_gmail_credential(access_token: &str) -> StoredGmailCredential {
     )
 }
 
+fn stored_google_calendar_credential(access_token: &str) -> StoredGoogleCalendarCredential {
+    StoredGoogleCalendarCredential::from_broker_token(
+        OAuthBrokerToken {
+            access_token: access_token.to_string(),
+            token_type: Some("Bearer".to_string()),
+            expires_in: Some(3600),
+            refresh_token_handle: Some("handle-1".to_string()),
+            account_id: Some("acct-1".to_string()),
+            account_label: Some("user@example.com".to_string()),
+            workspace_id: Some("primary".to_string()),
+            workspace_name: Some("Primary calendar".to_string()),
+            scopes: GOOGLE_CALENDAR_OAUTH_SCOPES
+                .iter()
+                .map(|scope| scope.to_string())
+                .collect(),
+        },
+        "client-id".to_string(),
+        "https://auth.example.test".to_string(),
+        4_102_444_800,
+    )
+}
+
 fn expired_gmail_credential(access_token: &str, broker_url: String) -> StoredGmailCredential {
     let mut stored = StoredGmailCredential::from_broker_token(
         OAuthBrokerToken {
@@ -358,6 +504,14 @@ fn gmail_mount() -> MountConfig {
     MountConfig::new(MountId::new("gmail-main"), GMAIL_CONNECTOR_ID, "/tmp/gmail")
 }
 
+fn google_calendar_mount() -> MountConfig {
+    MountConfig::new(
+        MountId::new("google-calendar-main"),
+        GOOGLE_CALENDAR_CONNECTOR_ID,
+        "/tmp/google-calendar",
+    )
+}
+
 fn validate_gmail_create_issues(path: &str, markdown: &str) -> Vec<ValidationIssue> {
     let mount = gmail_mount();
     let parsed = parse_canonical_markdown(markdown).expect("parse gmail markdown");
@@ -402,6 +556,46 @@ fn validate_gmail_changed(path: &str, markdown: &str) -> Vec<String> {
         .collect()
 }
 
+fn validate_google_calendar_create(path: &str, markdown: &str) -> Vec<String> {
+    let mount = google_calendar_mount();
+    let parsed = parse_canonical_markdown(markdown).expect("parse google calendar markdown");
+
+    LocalSourceValidator
+        .validate_create_frontmatter(SourceValidationContext {
+            state_root: None,
+            mount: &mount,
+            parent: None,
+            relative_path: std::path::Path::new(path),
+            parsed: &parsed,
+            shadow: None,
+        })
+        .expect("validate google calendar create")
+        .issues
+        .into_iter()
+        .map(|issue| issue.code)
+        .collect()
+}
+
+fn validate_google_calendar_changed(path: &str, markdown: &str) -> Vec<String> {
+    let mount = google_calendar_mount();
+    let parsed = parse_canonical_markdown(markdown).expect("parse google calendar markdown");
+
+    LocalSourceValidator
+        .validate_changed_frontmatter(SourceValidationContext {
+            state_root: None,
+            mount: &mount,
+            parent: None,
+            relative_path: std::path::Path::new(path),
+            parsed: &parsed,
+            shadow: None,
+        })
+        .expect("validate google calendar changed")
+        .issues
+        .into_iter()
+        .map(|issue| issue.code)
+        .collect()
+}
+
 fn validate_linear_changed(markdown: &str, shadow_frontmatter: &str) -> Vec<ValidationIssue> {
     let mount = MountConfig::new(
         MountId::new("linear-main"),
@@ -456,7 +650,14 @@ fn validate_linear_create(markdown: &str) -> Vec<ValidationIssue> {
 fn supported_source_connectors_include_first_party_connectors() {
     assert_eq!(
         supported_source_connectors(),
-        vec!["notion", "google-docs", "gmail", "granola", "linear"]
+        vec![
+            "notion",
+            "google-docs",
+            "google-calendar",
+            "gmail",
+            "granola",
+            "linear"
+        ]
     );
 }
 
@@ -717,6 +918,28 @@ fn resolving_gmail_mount_uses_active_oauth_connection_credentials() {
     assert_eq!(connector.config().access_token, "gmail-access-token");
 }
 
+#[test]
+fn resolving_google_calendar_mount_uses_active_oauth_connection_credentials() {
+    let mut store = InMemoryStateStore::new();
+    let credentials = InMemoryCredentialStore::new();
+    let (_connection_id, secret_ref) = save_google_calendar_connection(&mut store);
+    credentials
+        .put(
+            &secret_ref,
+            &serde_json::to_string(&stored_google_calendar_credential("calendar-access-token"))
+                .expect("credential json"),
+        )
+        .expect("save credential");
+
+    let source = resolve_source_for_mount(&store, &credentials, &google_calendar_mount())
+        .expect("resolve google calendar");
+
+    let ResolvedSource::GoogleCalendar(connector) = source else {
+        panic!("expected google calendar source");
+    };
+    assert_eq!(connector.config().access_token, "calendar-access-token");
+}
+
 #[test]
 fn resolving_gmail_mount_with_invalid_settings_reports_validation_detail() {
     let mut store = InMemoryStateStore::new();
@@ -1173,6 +1396,50 @@ fn local_gmail_validator_blocks_changed_inbox_and_sent_items() {
     }
 }
 
+#[test]
+fn local_google_calendar_validator_allows_valid_direct_draft_create() {
+    let issues = validate_google_calendar_create(
+        "draft/foo.md",
+        "---\nsummary: Team sync\nstart:\n  dateTime: \"2026-07-20T10:00:00Z\"\nend:\n  dateTime: \"2026-07-20T10:30:00Z\"\n---\nAgenda\n",
+    );
+
+    assert!(issues.is_empty());
+}
+
+#[test]
+fn local_google_calendar_validator_blocks_nested_draft_create() {
+    let issues = validate_google_calendar_create(
+        "draft/nested/foo.md",
+        "---\nsummary: Team sync\nstart:\n  dateTime: \"2026-07-20T10:00:00Z\"\nend:\n  dateTime: \"2026-07-20T10:30:00Z\"\n---\nAgenda\n",
+    );
+
+    assert_eq!(issues, vec!["google_calendar_create_outside_draft"]);
+}
+
+#[test]
+fn local_google_calendar_validator_blocks_changed_events() {
+    let issues = validate_google_calendar_changed(
+        "events/foo.md",
+        "---\nloc:\n  id: event-1\n  type: page\n  connector: google-calendar\nsummary: Team sync\n---\nAgenda\n",
+    );
+
+    assert_eq!(issues, vec!["google_calendar_events_read_only"]);
+}
+
+#[test]
+fn local_google_calendar_validator_blocks_missing_required_draft_frontmatter() {
+    let issues = validate_google_calendar_create("draft/foo.md", "---\n---\nAgenda\n");
+
+    assert_eq!(
+        issues,
+        vec![
+            "google_calendar_draft_missing_start",
+            "google_calendar_draft_missing_end",
+            "google_calendar_draft_missing_summary"
+        ]
+    );
+}
+
 #[test]
 fn local_google_docs_validator_blocks_unsupported_directives() {
     let mount = MountConfig::new(
diff --git a/docs-site/connectors/google-calendar.mdx b/docs-site/connectors/google-calendar.mdx
new file mode 100644
index 00000000..6ed6ce2b
--- /dev/null
+++ b/docs-site/connectors/google-calendar.mdx
@@ -0,0 +1,93 @@
+---
+title: "Google Calendar connector"
+description: "How primary-calendar events map into Locality."
+---
+
+The Google Calendar connector mounts primary-calendar events as local files and
+uses reviewed draft files to create new events.
+
+## Connect
+
+```bash
+loc connect google-calendar --name google-calendar-default
+```
+
+## Mount
+
+```bash
+loc mount google-calendar ~/Locality/google-calendar-main --projection plain-files
+loc pull ~/Locality/google-calendar-main
+```
+
+Optional explicit date window:
+
+```bash
+loc mount google-calendar ~/Locality/google-calendar-main \
+  --projection plain-files \
+  --after 2026-07-01 \
+  --before 2026-07-31
+```
+
+## Projection
+
+```text
+google-calendar-main/
+  events/
+    2026-07-20-design-review-event-1.md
+  draft/
+```
+
+- `events/` contains read-only primary-calendar event files;
+- `draft/` accepts new Markdown files that create events after review and push;
+- the full Google Calendar event resource is stored under `google_calendar.event`;
+- the Markdown body is the event description.
+
+By default, pull uses a rolling window from 30 days back through 180 days
+forward. Recurring events are expanded in the projection.
+
+## Creating events
+
+Create a Markdown file directly under `draft/`:
+
+```markdown
+---
+summary: Design review
+location: Room 12
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+  timeZone: America/Los_Angeles
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+  timeZone: America/Los_Angeles
+attendees:
+  - email: ann@example.com
+google_calendar:
+  conference: google_meet
+---
+
+Agenda:
+
+- Review launch scope
+- Confirm owners
+```
+
+Review and push the draft:
+
+```bash
+loc status ~/Locality/google-calendar-main/draft/design-review.md
+loc diff ~/Locality/google-calendar-main/draft/design-review.md
+loc push ~/Locality/google-calendar-main/draft/design-review.md -y
+```
+
+Pushing sends attendee updates. When `google_calendar.conference` is
+`google_meet`, Locality requests a Google Meet link during event creation.
+
+## Current limits
+
+- Only the primary calendar is projected.
+- Existing event files under `events/` are read-only.
+- Remote Google Calendar drafts are not projected.
+- Attachments are rendered as metadata but are not uploaded from Locality
+  drafts in V1.
+- Incremental sync tokens are not persisted; pull uses bounded date-window
+  enumeration.
diff --git a/docs-site/docs.json b/docs-site/docs.json
index 5eefd8d4..edc65af7 100644
--- a/docs-site/docs.json
+++ b/docs-site/docs.json
@@ -76,7 +76,8 @@
         "group": "Connectors",
         "pages": [
           "connectors/notion",
-          "connectors/google-docs"
+          "connectors/google-docs",
+          "connectors/google-calendar"
         ]
       },
       {
diff --git a/docs-site/llms.txt b/docs-site/llms.txt
index b84a7312..7d254efb 100644
--- a/docs-site/llms.txt
+++ b/docs-site/llms.txt
@@ -32,6 +32,7 @@
 
 - [Notion connector](connectors/notion.mdx): Notion projection, databases, supported writes, and common errors.
 - [Google Docs connector](connectors/google-docs.mdx): Google Docs projection, supported content, and limits.
+- [Google Calendar connector](connectors/google-calendar.mdx): Primary-calendar events, event drafts, and limits.
 
 ## Reference
 
diff --git a/docs/google-calendar-connector.md b/docs/google-calendar-connector.md
new file mode 100644
index 00000000..41f46898
--- /dev/null
+++ b/docs/google-calendar-connector.md
@@ -0,0 +1,168 @@
+# Google Calendar Connector Summary
+
+This document summarizes the first Google Calendar connector implementation.
+
+## Connector Scope
+
+Google Calendar is registered as a first-party Locality source connector named
+`google-calendar`. It uses the normal Locality connection, mount, pull, hydrate,
+diff, push, status, and live projection paths.
+
+The V1 connector is scoped to the account's primary calendar only.
+
+The connector projects a fixed calendar shape:
+
+```text
+~/Locality/
+  google-calendar-main/
+    events/
+    draft/
+```
+
+`events/` is read-only. `draft/` is the local write surface for new primary
+calendar events.
+
+## OAuth
+
+The Google Calendar OAuth flow uses the Locality OAuth broker endpoints:
+
+- `/v1/oauth/google-calendar/start`
+- `/v1/oauth/google-calendar/exchange`
+- `/v1/oauth/google-calendar/refresh`
+
+The default callback is:
+
+```text
+http://localhost:8757/oauth/google-calendar/callback
+```
+
+The broker allowlist also supports:
+
+```text
+http://127.0.0.1:8757/oauth/google-calendar/callback
+```
+
+Google Calendar, Gmail, and Google Docs share the same broker-configured Google
+OAuth client: `LOCALITY_GOOGLE_CLIENT_ID` and
+`LOCALITY_GOOGLE_CLIENT_SECRET`. Register each connector's localhost callback
+on that Google OAuth client.
+
+The broker requests these scopes:
+
+- `openid`
+- `email`
+- `profile`
+- `https://www.googleapis.com/auth/calendar.events`
+
+## Projection And Pull
+
+By default, Pull enumerates a rolling date window from 30 days back through 180
+days forward. Recurring events are expanded through the Google Calendar Events
+API with `singleEvents=true`.
+
+Google Calendar mounts can be registered with an explicit date window:
+
+```bash
+loc mount google-calendar ~/Locality/google-calendar-main \
+  --after 2026-07-01 \
+  --before 2026-07-31
+```
+
+Event files are projected under `events/`:
+
+```text
+google-calendar-main/
+  events/
+    2026-07-20-design-review-event-1.md
+  draft/
+```
+
+Rendered event frontmatter includes Locality identity, readable event fields
+such as `summary`, `start`, `end`, and `location`, and the full Google Calendar
+event resource under `google_calendar.event`. The Markdown body is the event
+description.
+
+## Write Policy
+
+`events/` is read-only. File Provider and source write policy should reject
+edits and deletes there.
+
+Creating a Markdown file directly under `draft/` is writable:
+
+```text
+draft/design-review.md
+```
+
+Nested draft files are rejected:
+
+```text
+draft/team/design-review.md
+```
+
+Draft frontmatter requires `summary` or `title`, plus `start` and `end` objects
+in the native Google Calendar API shape.
+
+```markdown
+---
+summary: Design review
+location: Room 12
+start:
+  dateTime: "2026-07-20T10:00:00-07:00"
+  timeZone: America/Los_Angeles
+end:
+  dateTime: "2026-07-20T10:30:00-07:00"
+  timeZone: America/Los_Angeles
+attendees:
+  - email: ann@example.com
+  - email: lee@example.com
+google_calendar:
+  conference: google_meet
+---
+
+Agenda:
+
+- Review launch scope
+- Confirm owners
+```
+
+`loc push` for a Google Calendar draft creates an event on the primary calendar
+with `sendUpdates=all`. Setting `google_calendar.conference: google_meet`
+requests a Google Meet link with `conferenceDataVersion=1`.
+
+## Useful Commands
+
+Connect with the local broker:
+
+```bash
+loc connect google-calendar --name google-calendar-default
+```
+
+Mount Google Calendar:
+
+```bash
+loc mount google-calendar ~/Locality/google-calendar-main --projection plain-files
+```
+
+Force enumeration:
+
+```bash
+loc pull ~/Locality/google-calendar-main
+```
+
+Review and create a draft event:
+
+```bash
+loc status "$HOME/Locality/google-calendar-main/draft/design-review.md"
+loc diff "$HOME/Locality/google-calendar-main/draft/design-review.md"
+loc push "$HOME/Locality/google-calendar-main/draft/design-review.md" -y
+```
+
+## Current Limitations
+
+- Primary calendar only.
+- Existing events are read-only.
+- Remote Google Calendar drafts are not projected.
+- Calendar attachments are rendered as metadata but not uploaded from Locality
+  drafts in V1.
+- Incremental sync tokens are not persisted; Pull uses bounded date-window
+  enumeration.