diff --git a/.env.example b/.env.example
index 696d3a061..32ca137ed 100644
--- a/.env.example
+++ b/.env.example
@@ -51,6 +51,13 @@ RELAY_URL=ws://localhost:3000
 # (use `just web` for Vite HMR instead).
 # BUZZ_WEB_DIR=./web/dist
 
+# -----------------------------------------------------------------------------
+# Desktop integrations (OAuth)
+# -----------------------------------------------------------------------------
+# Optional Google Calendar desktop OAuth client.
+# BUZZ_GOOGLE_CALENDAR_CLIENT_ID=
+# BUZZ_GOOGLE_CALENDAR_CLIENT_SECRET=
+
 # -----------------------------------------------------------------------------
 # Git (NIP-34 bare repositories)
 # -----------------------------------------------------------------------------
diff --git a/desktop/src-tauri/Cargo.toml b/desktop/src-tauri/Cargo.toml
index 6086233e8..ce2c4d8d7 100644
--- a/desktop/src-tauri/Cargo.toml
+++ b/desktop/src-tauri/Cargo.toml
@@ -78,7 +78,7 @@ serde_yaml = "0.9"
 toml = "0.8"
 nostr = { version = "0.44", features = ["nip44"] }
 zeroize = "1"
-reqwest = { version = "0.13", features = ["json", "query", "stream"] }
+reqwest = { version = "0.13", features = ["form", "json", "query", "stream"] }
 url = "2"
 buzz_core_pkg = { package = "buzz-core", path = "../../crates/buzz-core" }
 buzz_persona_pkg = { package = "buzz-persona", path = "../../crates/buzz-persona" }
diff --git a/desktop/src-tauri/src/commands/calendar.rs b/desktop/src-tauri/src/commands/calendar.rs
new file mode 100644
index 000000000..9abb00fb1
--- /dev/null
+++ b/desktop/src-tauri/src/commands/calendar.rs
@@ -0,0 +1,547 @@
+use std::time::Duration;
+
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use tauri::State;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use url::Url;
+use uuid::Uuid;
+
+use crate::app_state::{AppState, KEYRING_SERVICE};
+use crate::secret_store::SecretStore;
+
+const GOOGLE_CALENDAR_CREDENTIAL_KEY: &str = "google-calendar-oauth";
+const GOOGLE_AUTH_URL: &str = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_TOKEN_URL: &str = "https://oauth2.googleapis.com/token";
+const GOOGLE_CALENDAR_EVENTS_READONLY_SCOPE: &str =
+    "https://www.googleapis.com/auth/calendar.events.readonly";
+const OAUTH_CALLBACK_PATH: &str = "/";
+const OAUTH_CALLBACK_TIMEOUT: Duration = Duration::from_secs(180);
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct GoogleCalendarCredential {
+    access_token: Option<String>,
+    connected_at: i64,
+    expires_at: Option<i64>,
+    refresh_token: String,
+    scope: Option<String>,
+    token_type: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct GoogleCalendarStatus {
+    configured: bool,
+    connected: bool,
+    connected_at: Option<i64>,
+    scopes: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct GoogleCalendarEvent {
+    id: String,
+    title: String,
+    starts_at: String,
+    ends_at: String,
+    all_day: bool,
+    join_url: Option<String>,
+    html_url: Option<String>,
+    transparency: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GoogleTokenResponse {
+    access_token: Option<String>,
+    expires_in: Option<i64>,
+    refresh_token: Option<String>,
+    scope: Option<String>,
+    token_type: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct GoogleEventsResponse {
+    items: Option<Vec<GoogleRawEvent>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GoogleRawEvent {
+    id: Option<String>,
+    summary: Option<String>,
+    status: Option<String>,
+    start: Option<GoogleRawEventTime>,
+    end: Option<GoogleRawEventTime>,
+    hangout_link: Option<String>,
+    html_link: Option<String>,
+    conference_data: Option<GoogleConferenceData>,
+    transparency: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GoogleRawEventTime {
+    date: Option<String>,
+    date_time: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GoogleConferenceData {
+    entry_points: Option<Vec<GoogleConferenceEntryPoint>>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct GoogleConferenceEntryPoint {
+    entry_point_type: Option<String>,
+    uri: Option<String>,
+}
+
+fn google_calendar_client_id() -> Option<String> {
+    std::env::var("BUZZ_GOOGLE_CALENDAR_CLIENT_ID")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .or_else(|| {
+            option_env!("BUZZ_GOOGLE_CALENDAR_CLIENT_ID")
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToOwned::to_owned)
+        })
+}
+
+fn google_calendar_client_secret() -> Option<String> {
+    std::env::var("BUZZ_GOOGLE_CALENDAR_CLIENT_SECRET")
+        .ok()
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .or_else(|| {
+            option_env!("BUZZ_GOOGLE_CALENDAR_CLIENT_SECRET")
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToOwned::to_owned)
+        })
+}
+
+fn credential_store() -> &'static SecretStore {
+    SecretStore::shared(KEYRING_SERVICE)
+}
+
+fn now_ts() -> i64 {
+    Utc::now().timestamp()
+}
+
+fn load_credential() -> Result<Option<GoogleCalendarCredential>, String> {
+    let Some(raw) = credential_store().load(GOOGLE_CALENDAR_CREDENTIAL_KEY)? else {
+        return Ok(None);
+    };
+    serde_json::from_str(&raw).map_err(|e| format!("parse Google Calendar credential: {e}"))
+}
+
+fn save_credential(credential: &GoogleCalendarCredential) -> Result<(), String> {
+    let raw = serde_json::to_string(credential)
+        .map_err(|e| format!("serialize Google Calendar credential: {e}"))?;
+    credential_store().store(GOOGLE_CALENDAR_CREDENTIAL_KEY, &raw)
+}
+
+fn scopes(scope: Option<&str>) -> Vec<String> {
+    scope
+        .unwrap_or("")
+        .split_whitespace()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+        .collect()
+}
+
+fn status_from_credential(credential: Option<&GoogleCalendarCredential>) -> GoogleCalendarStatus {
+    GoogleCalendarStatus {
+        configured: google_calendar_client_id().is_some(),
+        connected: credential.is_some(),
+        connected_at: credential.map(|value| value.connected_at),
+        scopes: scopes(credential.and_then(|value| value.scope.as_deref())),
+    }
+}
+
+fn pkce_verifier() -> String {
+    [
+        Uuid::new_v4().simple().to_string(),
+        Uuid::new_v4().simple().to_string(),
+        Uuid::new_v4().simple().to_string(),
+    ]
+    .join("")
+}
+
+fn pkce_challenge(verifier: &str) -> String {
+    URL_SAFE_NO_PAD.encode(Sha256::digest(verifier.as_bytes()))
+}
+
+fn oauth_state() -> String {
+    [
+        Uuid::new_v4().simple().to_string(),
+        Uuid::new_v4().simple().to_string(),
+    ]
+    .join("")
+}
+
+fn oauth_authorization_url(
+    client_id: &str,
+    redirect_uri: &str,
+    state: &str,
+    code_challenge: &str,
+) -> Result<Url, String> {
+    let mut url = Url::parse(GOOGLE_AUTH_URL).map_err(|e| e.to_string())?;
+    url.query_pairs_mut()
+        .append_pair("client_id", client_id)
+        .append_pair("redirect_uri", redirect_uri)
+        .append_pair("response_type", "code")
+        .append_pair("scope", GOOGLE_CALENDAR_EVENTS_READONLY_SCOPE)
+        .append_pair("state", state)
+        .append_pair("code_challenge", code_challenge)
+        .append_pair("code_challenge_method", "S256")
+        .append_pair("prompt", "consent")
+        .append_pair("access_type", "offline");
+    Ok(url)
+}
+
+fn callback_response(title: &str, body: &str) -> String {
+    let html = format!(
+        "<!doctype html><html><head><meta charset=\"utf-8\"><title>{title}</title></head>\
+         <body><main style=\"font-family: system-ui, sans-serif; max-width: 34rem; margin: 4rem auto;\">\
+         <h1>{title}</h1><p>{body}</p></main></body></html>"
+    );
+    format!(
+        "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        html.len(),
+        html
+    )
+}
+
+async fn wait_for_oauth_callback(
+    listener: TcpListener,
+    expected_state: &str,
+) -> Result<String, String> {
+    let (mut stream, _) = tokio::time::timeout(OAUTH_CALLBACK_TIMEOUT, listener.accept())
+        .await
+        .map_err(|_| "Timed out waiting for Google Calendar authorization.".to_string())?
+        .map_err(|e| format!("accept OAuth callback: {e}"))?;
+
+    let mut buffer = [0_u8; 8192];
+    let bytes_read = stream
+        .read(&mut buffer)
+        .await
+        .map_err(|e| format!("read OAuth callback: {e}"))?;
+    let request = String::from_utf8_lossy(&buffer[..bytes_read]);
+    let request_target = request
+        .lines()
+        .next()
+        .and_then(|line| line.split_whitespace().nth(1))
+        .ok_or_else(|| "Invalid OAuth callback request.".to_string())?;
+    let callback_url = Url::parse(&format!("http://127.0.0.1{request_target}"))
+        .map_err(|e| format!("parse OAuth callback: {e}"))?;
+
+    let mut code = None;
+    let mut state = None;
+    let mut error = None;
+    for (key, value) in callback_url.query_pairs() {
+        match key.as_ref() {
+            "code" => code = Some(value.into_owned()),
+            "state" => state = Some(value.into_owned()),
+            "error" => error = Some(value.into_owned()),
+            _ => {}
+        }
+    }
+
+    let result = if callback_url.path() != OAUTH_CALLBACK_PATH {
+        Err("Google returned an unexpected OAuth callback path.".to_string())
+    } else if let Some(error) = error {
+        Err(format!("Google Calendar authorization failed: {error}"))
+    } else if state.as_deref() != Some(expected_state) {
+        Err("Google Calendar authorization state did not match.".to_string())
+    } else {
+        code.ok_or_else(|| "Google Calendar authorization returned no code.".to_string())
+    };
+
+    let (title, body) = if result.is_ok() {
+        (
+            "Google Calendar authorization received",
+            "Return to Buzz to finish connecting Google Calendar.",
+        )
+    } else {
+        (
+            "Google Calendar connection failed",
+            "Return to Buzz to try connecting again.",
+        )
+    };
+    let response = callback_response(title, body);
+    let _ = stream.write_all(response.as_bytes()).await;
+    let _ = stream.shutdown().await;
+
+    result
+}
+
+async fn exchange_code_for_token(
+    code: &str,
+    code_verifier: &str,
+    redirect_uri: &str,
+    client_id: &str,
+    state: &AppState,
+) -> Result<GoogleTokenResponse, String> {
+    let mut form = vec![
+        ("client_id", client_id.to_string()),
+        ("code", code.to_string()),
+        ("code_verifier", code_verifier.to_string()),
+        ("grant_type", "authorization_code".to_string()),
+        ("redirect_uri", redirect_uri.to_string()),
+    ];
+    if let Some(client_secret) = google_calendar_client_secret() {
+        form.push(("client_secret", client_secret));
+    }
+
+    let response = state
+        .http_client
+        .post(GOOGLE_TOKEN_URL)
+        .form(&form)
+        .send()
+        .await
+        .map_err(|e| format!("Google OAuth token exchange failed: {e}"))?;
+    parse_google_token_response(response).await
+}
+
+async fn refresh_access_token(
+    credential: &GoogleCalendarCredential,
+    client_id: &str,
+    state: &AppState,
+) -> Result<GoogleTokenResponse, String> {
+    let mut form = vec![
+        ("client_id", client_id.to_string()),
+        ("refresh_token", credential.refresh_token.clone()),
+        ("grant_type", "refresh_token".to_string()),
+    ];
+    if let Some(client_secret) = google_calendar_client_secret() {
+        form.push(("client_secret", client_secret));
+    }
+
+    let response = state
+        .http_client
+        .post(GOOGLE_TOKEN_URL)
+        .form(&form)
+        .send()
+        .await
+        .map_err(|e| format!("Google Calendar token refresh failed: {e}"))?;
+    parse_google_token_response(response).await
+}
+
+async fn parse_google_token_response(
+    response: reqwest::Response,
+) -> Result<GoogleTokenResponse, String> {
+    let status = response.status();
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("read Google token response: {e}"))?;
+    if !status.is_success() {
+        return Err(format!("Google token request failed ({status}): {body}"));
+    }
+    serde_json::from_str(&body).map_err(|e| format!("parse Google token response: {e}"))
+}
+
+async fn access_token(state: &AppState) -> Result<String, String> {
+    let client_id = google_calendar_client_id().ok_or_else(|| {
+        "Set BUZZ_GOOGLE_CALENDAR_CLIENT_ID to enable Google Calendar.".to_string()
+    })?;
+    let mut credential = load_credential()?
+        .ok_or_else(|| "Connect Google Calendar before reading events.".to_string())?;
+
+    if let (Some(token), Some(expires_at)) = (&credential.access_token, credential.expires_at) {
+        if expires_at > now_ts() + 60 {
+            return Ok(token.clone());
+        }
+    }
+
+    let token = refresh_access_token(&credential, &client_id, state).await?;
+    let access_token = token
+        .access_token
+        .ok_or_else(|| "Google token refresh returned no access token.".to_string())?;
+    credential.access_token = Some(access_token.clone());
+    credential.expires_at = token.expires_in.map(|seconds| now_ts() + seconds);
+    credential.scope = token.scope.or(credential.scope);
+    credential.token_type = token.token_type.or(credential.token_type);
+    save_credential(&credential)?;
+    Ok(access_token)
+}
+
+fn is_http_url(value: &str) -> bool {
+    Url::parse(value)
+        .map(|url| url.scheme() == "http" || url.scheme() == "https")
+        .unwrap_or(false)
+}
+
+fn event_join_url(event: &GoogleRawEvent) -> Option<String> {
+    event
+        .conference_data
+        .as_ref()
+        .and_then(|data| data.entry_points.as_ref())
+        .and_then(|entry_points| {
+            entry_points
+                .iter()
+                .find(|entry| entry.entry_point_type.as_deref() == Some("video"))
+                .and_then(|entry| entry.uri.as_deref())
+                .filter(|value| is_http_url(value))
+                .map(ToOwned::to_owned)
+                .or_else(|| {
+                    entry_points
+                        .iter()
+                        .filter_map(|entry| entry.uri.as_deref())
+                        .find(|value| is_http_url(value))
+                        .map(ToOwned::to_owned)
+                })
+        })
+        .or_else(|| {
+            event
+                .hangout_link
+                .as_deref()
+                .filter(|value| is_http_url(value))
+                .map(ToOwned::to_owned)
+        })
+}
+
+fn convert_google_event(event: GoogleRawEvent) -> Option<GoogleCalendarEvent> {
+    if event.status.as_deref() == Some("cancelled") {
+        return None;
+    }
+
+    let join_url = event_join_url(&event);
+    let html_url = event
+        .html_link
+        .as_ref()
+        .filter(|value| is_http_url(value))
+        .cloned();
+    let start = event.start?;
+    let end = event.end?;
+    let starts_at = start.date_time.or(start.date)?;
+    let ends_at = end.date_time.or(end.date)?;
+    let all_day = !starts_at.contains('T') && !ends_at.contains('T');
+
+    Some(GoogleCalendarEvent {
+        id: event
+            .id
+            .unwrap_or_else(|| Uuid::new_v4().simple().to_string()),
+        title: event.summary.unwrap_or_else(|| "Busy".to_string()),
+        starts_at,
+        ends_at,
+        all_day,
+        join_url,
+        html_url,
+        transparency: event.transparency,
+    })
+}
+
+#[tauri::command]
+pub fn get_google_calendar_status() -> Result<GoogleCalendarStatus, String> {
+    if google_calendar_client_id().is_none() {
+        return Ok(status_from_credential(None));
+    }
+
+    Ok(status_from_credential(load_credential()?.as_ref()))
+}
+
+#[tauri::command]
+pub async fn connect_google_calendar(
+    state: State<'_, AppState>,
+) -> Result<GoogleCalendarStatus, String> {
+    let client_id = google_calendar_client_id().ok_or_else(|| {
+        "Set BUZZ_GOOGLE_CALENDAR_CLIENT_ID to enable Google Calendar.".to_string()
+    })?;
+    let listener = TcpListener::bind(("127.0.0.1", 0))
+        .await
+        .map_err(|e| format!("bind Google Calendar OAuth callback: {e}"))?;
+    let port = listener
+        .local_addr()
+        .map_err(|e| format!("read OAuth callback address: {e}"))?
+        .port();
+    let redirect_uri = format!("http://127.0.0.1:{port}");
+    let code_verifier = pkce_verifier();
+    let state_token = oauth_state();
+    let auth_url = oauth_authorization_url(
+        &client_id,
+        &redirect_uri,
+        &state_token,
+        &pkce_challenge(&code_verifier),
+    )?;
+
+    tauri_plugin_opener::open_url(auth_url.as_str(), None::<&str>)
+        .map_err(|e| format!("open Google authorization page: {e}"))?;
+
+    let code = wait_for_oauth_callback(listener, &state_token).await?;
+    let token =
+        exchange_code_for_token(&code, &code_verifier, &redirect_uri, &client_id, &state).await?;
+    let refresh_token = token.refresh_token.ok_or_else(|| {
+        "Google did not return a refresh token. Disconnect and try again.".to_string()
+    })?;
+    let credential = GoogleCalendarCredential {
+        access_token: token.access_token,
+        connected_at: now_ts(),
+        expires_at: token.expires_in.map(|seconds| now_ts() + seconds),
+        refresh_token,
+        scope: token.scope,
+        token_type: token.token_type,
+    };
+    save_credential(&credential)?;
+
+    Ok(status_from_credential(Some(&credential)))
+}
+
+#[tauri::command]
+pub fn disconnect_google_calendar() -> Result<GoogleCalendarStatus, String> {
+    credential_store().delete(GOOGLE_CALENDAR_CREDENTIAL_KEY)?;
+    Ok(status_from_credential(None))
+}
+
+#[tauri::command]
+pub async fn get_google_calendar_events(
+    time_min: String,
+    time_max: String,
+    state: State<'_, AppState>,
+) -> Result<Vec<GoogleCalendarEvent>, String> {
+    let access_token = access_token(&state).await?;
+    let mut url = Url::parse("https://www.googleapis.com/calendar/v3/calendars/primary/events")
+        .map_err(|e| e.to_string())?;
+    url.query_pairs_mut()
+        .append_pair("timeMin", &time_min)
+        .append_pair("timeMax", &time_max)
+        .append_pair("singleEvents", "true")
+        .append_pair("orderBy", "startTime")
+        .append_pair("showDeleted", "false")
+        .append_pair("conferenceDataVersion", "1")
+        .append_pair("maxResults", "50");
+
+    let response = state
+        .http_client
+        .get(url)
+        .bearer_auth(access_token)
+        .send()
+        .await
+        .map_err(|e| format!("Google Calendar events request failed: {e}"))?;
+    let status = response.status();
+    let body = response
+        .text()
+        .await
+        .map_err(|e| format!("read Google Calendar events response: {e}"))?;
+    if !status.is_success() {
+        return Err(format!(
+            "Google Calendar events request failed ({status}): {body}"
+        ));
+    }
+
+    let raw: GoogleEventsResponse =
+        serde_json::from_str(&body).map_err(|e| format!("parse Google Calendar events: {e}"))?;
+    Ok(raw
+        .items
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(convert_google_event)
+        .collect())
+}
diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs
index 445fe2956..4a73f8c4e 100644
--- a/desktop/src-tauri/src/commands/mod.rs
+++ b/desktop/src-tauri/src/commands/mod.rs
@@ -3,6 +3,7 @@ mod agent_discovery;
 mod agent_models;
 mod agent_settings;
 mod agents;
+mod calendar;
 mod canvas;
 mod channel_templates;
 mod channels;
@@ -36,6 +37,7 @@ pub use agent_discovery::*;
 pub use agent_models::*;
 pub use agent_settings::*;
 pub use agents::*;
+pub use calendar::*;
 pub use canvas::*;
 pub use channel_templates::*;
 pub use channels::*;
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index 369046a9d..e6db0b0a2 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -445,6 +445,10 @@ pub fn run() {
             get_relay_ws_url,
             get_relay_http_url,
             get_media_proxy_port,
+            get_google_calendar_status,
+            connect_google_calendar,
+            disconnect_google_calendar,
+            get_google_calendar_events,
             fetch_link_preview_title,
             discover_acp_providers,
             install_acp_runtime,
diff --git a/desktop/src/features/calendar/api.ts b/desktop/src/features/calendar/api.ts
new file mode 100644
index 000000000..e905b7b54
--- /dev/null
+++ b/desktop/src/features/calendar/api.ts
@@ -0,0 +1,88 @@
+import { invokeTauri } from "@/shared/api/tauri";
+
+export type GoogleCalendarStatus = {
+  configured: boolean;
+  connected: boolean;
+  connectedAt: number | null;
+  scopes: string[];
+};
+
+export type GoogleCalendarEvent = {
+  id: string;
+  title: string;
+  startsAt: string;
+  endsAt: string;
+  allDay: boolean;
+  joinUrl: string | null;
+  htmlUrl: string | null;
+  transparency: string | null;
+};
+
+type RawGoogleCalendarStatus = {
+  configured: boolean;
+  connected: boolean;
+  connected_at: number | null;
+  scopes: string[];
+};
+
+type RawGoogleCalendarEvent = {
+  id: string;
+  title: string;
+  starts_at: string;
+  ends_at: string;
+  all_day: boolean;
+  join_url: string | null;
+  html_url: string | null;
+  transparency: string | null;
+};
+
+function fromRawStatus(raw: RawGoogleCalendarStatus): GoogleCalendarStatus {
+  return {
+    configured: raw.configured,
+    connected: raw.connected,
+    connectedAt: raw.connected_at,
+    scopes: raw.scopes,
+  };
+}
+
+function fromRawEvent(raw: RawGoogleCalendarEvent): GoogleCalendarEvent {
+  return {
+    id: raw.id,
+    title: raw.title,
+    startsAt: raw.starts_at,
+    endsAt: raw.ends_at,
+    allDay: raw.all_day,
+    joinUrl: raw.join_url,
+    htmlUrl: raw.html_url,
+    transparency: raw.transparency,
+  };
+}
+
+export async function getGoogleCalendarStatus(): Promise<GoogleCalendarStatus> {
+  return fromRawStatus(
+    await invokeTauri<RawGoogleCalendarStatus>("get_google_calendar_status"),
+  );
+}
+
+export async function connectGoogleCalendar(): Promise<GoogleCalendarStatus> {
+  return fromRawStatus(
+    await invokeTauri<RawGoogleCalendarStatus>("connect_google_calendar"),
+  );
+}
+
+export async function disconnectGoogleCalendar(): Promise<GoogleCalendarStatus> {
+  return fromRawStatus(
+    await invokeTauri<RawGoogleCalendarStatus>("disconnect_google_calendar"),
+  );
+}
+
+export async function getGoogleCalendarEvents(input: {
+  timeMax: string;
+  timeMin: string;
+}): Promise<GoogleCalendarEvent[]> {
+  const raw = await invokeTauri<RawGoogleCalendarEvent[]>(
+    "get_google_calendar_events",
+    input,
+  );
+  return raw.map(fromRawEvent);
+}
diff --git a/desktop/src/features/calendar/hooks.ts b/desktop/src/features/calendar/hooks.ts
new file mode 100644
index 000000000..7d4f112ff
--- /dev/null
+++ b/desktop/src/features/calendar/hooks.ts
@@ -0,0 +1,203 @@
+import * as React from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+import {
+  connectGoogleCalendar,
+  disconnectGoogleCalendar,
+  getGoogleCalendarEvents,
+  getGoogleCalendarStatus,
+  type GoogleCalendarEvent,
+} from "@/features/calendar/api";
+
+export const googleCalendarStatusQueryKey = ["google-calendar-status"] as const;
+
+export const googleCalendarEventsQueryKey = (
+  timeMin: string,
+  timeMax: string,
+) => ["google-calendar-events", timeMin, timeMax] as const;
+
+const calendarBusyTimeFormatter = new Intl.DateTimeFormat(undefined, {
+  hour: "numeric",
+  minute: "2-digit",
+});
+
+function useCalendarNow(enabled: boolean): number {
+  const [now, setNow] = React.useState(() => Date.now());
+
+  React.useEffect(() => {
+    if (!enabled) return;
+
+    setNow(Date.now());
+    const interval = window.setInterval(() => setNow(Date.now()), 60_000);
+    return () => window.clearInterval(interval);
+  }, [enabled]);
+
+  return now;
+}
+
+export function useGoogleCalendarStatusQuery({
+  enabled = true,
+}: {
+  enabled?: boolean;
+} = {}) {
+  return useQuery({
+    enabled,
+    queryKey: googleCalendarStatusQueryKey,
+    queryFn: getGoogleCalendarStatus,
+    staleTime: 60_000,
+  });
+}
+
+export function useGoogleCalendarEventsQuery({
+  enabled,
+  timeMax,
+  timeMin,
+}: {
+  enabled: boolean;
+  timeMax: string;
+  timeMin: string;
+}) {
+  return useQuery({
+    enabled,
+    queryKey: googleCalendarEventsQueryKey(timeMin, timeMax),
+    queryFn: () => getGoogleCalendarEvents({ timeMax, timeMin }),
+    refetchInterval: enabled ? 60_000 : false,
+    staleTime: 45_000,
+  });
+}
+
+export function useGoogleCalendarConnectionMutations() {
+  const queryClient = useQueryClient();
+  const invalidate = () => {
+    void queryClient.invalidateQueries({
+      queryKey: googleCalendarStatusQueryKey,
+    });
+    void queryClient.invalidateQueries({
+      predicate: (query) => query.queryKey[0] === "google-calendar-events",
+    });
+  };
+
+  const connect = useMutation({
+    mutationFn: connectGoogleCalendar,
+    onSuccess: invalidate,
+  });
+  const disconnect = useMutation({
+    mutationFn: disconnectGoogleCalendar,
+    onSuccess: invalidate,
+  });
+
+  return { connect, disconnect };
+}
+
+export function eventStartDate(event: GoogleCalendarEvent): Date {
+  return parseCalendarDate(event.startsAt, event.allDay);
+}
+
+export function eventEndDate(event: GoogleCalendarEvent): Date {
+  return parseCalendarDate(event.endsAt, event.allDay);
+}
+
+export function isBusyCalendarEvent(event: GoogleCalendarEvent): boolean {
+  return !event.allDay && event.transparency !== "transparent";
+}
+
+export function isOngoingCalendarEvent(
+  event: GoogleCalendarEvent,
+  nowMs: number,
+): boolean {
+  return (
+    isBusyCalendarEvent(event) &&
+    eventStartDate(event).getTime() <= nowMs &&
+    eventEndDate(event).getTime() > nowMs
+  );
+}
+
+export function isUpcomingCalendarEvent(
+  event: GoogleCalendarEvent,
+  nowMs: number,
+): boolean {
+  return isBusyCalendarEvent(event) && eventStartDate(event).getTime() > nowMs;
+}
+
+export function formatCalendarBusyLabel(event: GoogleCalendarEvent): string {
+  return `In meeting until ${calendarBusyTimeFormatter.format(
+    eventEndDate(event),
+  )}`;
+}
+
+export function parseCalendarDate(value: string, allDay: boolean): Date {
+  if (allDay && /^\d{4}-\d{2}-\d{2}$/.test(value)) {
+    return new Date(`${value}T00:00:00`);
+  }
+  return new Date(value);
+}
+
+export function todayCalendarWindow(nowMs = Date.now()): {
+  timeMax: string;
+  timeMin: string;
+} {
+  const start = new Date(nowMs);
+  start.setHours(0, 0, 0, 0);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  return {
+    timeMin: start.toISOString(),
+    timeMax: end.toISOString(),
+  };
+}
+
+export function currentCalendarWindow(nowMs = Date.now()): {
+  timeMax: string;
+  timeMin: string;
+} {
+  const start = new Date(nowMs - 60 * 60 * 1_000);
+  const end = new Date(nowMs + 8 * 60 * 60 * 1_000);
+  return {
+    timeMin: start.toISOString(),
+    timeMax: end.toISOString(),
+  };
+}
+
+export function useCurrentGoogleCalendarEvent({
+  enabled = true,
+}: {
+  enabled?: boolean;
+} = {}) {
+  const now = useCalendarNow(enabled);
+  const statusQuery = useGoogleCalendarStatusQuery({ enabled });
+  const window = React.useMemo(() => todayCalendarWindow(now), [now]);
+  const eventsQuery = useGoogleCalendarEventsQuery({
+    enabled: Boolean(
+      enabled && statusQuery.data?.configured && statusQuery.data.connected,
+    ),
+    timeMax: window.timeMax,
+    timeMin: window.timeMin,
+  });
+  const events = eventsQuery.data ?? [];
+  const sortedEvents = React.useMemo(
+    () =>
+      [...events].sort(
+        (a, b) => eventStartDate(a).getTime() - eventStartDate(b).getTime(),
+      ),
+    [events],
+  );
+  const currentEvent = React.useMemo(
+    () =>
+      sortedEvents.find((event) => isOngoingCalendarEvent(event, now)) ?? null,
+    [sortedEvents, now],
+  );
+  const nextEvent = React.useMemo(
+    () =>
+      sortedEvents.find((event) => isUpcomingCalendarEvent(event, now)) ?? null,
+    [sortedEvents, now],
+  );
+
+  return {
+    currentEvent,
+    eventsQuery,
+    isConnected: Boolean(statusQuery.data?.connected),
+    isConfigured: Boolean(statusQuery.data?.configured),
+    nextEvent,
+    statusQuery,
+  };
+}
diff --git a/desktop/src/features/calendar/ui/CalendarSettingsCard.tsx b/desktop/src/features/calendar/ui/CalendarSettingsCard.tsx
new file mode 100644
index 000000000..aeee6d450
--- /dev/null
+++ b/desktop/src/features/calendar/ui/CalendarSettingsCard.tsx
@@ -0,0 +1,134 @@
+import { CalendarDays, Check, ExternalLink, Plug, Unplug } from "lucide-react";
+
+import {
+  useGoogleCalendarConnectionMutations,
+  useGoogleCalendarStatusQuery,
+} from "@/features/calendar/hooks";
+import { Button } from "@/shared/ui/button";
+import {
+  SettingsOptionGroup,
+  SettingsOptionRow,
+} from "@/features/settings/ui/SettingsOptionGroup";
+import { SettingsSectionHeader } from "@/features/settings/ui/SettingsSectionHeader";
+
+function errorMessage(error: unknown): string | null {
+  if (!error) return null;
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function ConnectionsSettingsCard() {
+  const statusQuery = useGoogleCalendarStatusQuery();
+  const { connect, disconnect } = useGoogleCalendarConnectionMutations();
+  const status = statusQuery.data;
+  const isBusy = connect.isPending || disconnect.isPending;
+  const isLoading = statusQuery.isLoading;
+  const mutationError =
+    errorMessage(connect.error) ?? errorMessage(disconnect.error);
+  const statusError = errorMessage(statusQuery.error);
+  const description = isLoading
+    ? "Checking Google Calendar connection status."
+    : status?.connected
+      ? "Connected with read-only event access. Meeting details stay on this device."
+      : status?.configured
+        ? "Connect to read upcoming events and video meeting links."
+        : "Google Calendar is unavailable until this build includes a Google OAuth client ID.";
+
+  return (
+    <section className="min-w-0" data-testid="settings-connections">
+      <SettingsSectionHeader
+        title="Connections"
+        description="Connect apps on this device so Buzz can bring their context into your workspace."
+      />
+
+      <div className="flex flex-col gap-4">
+        <SettingsOptionGroup>
+          <SettingsOptionRow>
+            <div className="min-w-0">
+              <span className="flex items-center gap-2 text-sm font-medium">
+                <CalendarDays className="h-4 w-4 text-muted-foreground" />
+                Google Calendar
+              </span>
+              <p className="text-sm font-normal text-muted-foreground">
+                {description}
+              </p>
+            </div>
+            {status?.connected ? (
+              <Button
+                disabled={isBusy}
+                onClick={() => disconnect.mutate()}
+                size="sm"
+                type="button"
+                variant="outline"
+              >
+                <Unplug />
+                Disconnect
+              </Button>
+            ) : (
+              <Button
+                disabled={isLoading || isBusy || !status?.configured}
+                onClick={() => connect.mutate()}
+                size="sm"
+                type="button"
+              >
+                <Plug />
+                Connect
+              </Button>
+            )}
+          </SettingsOptionRow>
+        </SettingsOptionGroup>
+
+        {status?.connected ? (
+          <div className="flex items-center gap-2 rounded-lg border border-primary/20 bg-primary/5 px-3 py-2 text-sm text-primary">
+            <Check className="h-4 w-4 shrink-0" />
+            <span className="min-w-0">
+              Google Calendar is ready. The sidebar will show current and
+              upcoming meetings.
+            </span>
+          </div>
+        ) : null}
+
+        {!isLoading && !status?.configured ? (
+          <div className="rounded-lg border border-border/70 bg-muted/20 px-3 py-2 text-sm text-muted-foreground">
+            Connect is unavailable because this build is missing its Google
+            OAuth client ID. End users do not create this themselves; local and
+            staging builds need{" "}
+            <code className="rounded bg-muted px-1 py-0.5 text-xs">
+              BUZZ_GOOGLE_CALENDAR_CLIENT_ID
+            </code>
+            . If the OAuth app has a client secret, also provide{" "}
+            <code className="rounded bg-muted px-1 py-0.5 text-xs">
+              BUZZ_GOOGLE_CALENDAR_CLIENT_SECRET
+            </code>
+            .
+          </div>
+        ) : null}
+
+        {!status?.connected && status?.configured ? (
+          <div className="rounded-lg border border-border/70 bg-muted/20 px-3 py-2 text-sm text-muted-foreground">
+            Connect opens Google OAuth in your browser. After you approve
+            read-only calendar access, Buzz stores the refresh token in the
+            system keychain.
+          </div>
+        ) : null}
+
+        {statusError || mutationError ? (
+          <div className="rounded-lg border border-destructive/30 bg-destructive/10 px-3 py-2 text-sm text-destructive">
+            {mutationError ?? statusError}
+          </div>
+        ) : null}
+
+        <a
+          className="inline-flex w-fit items-center gap-1.5 text-sm text-muted-foreground underline-offset-4 hover:text-foreground hover:underline"
+          href="https://developers.google.com/identity/protocols/oauth2/native-app"
+          rel="noreferrer"
+          target="_blank"
+        >
+          Google OAuth desktop app setup
+          <ExternalLink className="h-3.5 w-3.5" />
+        </a>
+      </div>
+    </section>
+  );
+}
+
+export const CalendarSettingsCard = ConnectionsSettingsCard;
diff --git a/desktop/src/features/profile/ui/ProfilePopover.tsx b/desktop/src/features/profile/ui/ProfilePopover.tsx
index 7b6478767..b06f08377 100644
--- a/desktop/src/features/profile/ui/ProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/ProfilePopover.tsx
@@ -1,5 +1,5 @@
 import * as React from "react";
-import { ChevronRight, Smile } from "lucide-react";
+import { CalendarDays, ChevronRight, Smile } from "lucide-react";
 
 import { Popover, PopoverContent, PopoverTrigger } from "@/shared/ui/popover";
 import { ProfileAvatar } from "@/features/profile/ui/ProfileAvatar";
@@ -18,6 +18,7 @@ interface ProfilePopoverProps {
   avatarDataUrl?: string | null;
   currentStatus: PresenceStatus;
   isStatusPending?: boolean;
+  calendarBusyLabel?: string | null;
   userStatusText?: string;
   userStatusEmoji?: string;
   onSetStatus: (status: PresenceStatus) => void;
@@ -48,6 +49,7 @@ export function ProfilePopover({
   avatarDataUrl,
   currentStatus,
   isStatusPending,
+  calendarBusyLabel,
   userStatusText,
   userStatusEmoji,
   onSetStatus,
@@ -62,6 +64,7 @@ export function ProfilePopover({
   const [presenceMenuOpen, setPresenceMenuOpen] = React.useState(false);
   const presenceHoverTimer = React.useRef<number | null>(null);
   const hasUserStatus = Boolean(userStatusText || userStatusEmoji);
+  const hasCalendarBusy = Boolean(calendarBusyLabel);
   const settingsShortcutLabel = isMacPlatform() ? "⌘," : "Ctrl+,";
 
   function clearPresenceHoverTimer() {
@@ -167,7 +170,11 @@ export function ProfilePopover({
                 role="menuitem"
                 type="button"
               >
-                <Smile className="h-4 w-4 shrink-0 text-muted-foreground" />
+                {hasCalendarBusy && !hasUserStatus ? (
+                  <CalendarDays className="h-4 w-4 shrink-0 text-muted-foreground" />
+                ) : (
+                  <Smile className="h-4 w-4 shrink-0 text-muted-foreground" />
+                )}
                 {hasUserStatus ? (
                   <span className="flex min-w-0 flex-1 items-center gap-1 truncate text-popover-foreground">
                     {userStatusEmoji ? (
@@ -178,6 +185,10 @@ export function ProfilePopover({
                     ) : null}
                     <span className="truncate">{userStatusText}</span>
                   </span>
+                ) : hasCalendarBusy ? (
+                  <span className="flex-1 truncate text-popover-foreground">
+                    {calendarBusyLabel}
+                  </span>
                 ) : (
                   <span className="flex-1 truncate text-muted-foreground">
                     Update your status
diff --git a/desktop/src/features/profile/ui/UserProfilePopover.tsx b/desktop/src/features/profile/ui/UserProfilePopover.tsx
index be6b1f6c3..ca27216b3 100644
--- a/desktop/src/features/profile/ui/UserProfilePopover.tsx
+++ b/desktop/src/features/profile/ui/UserProfilePopover.tsx
@@ -1,6 +1,11 @@
 import * as React from "react";
 import { useQueryClient } from "@tanstack/react-query";
-import { Activity, Headphones, MessageSquare } from "lucide-react";
+import {
+  Activity,
+  CalendarDays,
+  Headphones,
+  MessageSquare,
+} from "lucide-react";
 import { toast } from "sonner";
 
 import { useAppNavigation } from "@/app/navigation/useAppNavigation";
@@ -42,6 +47,10 @@ import { BotIdenticon } from "@/features/messages/ui/BotIdenticon";
 import { useNow } from "@/shared/lib/useNow";
 import { Button } from "@/shared/ui/button";
 import { Spinner } from "@/shared/ui/spinner";
+import {
+  formatCalendarBusyLabel,
+  useCurrentGoogleCalendarEvent,
+} from "@/features/calendar/hooks";
 
 type UserProfilePopoverProps = {
   children: React.ReactNode;
@@ -216,6 +225,13 @@ export function UserProfilePopover({
   const isSelf =
     currentPubkey !== undefined &&
     currentPubkey.toLowerCase() === pubkey.toLowerCase();
+  const { currentEvent: selfCalendarEvent } = useCurrentGoogleCalendarEvent({
+    enabled: open && isSelf,
+  });
+  const selfCalendarBusyLabel = selfCalendarEvent
+    ? formatCalendarBusyLabel(selfCalendarEvent)
+    : null;
+  const hasSelfCalendarBusy = Boolean(selfCalendarBusyLabel);
   const showProfileActions = currentPubkey !== undefined && !isSelf;
   const selfProfileQuery = useProfileQuery(open && showProfileActions);
   const isCurrentUserOwner =
@@ -573,7 +589,7 @@ export function UserProfilePopover({
             </button>
           ) : null}
 
-          {hasUserStatus || showProfileActions ? (
+          {hasUserStatus || hasSelfCalendarBusy || showProfileActions ? (
             <>
               <div
                 aria-hidden="true"
@@ -592,6 +608,12 @@ export function UserProfilePopover({
                   ) : null}
                 </StatusLine>
               ) : null}
+              {hasSelfCalendarBusy ? (
+                <StatusLine>
+                  <CalendarDays className="h-3.5 w-3.5 shrink-0" />
+                  <span className="truncate">{selfCalendarBusyLabel}</span>
+                </StatusLine>
+              ) : null}
               {showProfileActions ? (
                 <div className="flex gap-2">
                   <Button
diff --git a/desktop/src/features/settings/ui/SettingsPanels.tsx b/desktop/src/features/settings/ui/SettingsPanels.tsx
index 944b32246..7c6dfff0b 100644
--- a/desktop/src/features/settings/ui/SettingsPanels.tsx
+++ b/desktop/src/features/settings/ui/SettingsPanels.tsx
@@ -12,6 +12,7 @@ import {
   Monitor,
   MonitorCog,
   Moon,
+  Plug,
   Search,
   Smartphone,
   Smile,
@@ -27,6 +28,7 @@ import type {
 import type { SoundName, SoundSlot } from "@/features/notifications/lib/sound";
 import { RelayMembersSettingsCard } from "@/features/relay-members/ui/RelayMembersSettingsCard";
 import { CustomEmojiSettingsCard } from "@/features/custom-emoji/ui/CustomEmojiSettingsCard";
+import { ConnectionsSettingsCard } from "@/features/calendar/ui/CalendarSettingsCard";
 import { cn } from "@/shared/lib/cn";
 import {
   ACCENT_COLORS,
@@ -50,6 +52,7 @@ import { SettingsSectionHeader } from "./SettingsSectionHeader";
 export type SettingsSection =
   | "profile"
   | "notifications"
+  | "connections"
   | "experimental"
   | "agents"
   | "channel-templates"
@@ -67,6 +70,7 @@ export const DEFAULT_SETTINGS_SECTION: SettingsSection = "profile";
 const SETTINGS_SECTION_VALUES: readonly SettingsSection[] = [
   "profile",
   "notifications",
+  "connections",
   "experimental",
   "agents",
   "channel-templates",
@@ -137,6 +141,11 @@ export const settingsSections: SettingsSectionDescriptor[] = [
     icon: Bot,
     featureGate: "managed-agents",
   },
+  {
+    value: "connections",
+    label: "Connections",
+    icon: Plug,
+  },
   {
     value: "channel-templates",
     label: "Templates",
@@ -370,6 +379,8 @@ export function renderSettingsSection(
           onSetSoundForSlot={props.onSetSoundForSlot}
         />
       );
+    case "connections":
+      return <ConnectionsSettingsCard />;
     case "experimental":
       return <ExperimentalFeaturesCard />;
     case "agents":
diff --git a/desktop/src/features/settings/ui/SettingsView.tsx b/desktop/src/features/settings/ui/SettingsView.tsx
index 4a8de7cb7..7c5a20852 100644
--- a/desktop/src/features/settings/ui/SettingsView.tsx
+++ b/desktop/src/features/settings/ui/SettingsView.tsx
@@ -64,6 +64,7 @@ const settingsNavGroups: Array<{
     label: "App",
     sections: [
       "agents",
+      "connections",
       "compute",
       "experimental",
       "mobile",
diff --git a/desktop/src/features/sidebar/ui/AppSidebar.tsx b/desktop/src/features/sidebar/ui/AppSidebar.tsx
index 46293a3d4..b45964ed7 100644
--- a/desktop/src/features/sidebar/ui/AppSidebar.tsx
+++ b/desktop/src/features/sidebar/ui/AppSidebar.tsx
@@ -7,6 +7,10 @@ import { SidebarDndContext } from "@/features/sidebar/ui/SidebarDnd";
 
 import type { Workspace } from "@/features/workspaces/types";
 import { AddWorkspaceDialog } from "@/features/workspaces/ui/AddWorkspaceDialog";
+import {
+  formatCalendarBusyLabel,
+  useCurrentGoogleCalendarEvent,
+} from "@/features/calendar/hooks";
 import { useDeferredLoad } from "@/shared/hooks/useDeferredStartup";
 import {
   useChannelSections,
@@ -224,6 +228,8 @@ export function AppSidebar({
   onUnstarChannel,
 }: AppSidebarProps) {
   const activeWorkingByChannelId = useActiveWorkingChannelsById();
+  const { currentEvent: currentCalendarEvent, nextEvent: nextCalendarEvent } =
+    useCurrentGoogleCalendarEvent();
   const { status: updateStatus } = useUpdaterContext();
   const canShowSidebarUpdateCard = shouldShowSidebarUpdateCard(updateStatus);
   const sidebarRelayConnectionCard = useSidebarRelayConnectionCard(
@@ -449,14 +455,18 @@ export function AppSidebar({
     immediate: isSelectedDirectMessage,
     timeoutMs: 400,
   });
-  const { dmChannelLabels, dmParticipantsByChannelId, dmPresenceByChannelId } =
-    useDmSidebarMetadata({
-      currentPubkey,
-      directMessages,
-      enabled: shouldLoadDmMetadata,
-      fallbackDisplayName,
-      profileDisplayName: profile?.displayName,
-    });
+  const {
+    dmChannelLabels,
+    dmInMeetingByChannelId,
+    dmParticipantsByChannelId,
+    dmPresenceByChannelId,
+  } = useDmSidebarMetadata({
+    currentPubkey,
+    directMessages,
+    enabled: shouldLoadDmMetadata,
+    fallbackDisplayName,
+    profileDisplayName: profile?.displayName,
+  });
   const sortedDirectMessages = React.useMemo(
     () => sortDmChannelsByLabel(directMessages, dmChannelLabels),
     [directMessages, dmChannelLabels],
@@ -473,6 +483,9 @@ export function AppSidebar({
     profile?.displayName?.trim() ||
     fallbackDisplayName?.trim() ||
     "Current identity";
+  const calendarBusyLabel = currentCalendarEvent
+    ? formatCalendarBusyLabel(currentCalendarEvent)
+    : null;
   const {
     scrollToNextAbove,
     scrollToNextBelow,
@@ -525,6 +538,8 @@ export function AppSidebar({
         data-testid="app-sidebar-scroll-anchor"
       >
         <AppSidebarPinnedHeader
+          calendarEvent={currentCalendarEvent ?? nextCalendarEvent}
+          calendarNow={Date.now()}
           channelLabels={dmChannelLabels}
           currentPubkey={currentPubkey}
           homeBadgeCount={homeBadgeCount}
@@ -735,6 +750,7 @@ export function AppSidebar({
                     </div>
                   }
                   dmParticipantsByChannelId={dmParticipantsByChannelId}
+                  dmInMeetingByChannelId={dmInMeetingByChannelId}
                   isCollapsed={collapsedGroups.directMessages}
                   isActiveChannel={selectedView === "channel"}
                   activeWorkingByChannelId={activeWorkingByChannelId}
@@ -810,6 +826,7 @@ export function AppSidebar({
               <SidebarMenuItem>
                 <SidebarProfileCard
                   activeWorkspace={activeWorkspace}
+                  calendarBusyLabel={calendarBusyLabel}
                   isPresencePending={isPresencePending}
                   onOpenAddWorkspace={onOpenAddWorkspace}
                   onOpenSettings={onSelectSettings}
diff --git a/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx b/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
index 5d87190d2..0d0899b86 100644
--- a/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
+++ b/desktop/src/features/sidebar/ui/AppSidebarPinnedHeader.tsx
@@ -1,7 +1,21 @@
-import { Activity, Bot, FolderGit2, Inbox, Zap } from "lucide-react";
+import { openUrl } from "@tauri-apps/plugin-opener";
+import {
+  Activity,
+  Bot,
+  CalendarDays,
+  FolderGit2,
+  Inbox,
+  Video,
+  Zap,
+} from "lucide-react";
 
 import { TopbarSearch } from "@/features/search/ui/TopbarSearch";
 import { FeatureGate } from "@/shared/features";
+import type { GoogleCalendarEvent } from "@/features/calendar/api";
+import {
+  eventStartDate,
+  isOngoingCalendarEvent,
+} from "@/features/calendar/hooks";
 import type { Channel, SearchHit } from "@/shared/api/types";
 import {
   SidebarHeader,
@@ -19,7 +33,86 @@ type SidebarSelectedView =
   | "pulse"
   | "projects";
 
+function formatCalendarStart(event: GoogleCalendarEvent, nowMs: number) {
+  const startsAt = eventStartDate(event).getTime();
+  const minutes = Math.max(0, Math.ceil((startsAt - nowMs) / 60_000));
+
+  if (minutes <= 0) return "Now";
+  if (minutes < 60) return `in ${minutes}m`;
+
+  const hours = Math.floor(minutes / 60);
+  const remainder = minutes % 60;
+  return remainder === 0 ? `in ${hours}h` : `in ${hours}h ${remainder}m`;
+}
+
+function CalendarMenuItem({
+  event,
+  now,
+}: {
+  event: GoogleCalendarEvent | null;
+  now: number;
+}) {
+  const emptyTitle = "No upcoming meetings";
+  const title = event?.title.trim() || emptyTitle;
+  const isOngoing = event ? isOngoingCalendarEvent(event, now) : false;
+  const joinUrl = event?.joinUrl ?? null;
+  const showJoin = Boolean(isOngoing && joinUrl);
+  const canOpenJoinUrl = Boolean(showJoin && joinUrl);
+  const meta = event ? formatCalendarStart(event, now) : null;
+  const content = (
+    <>
+      <CalendarDays className="h-4 w-4" />
+      <span className="min-w-0 flex-1 truncate pr-2">{title}</span>
+      {showJoin ? (
+        <>
+          <span className="shrink-0 text-2xs font-medium text-sidebar-foreground/60 group-hover/calendar:hidden group-focus-visible/calendar:hidden">
+            Now
+          </span>
+          <span className="hidden shrink-0 items-center gap-1 rounded-full bg-primary/10 px-1.5 py-0.5 text-2xs font-medium text-primary group-hover/calendar:inline-flex group-focus-visible/calendar:inline-flex">
+            <Video className="h-3 w-3" />
+            Join
+          </span>
+        </>
+      ) : meta ? (
+        <span className="shrink-0 text-2xs font-medium text-sidebar-foreground/60">
+          {meta}
+        </span>
+      ) : null}
+    </>
+  );
+
+  if (!canOpenJoinUrl) {
+    return (
+      <SidebarMenuItem>
+        <SidebarMenuButton asChild className="group/calendar" tooltip={title}>
+          <div data-testid="sidebar-calendar-status">{content}</div>
+        </SidebarMenuButton>
+      </SidebarMenuItem>
+    );
+  }
+
+  return (
+    <SidebarMenuItem>
+      <SidebarMenuButton
+        aria-label={showJoin ? `Join ${title}` : title}
+        className="group/calendar"
+        data-testid="sidebar-calendar-status"
+        onClick={() => {
+          if (!canOpenJoinUrl || !joinUrl) return;
+          void openUrl(joinUrl);
+        }}
+        tooltip={title}
+        type="button"
+      >
+        {content}
+      </SidebarMenuButton>
+    </SidebarMenuItem>
+  );
+}
+
 type AppSidebarPinnedHeaderProps = {
+  calendarEvent: GoogleCalendarEvent | null;
+  calendarNow: number;
   channelLabels: Record<string, string>;
   currentPubkey?: string;
   homeBadgeCount: number;
@@ -40,6 +133,8 @@ type AppSidebarPinnedHeaderProps = {
 };
 
 export function AppSidebarPinnedHeader({
+  calendarEvent,
+  calendarNow,
   channelLabels,
   currentPubkey,
   homeBadgeCount,
@@ -76,7 +171,7 @@ export function AppSidebarPinnedHeader({
         className="cursor-default select-none px-0 pb-0 pt-2.5"
         data-tauri-drag-region
       >
-        <SidebarMenu className="pb-2">
+        <SidebarMenu className="pb-1">
           <SidebarMenuItem>
             <SidebarMenuButton
               isActive={selectedView === "home"}
@@ -96,6 +191,19 @@ export function AppSidebarPinnedHeader({
               </SidebarMenuBadge>
             ) : null}
           </SidebarMenuItem>
+          <SidebarMenuItem>
+            <SidebarMenuButton
+              data-testid="open-agents-view"
+              isActive={selectedView === "agents"}
+              onClick={onSelectAgents}
+              tooltip="Agents"
+              type="button"
+            >
+              <Bot className="h-4 w-4" />
+              <span>Agents</span>
+            </SidebarMenuButton>
+          </SidebarMenuItem>
+          <CalendarMenuItem event={calendarEvent} now={calendarNow} />
           <FeatureGate feature="pulse">
             <SidebarMenuItem>
               <SidebarMenuButton
@@ -124,18 +232,6 @@ export function AppSidebarPinnedHeader({
               </SidebarMenuButton>
             </SidebarMenuItem>
           </FeatureGate>
-          <SidebarMenuItem>
-            <SidebarMenuButton
-              data-testid="open-agents-view"
-              isActive={selectedView === "agents"}
-              onClick={onSelectAgents}
-              tooltip="Agents"
-              type="button"
-            >
-              <Bot className="h-4 w-4" />
-              <span>Agents</span>
-            </SidebarMenuButton>
-          </SidebarMenuItem>
           <FeatureGate feature="workflows">
             <SidebarMenuItem>
               <SidebarMenuButton
diff --git a/desktop/src/features/sidebar/ui/SidebarProfileCard.tsx b/desktop/src/features/sidebar/ui/SidebarProfileCard.tsx
index 885dd7e9a..a1e899e08 100644
--- a/desktop/src/features/sidebar/ui/SidebarProfileCard.tsx
+++ b/desktop/src/features/sidebar/ui/SidebarProfileCard.tsx
@@ -1,4 +1,5 @@
 import * as React from "react";
+import { CalendarDays } from "lucide-react";
 
 import { getPresenceLabel } from "@/features/presence/lib/presence";
 import { PresenceDot } from "@/features/presence/ui/PresenceBadge";
@@ -17,6 +18,7 @@ import { cn } from "@/shared/lib/cn";
 
 type SidebarProfileCardProps = {
   activeWorkspace: Workspace | null;
+  calendarBusyLabel?: string | null;
   isPresencePending?: boolean;
   onOpenAddWorkspace: () => void;
   onOpenSettings: (section?: "profile" | "appearance") => void;
@@ -38,6 +40,7 @@ type SidebarProfileCardProps = {
 
 export function SidebarProfileCard({
   activeWorkspace,
+  calendarBusyLabel,
   isPresencePending,
   onOpenAddWorkspace,
   onOpenSettings,
@@ -74,6 +77,7 @@ export function SidebarProfileCard({
     [toggleProfilePopover],
   );
   const hasStatus = Boolean(selfUserStatus?.text || selfUserStatus?.emoji);
+  const hasCalendarBusy = Boolean(calendarBusyLabel);
   const workspaceLabel = activeWorkspace?.name ?? "No workspace";
   const readonlyWorkspaceLabel = (
     <span className="flex min-w-0 cursor-pointer items-center gap-1 text-xs leading-snug text-sidebar-foreground/70">
@@ -143,6 +147,7 @@ export function SidebarProfileCard({
             currentStatus={selfPresenceStatus}
             displayName={resolvedDisplayName}
             isStatusPending={isPresencePending}
+            calendarBusyLabel={calendarBusyLabel}
             onClearUserStatus={onClearUserStatus}
             onOpenSettings={onOpenSettings}
             onSetStatus={onSetPresenceStatus ?? (() => {})}
@@ -180,7 +185,7 @@ export function SidebarProfileCard({
             </button>
           </ProfilePopover>
 
-          {hasStatus ? (
+          {hasStatus || hasCalendarBusy ? (
             <div className="relative mt-0.5">
               <button
                 aria-label={`Open profile menu for ${resolvedDisplayName}`}
@@ -195,13 +200,22 @@ export function SidebarProfileCard({
                 }}
                 type="button"
               >
-                {selfUserStatus?.emoji ? (
-                  <StatusEmoji
-                    className="mr-1 w-4 shrink-0 text-xs"
-                    value={selfUserStatus.emoji}
-                  />
-                ) : null}
-                <span className="truncate">{selfUserStatus?.text}</span>
+                {hasStatus ? (
+                  <>
+                    {selfUserStatus?.emoji ? (
+                      <StatusEmoji
+                        className="mr-1 w-4 shrink-0 text-xs"
+                        value={selfUserStatus.emoji}
+                      />
+                    ) : null}
+                    <span className="truncate">{selfUserStatus?.text}</span>
+                  </>
+                ) : (
+                  <>
+                    <CalendarDays className="mr-1 h-3.5 w-3.5 shrink-0 text-sidebar-foreground/55" />
+                    <span className="truncate">{calendarBusyLabel}</span>
+                  </>
+                )}
               </button>
               <div
                 className={cn(
diff --git a/desktop/src/features/sidebar/ui/SidebarSection.tsx b/desktop/src/features/sidebar/ui/SidebarSection.tsx
index d435553b4..667d0031c 100644
--- a/desktop/src/features/sidebar/ui/SidebarSection.tsx
+++ b/desktop/src/features/sidebar/ui/SidebarSection.tsx
@@ -1,6 +1,7 @@
 import type * as React from "react";
 import {
   BellOff,
+  CalendarDays,
   ChevronDown,
   CircleDot,
   FileText,
@@ -234,6 +235,7 @@ export function ChannelMenuButton({
   activeWorking,
   isMuted,
   dmParticipants,
+  dmInMeeting,
   presenceStatus,
   onSelectChannel,
 }: {
@@ -245,6 +247,7 @@ export function ChannelMenuButton({
   activeWorking?: ActiveChannelTurnSummary;
   isMuted?: boolean;
   dmParticipants?: SidebarDmParticipant[];
+  dmInMeeting?: boolean;
   presenceStatus?: PresenceStatus;
   onSelectChannel: (channelId: string) => void;
 }) {
@@ -275,6 +278,19 @@ export function ChannelMenuButton({
         presenceStatus={presenceStatus}
       />
       <span className="min-w-0 flex-1 truncate">{resolvedLabel}</span>
+      {dmInMeeting ? (
+        <CalendarDays
+          aria-label="In meeting"
+          className={cn(
+            "h-3.5 w-3.5 shrink-0",
+            isActive
+              ? "text-sidebar-active-foreground/70"
+              : "text-sidebar-foreground/45",
+          )}
+          data-testid={`channel-meeting-status-${channel.name}`}
+          role="img"
+        />
+      ) : null}
       {ephemeralDisplay ? (
         <EphemeralChannelBadge
           display={ephemeralDisplay}
@@ -318,6 +334,7 @@ export function SidebarSection({
   action,
   activeWorkingByChannelId,
   dmParticipantsByChannelId,
+  dmInMeetingByChannelId,
   emptyState,
   items,
   channelLabels,
@@ -341,6 +358,7 @@ export function SidebarSection({
   action?: React.ReactNode;
   activeWorkingByChannelId?: ReadonlyMap<string, ActiveChannelTurnSummary>;
   dmParticipantsByChannelId?: Record<string, SidebarDmParticipant[]>;
+  dmInMeetingByChannelId?: Record<string, boolean>;
   emptyState?: React.ReactNode;
   items: Channel[];
   channelLabels?: Record<string, string>;
@@ -413,6 +431,7 @@ export function SidebarSection({
                       channel={channel}
                       activeWorking={activeWorkingByChannelId?.get(channel.id)}
                       dmParticipants={dmParticipantsByChannelId?.[channel.id]}
+                      dmInMeeting={dmInMeetingByChannelId?.[channel.id]}
                       hasUnread={unreadChannelIds.has(channel.id)}
                       unreadCount={unreadChannelCounts.get(channel.id) ?? 0}
                       isMuted={mutedChannelIds?.has(channel.id)}
diff --git a/desktop/src/features/sidebar/useDmSidebarMetadata.ts b/desktop/src/features/sidebar/useDmSidebarMetadata.ts
index 52f613f7d..1da427ff1 100644
--- a/desktop/src/features/sidebar/useDmSidebarMetadata.ts
+++ b/desktop/src/features/sidebar/useDmSidebarMetadata.ts
@@ -4,9 +4,14 @@ import { usePresenceQuery } from "@/features/presence/hooks";
 import { resolveUserLabel } from "@/features/profile/lib/identity";
 import { useUsersBatchQuery } from "@/features/profile/hooks";
 import { resolveChannelDisplayLabel } from "@/features/sidebar/lib/channelLabels";
+import { useUserStatusQuery } from "@/features/user-status/hooks";
 import type { SidebarDmParticipant } from "@/features/sidebar/ui/SidebarSection";
 import type { Channel, PresenceStatus } from "@/shared/api/types";
 
+function isMeetingStatus(status: string | null | undefined): boolean {
+  return /\bmeeting\b/i.test(status?.trim() ?? "");
+}
+
 export function useDmSidebarMetadata({
   currentPubkey,
   directMessages,
@@ -51,8 +56,11 @@ export function useDmSidebarMetadata({
   const dmProfilesQuery = useUsersBatchQuery(dmParticipantPubkeys, {
     enabled: enabled && directMessages.length > 0,
   });
+  const dmUserStatusQuery = useUserStatusQuery(
+    enabled ? dmParticipantPubkeys : [],
+  );
   const dmProfiles = dmProfilesQuery.data?.profiles;
-  const dmPresenceByChannelId = React.useMemo(
+  const otherParticipantByChannelId = React.useMemo(
     () =>
       Object.fromEntries(
         directMessages.map((channel) => {
@@ -69,16 +77,41 @@ export function useDmSidebarMetadata({
             },
           );
 
+          return [channel.id, otherParticipantPubkey?.toLowerCase() ?? null];
+        }),
+      ) satisfies Record<string, string | null>,
+    [currentPubkey, directMessages, selfDmLabels],
+  );
+  const dmPresenceByChannelId = React.useMemo(
+    () =>
+      Object.fromEntries(
+        directMessages.map((channel) => {
+          const otherParticipantPubkey =
+            otherParticipantByChannelId[channel.id];
+
           return [
             channel.id,
             otherParticipantPubkey
-              ? (dmPresenceQuery.data?.[otherParticipantPubkey.toLowerCase()] ??
-                "offline")
+              ? (dmPresenceQuery.data?.[otherParticipantPubkey] ?? "offline")
               : "offline",
           ];
         }),
       ) satisfies Record<string, PresenceStatus>,
-    [currentPubkey, directMessages, dmPresenceQuery.data, selfDmLabels],
+    [directMessages, dmPresenceQuery.data, otherParticipantByChannelId],
+  );
+  const dmInMeetingByChannelId = React.useMemo(
+    () =>
+      Object.fromEntries(
+        directMessages.map((channel) => {
+          const otherParticipantPubkey =
+            otherParticipantByChannelId[channel.id];
+          const status = otherParticipantPubkey
+            ? dmUserStatusQuery.data?.[otherParticipantPubkey]
+            : null;
+          return [channel.id, isMeetingStatus(status?.text)];
+        }),
+      ) satisfies Record<string, boolean>,
+    [directMessages, dmUserStatusQuery.data, otherParticipantByChannelId],
   );
   const dmChannelLabels = React.useMemo(
     () =>
@@ -140,6 +173,7 @@ export function useDmSidebarMetadata({
 
   return {
     dmChannelLabels,
+    dmInMeetingByChannelId,
     dmParticipantsByChannelId,
     dmPresenceByChannelId,
   };
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index eaaf6eaa4..c40ace2c1 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -3440,6 +3440,15 @@ function handleGetLikedNotes(): RawUserNotesResponse {
   return { notes: [], next_cursor: null };
 }
 
+function mockGoogleCalendarStatus() {
+  return {
+    configured: false,
+    connected: false,
+    connected_at: null,
+    scopes: [],
+  };
+}
+
 // A random 64-hex event id, matching the shape of real Nostr event ids
 // (sha256 → 64 hex). Most mock events use the 32-hex `createMockEvent` default,
 // but kind:7 reactions need a real 64-hex id: the timeline's deletion path only
@@ -7490,6 +7499,14 @@ export function maybeInstallE2eTauriMocks() {
         );
       case "get_media_proxy_port":
         return MOCK_MEDIA_PROXY_PORT;
+      case "get_google_calendar_status":
+        return mockGoogleCalendarStatus();
+      case "connect_google_calendar":
+        return mockGoogleCalendarStatus();
+      case "disconnect_google_calendar":
+        return mockGoogleCalendarStatus();
+      case "get_google_calendar_events":
+        return [];
       case "pick_and_upload_media":
         return await resolveMockUploadDescriptors(activeConfig);
       case "upload_media_bytes":