@fayz-ai/plugin-agenda 0.9.0 → 0.9.1

package/src/integrations/google-calendar/connectorDef.tsx

@@ -1,185 +0,0 @@
-// Google Calendar as a unified ConnectorDefinition.
-//
-// Surfaces inside plugin-agenda's settings → Integrations tab (the host),
-// rendered by the shared ConnectorsHub. The hub handles the OAuth connect/
-// disconnect; the ExtraPanel below adds the calendar picker, manual sync and
-// run history (only meaningful once connected).
-import React, { useEffect, useState } from 'react'
-import { RefreshCw, History, CheckCircle2, AlertCircle, Loader2, CalendarCog, CalendarPlus } from 'lucide-react'
-import { Button, toast } from '@fayz-ai/ui'
-import type { ConnectorDefinition } from '@fayz-ai/core'
-import { createGoogleCalendarProvider } from './data/supabase'
-import type { CalendarChannel, CalendarSyncLogEntry } from './types'
-import { ChannelMappingList } from './components/ChannelMappingList'
-import { ImportEventsWizard } from './components/ImportEventsWizard'
-
-const provider = createGoogleCalendarProvider()
-
-/** Channels Google is allowed to write INTO the agenda from (gate the import wizard). */
-function inboundChannels(channels: CalendarChannel[]): CalendarChannel[] {
-  return channels.filter(
-    (c) => c.isActive && (c.direction === 'inbound' || c.direction === 'bidirectional'),
-  )
-}
-
-function GoogleCalendarExtraPanel() {
-  const [connected, setConnected] = useState(false)
-  const [lastSyncAt, setLastSyncAt] = useState<string | undefined>()
-  const [syncing, setSyncing] = useState(false)
-  const [log, setLog] = useState<CalendarSyncLogEntry[]>([])
-  const [loaded, setLoaded] = useState(false)
-  const [channels, setChannels] = useState<CalendarChannel[]>([])
-  // Progressive disclosure: once connected the de-para is opened either on the
-  // "Configure calendars" CTA or automatically when channels already exist.
-  const [showMapping, setShowMapping] = useState(false)
-  const [showWizard, setShowWizard] = useState(false)
-
-  async function load() {
-    const integ = await provider.getIntegration()
-    setConnected(!!integ?.connected)
-    if (integ) {
-      setLastSyncAt(integ.lastSyncAt)
-      void provider.getSyncLog().then(setLog)
-      void provider.listChannels().then((ch) => {
-        setChannels(ch)
-        if (ch.length > 0) setShowMapping(true)
-      })
-    }
-    setLoaded(true)
-  }
-  useEffect(() => { void load() }, [])
-
-  // Before connecting there's nothing to configure here — a short hint only.
-  if (!loaded) return null
-  if (!connected) {
-    return (
-      <p className="text-xs text-muted-foreground border-t pt-4">
-        Connect a Google account above to map your calendars and import events.
-      </p>
-    )
-  }
-
-  async function handleSyncNow() {
-    setSyncing(true)
-    try {
-      const r = await provider.syncNow()
-      toast.success(`Synced — ${r.written} updated`)
-      void provider.getSyncLog().then(setLog)
-      void provider.getIntegration().then((i) => setLastSyncAt(i?.lastSyncAt))
-    } catch (e: any) { toast.error(e?.message ?? 'Sync failed') }
-    finally { setSyncing(false) }
-  }
-
-  const canImport = inboundChannels(channels).length > 0
-
-  return (
-    <div className="space-y-5 border-t pt-4">
-      {/* 1 — De-para (mapping). CTA first when nothing is configured yet. */}
-      <section className="space-y-2">
-        <div className="flex items-center gap-2">
-          <CalendarCog className="h-4 w-4 text-muted-foreground" />
-          <h4 className="text-sm font-semibold">Calendars</h4>
-        </div>
-        {showMapping ? (
-          <ChannelMappingList provider={provider} onChannelsChange={setChannels} />
-        ) : (
-          <div className="rounded-md border border-dashed px-4 py-5 text-center space-y-2">
-            <p className="text-sm text-muted-foreground">
-              Map each Google calendar to what it syncs — a professional, service, location, or your
-              whole agenda.
-            </p>
-            <Button variant="outline" size="sm" onClick={() => setShowMapping(true)}>
-              <CalendarCog className="h-3.5 w-3.5" /> Configure calendars
-            </Button>
-          </div>
-        )}
-      </section>
-
-      {/* 2 — Import future events (only meaningful once an inbound channel exists). */}
-      {showMapping && (
-        <section className="space-y-2">
-          {showWizard ? (
-            <ImportEventsWizard
-              provider={provider}
-              channels={inboundChannels(channels)}
-              onClose={() => setShowWizard(false)}
-              onImported={() => {
-                void provider.getSyncLog().then(setLog)
-                void provider.getIntegration().then((i) => setLastSyncAt(i?.lastSyncAt))
-              }}
-            />
-          ) : (
-            <Button
-              variant="outline"
-              size="sm"
-              disabled={!canImport}
-              title={canImport ? undefined : 'Enable an importing calendar first'}
-              onClick={() => setShowWizard(true)}
-            >
-              <CalendarPlus className="h-3.5 w-3.5" /> Import future events
-            </Button>
-          )}
-        </section>
-      )}
-
-      {/* 3 — Status: last sync + manual pull + run history. */}
-      <section className="space-y-2">
-        <div className="flex flex-wrap items-center gap-3">
-          <Button variant="outline" size="sm" onClick={handleSyncNow} disabled={syncing}>
-            <RefreshCw className={`h-3.5 w-3.5 ${syncing ? 'animate-spin' : ''}`} /> Sync now
-          </Button>
-          {lastSyncAt && (
-            <span className="text-[11px] text-muted-foreground">
-              Last sync: {new Date(lastSyncAt).toLocaleString()}
-            </span>
-          )}
-        </div>
-
-        {log.length > 0 && (
-          <div className="space-y-2">
-            <div className="flex items-center gap-2">
-              <History className="h-4 w-4 text-muted-foreground" />
-              <h4 className="text-sm font-semibold">History</h4>
-            </div>
-            <div className="rounded-md border divide-y text-sm">
-              {log.map((r) => (
-                <div key={r.id} className="flex items-center gap-3 px-3 py-2">
-                  <span className="text-muted-foreground text-xs">{new Date(r.createdAt).toLocaleString()}</span>
-                  <span className="text-[10px] uppercase tracking-wide px-1 py-px rounded bg-muted text-muted-foreground">{r.direction}</span>
-                  <span className="ml-auto text-xs">{r.written} written / {r.fetched} fetched</span>
-                  {r.status === 'success'
-                    ? <CheckCircle2 className="h-3.5 w-3.5 text-success" />
-                    : <AlertCircle className="h-3.5 w-3.5 text-warning" />}
-                </div>
-              ))}
-            </div>
-          </div>
-        )}
-      </section>
-    </div>
-  )
-}
-
-export const googleCalendarConnectorDef: ConnectorDefinition = {
-  id: 'google-calendar',
-  hostPluginId: 'agenda',
-  name: 'Google Calendar',
-  description: 'Two-way sync between your bookings and Google Calendar.',
-  icon: 'Calendar',
-  authKind: 'oauth',
-  category: 'scheduling',
-  direction: 'outbound',
-  // Sync only, and deliberately: the agenda has to exist inside the app — to be
-  // listed, filtered, reported on, and read when Google is unreachable. An
-  // agentic plane would answer questions but leave the calendar screen empty.
-  planes: ['sync'],
-  entities: ['booking'],
-  docsUrl: 'https://support.google.com/calendar',
-  async getStatus() {
-    const integ = await provider.getIntegration()
-    return { connected: !!integ?.connected }
-  },
-  startOAuth: (redirectTo) => provider.getConnectUrl(redirectTo),
-  disconnect: () => provider.disconnect(),
-  ExtraPanel: GoogleCalendarExtraPanel,
-}

package/src/integrations/google-calendar/data/supabase.ts

@@ -1,170 +0,0 @@
-// Google Calendar integration (control plane) — Supabase client.
-//
-// Thin client. Split of responsibilities:
-//   • anything that needs the OAuth client secret or a Google API call goes
-//     through the google-calendar-sync edge function (invoke);
-//   • plain tenant-scoped reads/writes (integration row, channels, log) hit the
-//     tables directly under RLS.
-import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
-import { channelRowToChannel } from '../mapping'
-import { GCAL_TABLES } from './tables'
-import type {
-  CalendarIntegration,
-  CalendarSyncLogEntry,
-  CalendarChannel,
-  ExternalEventPreview,
-  GoogleCalendarListEntry,
-  ImportEventsResult,
-} from '../types'
-
-const FUNCTION = 'google-calendar-sync'
-
-function sb() {
-  const supabase = getSupabaseClientOptional() as any
-  if (!supabase) throw new Error('Supabase not initialized')
-  return supabase
-}
-
-/** Snake_case patch for plg_calendar_channels writes (RLS-scoped). */
-export interface CalendarChannelInput {
-  id?: string
-  integrationId?: string
-  googleCalendarId: string
-  summary?: string | null
-  color?: string | null
-  direction?: CalendarChannel['direction']
-  targetKind?: CalendarChannel['targetKind']
-  targetId?: string | null
-  importMode?: CalendarChannel['importMode']
-  isActive?: boolean
-}
-
-export interface GoogleCalendarProvider {
-  getIntegration(): Promise<CalendarIntegration | null>
-  /** Start the OAuth connect flow — returns the Google consent URL to redirect to. */
-  getConnectUrl(redirectTo?: string): Promise<string>
-  setCalendar(calendarId: string): Promise<void>
-  disconnect(): Promise<void>
-  /** Manually pull external changes now (inbound). */
-  syncNow(): Promise<{ fetched: number; written: number; discovered?: number }>
-  getSyncLog(): Promise<CalendarSyncLogEntry[]>
-  // --- smart sync: multi-calendar channels + import wizard ---
-  /** List the user's Google calendars for the de-para picker (needs the API → function). */
-  listGoogleCalendars(): Promise<GoogleCalendarListEntry[]>
-  /** Read this tenant's channels (RLS). */
-  listChannels(): Promise<CalendarChannel[]>
-  /** Create/update a channel (RLS upsert on integration_id + google_calendar_id). */
-  saveChannel(input: CalendarChannelInput): Promise<void>
-  /** Delete a channel by id (RLS). */
-  deleteChannel(id: string): Promise<void>
-  /** Preview future events not yet linked to an appointment (import wizard). */
-  listExternalEvents(params?: { channelId?: string; timeMin?: string }): Promise<ExternalEventPreview[]>
-  /** Import selected external events as appointments. */
-  importEvents(items: { channelId: string; eventId: string }[]): Promise<ImportEventsResult>
-}
-
-export function createGoogleCalendarProvider(): GoogleCalendarProvider {
-  return {
-    async getIntegration() {
-      const { data } = await sb().from(GCAL_TABLES.integrations).select('*').eq('provider', 'google').limit(1).maybeSingle()
-      if (!data) return null
-      return {
-        id: data.id,
-        provider: data.provider,
-        calendarId: data.calendar_id ?? 'primary',
-        active: data.active ?? true,
-        connected: !!data.oauth_refresh_token,
-        lastSyncAt: data.last_sync_at ?? undefined,
-      }
-    },
-
-    async getConnectUrl(redirectTo) {
-      const { data, error } = await sb().functions.invoke(FUNCTION, {
-        body: { action: 'oauth_start', tenantId: getActiveTenantId(), redirectTo: redirectTo ?? window.location.href },
-      })
-      if (error) throw new Error(error.message)
-      return (data as { url: string }).url
-    },
-
-    async setCalendar(calendarId) {
-      await sb().from(GCAL_TABLES.integrations).update({ calendar_id: calendarId, updated_at: new Date().toISOString() }).eq('provider', 'google')
-    },
-
-    async disconnect() {
-      await sb().from(GCAL_TABLES.integrations).update({ active: false, oauth_refresh_token: null, oauth_access_token: null }).eq('provider', 'google')
-    },
-
-    async syncNow() {
-      const { data, error } = await sb().functions.invoke(FUNCTION, { body: { action: 'pull_events', tenantId: getActiveTenantId(), trigger: 'manual' } })
-      if (error) throw new Error(error.message)
-      return data as { fetched: number; written: number; discovered?: number }
-    },
-
-    async getSyncLog() {
-      const { data } = await sb().from(GCAL_TABLES.syncLog).select('*').order('created_at', { ascending: false }).limit(20)
-      return (data ?? []).map((r: any) => ({
-        id: r.id, direction: r.direction, trigger: r.trigger ?? undefined,
-        status: r.status, fetched: r.fetched ?? 0, written: r.written ?? 0,
-        error: r.error ?? undefined, createdAt: r.created_at,
-      }))
-    },
-
-    async listGoogleCalendars() {
-      const { data, error } = await sb().functions.invoke(FUNCTION, { body: { action: 'list_calendars', tenantId: getActiveTenantId() } })
-      if (error) throw new Error(error.message)
-      return (data as { calendars: GoogleCalendarListEntry[] }).calendars ?? []
-    },
-
-    async listChannels() {
-      const { data } = await sb().from(GCAL_TABLES.channels).select('*').order('created_at', { ascending: true })
-      return (data ?? []).map(channelRowToChannel)
-    },
-
-    async saveChannel(input) {
-      const tenantId = getActiveTenantId()
-      // Resolve the integration id when the caller didn't pass one.
-      let integrationId = input.integrationId
-      if (!integrationId) {
-        const { data } = await sb().from(GCAL_TABLES.integrations).select('id').eq('provider', 'google').limit(1).maybeSingle()
-        integrationId = data?.id
-      }
-      const row: Record<string, unknown> = {
-        integration_id: integrationId,
-        tenant_id: tenantId,
-        google_calendar_id: input.googleCalendarId,
-        updated_at: new Date().toISOString(),
-      }
-      if (input.id !== undefined) row.id = input.id
-      if (input.summary !== undefined) row.summary = input.summary
-      if (input.color !== undefined) row.color = input.color
-      if (input.direction !== undefined) row.direction = input.direction
-      if (input.targetKind !== undefined) row.target_kind = input.targetKind
-      if (input.targetId !== undefined) row.target_id = input.targetId
-      if (input.importMode !== undefined) row.import_mode = input.importMode
-      if (input.isActive !== undefined) row.is_active = input.isActive
-      const { error } = await sb().from(GCAL_TABLES.channels).upsert(row, { onConflict: 'integration_id,google_calendar_id' })
-      if (error) throw new Error(error.message)
-    },
-
-    async deleteChannel(id) {
-      const { error } = await sb().from(GCAL_TABLES.channels).delete().eq('id', id)
-      if (error) throw new Error(error.message)
-    },
-
-    async listExternalEvents(params) {
-      const { data, error } = await sb().functions.invoke(FUNCTION, {
-        body: { action: 'list_external_events', tenantId: getActiveTenantId(), channelId: params?.channelId, timeMin: params?.timeMin },
-      })
-      if (error) throw new Error(error.message)
-      return (data as { events: ExternalEventPreview[] }).events ?? []
-    },
-
-    async importEvents(items) {
-      const { data, error } = await sb().functions.invoke(FUNCTION, {
-        body: { action: 'import_events', tenantId: getActiveTenantId(), items },
-      })
-      if (error) throw new Error(error.message)
-      return data as ImportEventsResult
-    },
-  }
-}

package/src/integrations/google-calendar/data/tables.ts

@@ -1,12 +0,0 @@
-// Canonical DB object names for the Google Calendar connector.
-//
-// Plugin-owned tables carry the platform `plg_<plugin>_` prefix (DATA-MODEL.md
-// Ring 1). Single source of truth so the connector data layer (supabase.ts) and
-// the google-calendar-sync edge function never drift on a table name. The SQL
-// side is owned by ./migrations/001_google_calendar.sql + 002_smart_sync.sql
-// (fresh installs) and 003_plg_rename.sql (legacy-pool rename).
-export const GCAL_TABLES = {
-  integrations: 'plg_calendar_integrations',
-  channels: 'plg_calendar_channels',
-  syncLog: 'plg_calendar_sync_log',
-} as const

package/src/integrations/google-calendar/index.ts

@@ -1,45 +0,0 @@
-// Google Calendar integration — official (in-SDK) addon for plugin-agenda.
-//
-// Settings-only PluginManifest: contributes a "Google Calendar" tab to /settings
-// for connecting an account and running a manual sync. Outbound (booking →
-// Google) is automatic via a DB trigger; inbound (Google → booking) via pg_cron
-// or a Google watch webhook. The data plane is the google-calendar-sync edge
-// function (see ./functions/google-calendar-sync). The booking↔event link lives
-// on public.appointments.metadata.googleCalendarEventId.
-//
-// Graduation path: extract to its own `@fayz-ai/plugin-google-calendar` package.
-import type { PluginManifest } from '@fayz-ai/core'
-import { googleCalendarConnectorDef } from './connectorDef'
-
-export { createGoogleCalendarProvider } from './data/supabase'
-export { googleCalendarConnector } from './connector'
-export { googleCalendarConnectorDef } from './connectorDef'
-export {
-  bookingToEvent,
-  eventToBookingPatch,
-  bookingSummary,
-  appointmentRowToEvent,
-  eventToAppointmentPatch,
-  eventTimes,
-  resolveTargetChannel,
-  channelRowToChannel,
-} from './mapping'
-export * from './types'
-
-// Addon plugin: contributes the Google Calendar connector into its host
-// (plugin-agenda). It appears in Agenda settings → Integrations — no top-level
-// settings tab of its own. See packages/saas ConnectorsHub.
-export function createGoogleCalendarPlugin(): PluginManifest {
-  return {
-    id: 'google-calendar',
-    name: 'Google Calendar',
-    icon: 'Calendar',
-    version: '0.1.0',
-    scope: 'addon',
-    defaultEnabled: true,
-    dependencies: ['agenda'],
-    navigation: [],
-    routes: [],
-    connectors: [googleCalendarConnectorDef],
-  }
-}

package/src/integrations/google-calendar/integration.test.ts

@@ -1,199 +0,0 @@
-// Integration contract + capability test for the Google Calendar connector.
-//
-// TDD anchor: the connector contract, manifest integrity, and the pure
-// booking↔event mapping are all proven HERE — before/without the deployed edge
-// function. The data-plane behaviors that need a live Google account are written
-// as it.todo specs so the intended contract is documented and pending, not
-// silently missing. See docs/PLUGIN-PATTERNS.md → integration capability.
-import { describe, it, expect } from 'vitest'
-import { assertConnectorContract } from '@fayz-ai/core/testing'
-import { googleCalendarConnector } from './connector'
-import {
-  bookingToEvent,
-  eventToBookingPatch,
-  bookingSummary,
-  appointmentRowToEvent,
-  eventToAppointmentPatch,
-  eventTimes,
-  resolveTargetChannel,
-  channelRowToChannel,
-} from './mapping'
-import type { CalendarBooking } from '../../types'
-import type { AppointmentRow, CalendarChannel } from './types'
-
-function booking(overrides: Partial<CalendarBooking> = {}): CalendarBooking {
-  return {
-    id: 'b1', tenantId: 't1', kind: 'appointment',
-    startsAt: '2026-06-18T13:00:00-03:00', endsAt: '2026-06-18T14:00:00-03:00',
-    status: 'scheduled', notes: null, orderId: 'b1', locationId: null, metadata: {},
-    clientId: null, clientName: 'Sarah', clientPhone: null, clientEmail: 'sarah@x.com', clientAvatarUrl: null,
-    professionalId: null, professionalName: 'Ana', professionalAvatarUrl: null,
-    locationName: 'HQ', orderTotal: null, orderStatus: null,
-    services: [{ id: 's1', serviceId: 'svc1', name: 'Haircut', durationMinutes: 60, price: 100, assigneeId: null }] as any,
-    totalDurationMinutes: 60, createdAt: '', updatedAt: '',
-    ...overrides,
-  }
-}
-
-describe('google-calendar · connector contract (integrity)', () => {
-  it('declares a valid connector descriptor', () => {
-    expect(() => assertConnectorContract(googleCalendarConnector)).not.toThrow()
-    expect(googleCalendarConnector.capabilities[0].direction).toBe('bidirectional')
-  })
-})
-
-describe('google-calendar · booking↔event mapping (pure, TDD)', () => {
-  it('builds an event title from services + client', () => {
-    expect(bookingSummary(booking())).toBe('Haircut — Sarah')
-  })
-
-  it('maps a booking to a Google event input with start/end', () => {
-    const ev = bookingToEvent(booking())
-    expect(ev).not.toBeNull()
-    expect(ev!.summary).toBe('Haircut — Sarah')
-    expect(ev!.start.dateTime).toBe('2026-06-18T13:00:00-03:00')
-    expect(ev!.end.dateTime).toBe('2026-06-18T14:00:00-03:00')
-  })
-
-  it('refuses to map a booking with no end time', () => {
-    expect(bookingToEvent(booking({ endsAt: null }))).toBeNull()
-  })
-
-  it('maps an inbound reschedule to a booking patch', () => {
-    const patch = eventToBookingPatch({
-      id: 'e1', start: { dateTime: '2026-06-18T15:00:00-03:00' }, end: { dateTime: '2026-06-18T16:00:00-03:00' },
-    })
-    expect(patch.startsAt).toBe('2026-06-18T15:00:00-03:00')
-    expect(patch.endsAt).toBe('2026-06-18T16:00:00-03:00')
-  })
-
-  it('maps an inbound cancellation to a cancelled status', () => {
-    const patch = eventToBookingPatch({ id: 'e1', status: 'cancelled', start: {}, end: {} })
-    expect(patch.status).toBe('cancelled')
-  })
-
-  it('reads an all-day event window (date, no dateTime)', () => {
-    const t = eventTimes({ id: 'e1', start: { date: '2026-06-18' }, end: { date: '2026-06-19' } })
-    expect(t.allDay).toBe(true)
-    expect(t.startsAt).toBe('2026-06-18')
-    expect(t.endsAt).toBe('2026-06-19')
-  })
-
-  it('reads a timed event window as not all-day', () => {
-    const t = eventTimes({ id: 'e1', start: { dateTime: '2026-06-18T13:00:00-03:00' }, end: { dateTime: '2026-06-18T14:00:00-03:00' } })
-    expect(t.allDay).toBe(false)
-    expect(t.startsAt).toBe('2026-06-18T13:00:00-03:00')
-  })
-})
-
-describe('google-calendar · appointment-row mapping (edge-function shape)', () => {
-  function row(overrides: Partial<AppointmentRow> = {}): AppointmentRow {
-    return { id: 'a1', tenant_id: 't1', starts_at: '2026-06-18T13:00:00-03:00', ends_at: '2026-06-18T14:00:00-03:00', ...overrides }
-  }
-
-  it('maps a minimal row to a Google event input', () => {
-    const ev = appointmentRowToEvent(row())
-    expect(ev.summary).toBe('Appointment')
-    expect(ev.start.dateTime).toBe('2026-06-18T13:00:00-03:00')
-    expect(ev.end.dateTime).toBe('2026-06-18T14:00:00-03:00')
-  })
-
-  it('builds the title from metadata service + contact names', () => {
-    const ev = appointmentRowToEvent(row({ metadata: { serviceNames: 'Cleaning', contactName: 'Sarah' }, notes: 'bring x-rays' }))
-    expect(ev.summary).toBe('Cleaning — Sarah')
-    expect(ev.description).toBe('bring x-rays')
-  })
-
-  it('falls back end→start when the row has no end', () => {
-    const ev = appointmentRowToEvent(row({ ends_at: null }))
-    expect(ev.end.dateTime).toBe('2026-06-18T13:00:00-03:00')
-  })
-
-  it('maps an inbound reschedule to a snake_case appointment patch', () => {
-    const patch = eventToAppointmentPatch({
-      id: 'e1', summary: 'Moved',
-      start: { dateTime: '2026-06-18T15:00:00-03:00' }, end: { dateTime: '2026-06-18T16:00:00-03:00' },
-    })
-    expect(patch.cancelled).toBe(false)
-    expect(patch.starts_at).toBe('2026-06-18T15:00:00-03:00')
-    expect(patch.ends_at).toBe('2026-06-18T16:00:00-03:00')
-    expect(patch.summary).toBe('Moved')
-    expect(patch.allDay).toBe(false)
-  })
-
-  it('maps an inbound all-day event to an all-day patch', () => {
-    const patch = eventToAppointmentPatch({ id: 'e1', start: { date: '2026-06-18' }, end: { date: '2026-06-19' } })
-    expect(patch.allDay).toBe(true)
-    expect(patch.starts_at).toBe('2026-06-18')
-  })
-
-  it('maps an inbound cancellation to a cancelled patch', () => {
-    const patch = eventToAppointmentPatch({ id: 'e1', status: 'cancelled', start: {}, end: {} })
-    expect(patch.cancelled).toBe(true)
-    expect(patch.starts_at).toBeUndefined()
-  })
-})
-
-describe('google-calendar · channel resolution (outbound priority, pure)', () => {
-  function ch(overrides: Partial<CalendarChannel> = {}): CalendarChannel {
-    return {
-      id: 'c1', integrationId: 'i1', tenantId: 't1', googleCalendarId: 'cal@group',
-      summary: null, color: null, direction: 'bidirectional', targetKind: null, targetId: null,
-      importMode: 'appointment', syncToken: null, channelId: null, resourceId: null,
-      channelExpiresAt: null, isActive: true, createdAt: '', updatedAt: '',
-      ...overrides,
-    }
-  }
-
-  it('prefers an assignee-targeted channel over service/location/whole-agenda', () => {
-    const channels = [
-      ch({ id: 'whole', googleCalendarId: 'whole@g', targetKind: null }),
-      ch({ id: 'loc', googleCalendarId: 'loc@g', targetKind: 'location', targetId: 'L1' }),
-      ch({ id: 'svc', googleCalendarId: 'svc@g', targetKind: 'service', targetId: 'S1' }),
-      ch({ id: 'ana', googleCalendarId: 'ana@g', targetKind: 'assignee', targetId: 'A1' }),
-    ]
-    const match = resolveTargetChannel(channels, { assigneeId: 'A1', serviceIds: ['S1'], locationId: 'L1' })
-    expect(match?.id).toBe('ana')
-  })
-
-  it('falls through assignee → service → location → whole agenda', () => {
-    const svc = ch({ id: 'svc', targetKind: 'service', targetId: 'S9' })
-    const loc = ch({ id: 'loc', targetKind: 'location', targetId: 'L9' })
-    const whole = ch({ id: 'whole', targetKind: null })
-    expect(resolveTargetChannel([svc, loc, whole], { assigneeId: 'nope', serviceIds: ['S9'] })?.id).toBe('svc')
-    expect(resolveTargetChannel([loc, whole], { locationId: 'L9' })?.id).toBe('loc')
-    expect(resolveTargetChannel([whole], { assigneeId: 'x' })?.id).toBe('whole')
-  })
-
-  it('ignores inactive and non-outbound channels', () => {
-    const inbound = ch({ id: 'in', targetKind: 'assignee', targetId: 'A1', direction: 'inbound' })
-    const off = ch({ id: 'off', targetKind: 'assignee', targetId: 'A1', direction: 'off' })
-    const inactive = ch({ id: 'x', targetKind: null, isActive: false })
-    expect(resolveTargetChannel([inbound, off, inactive], { assigneeId: 'A1' })).toBeNull()
-  })
-
-  it('returns null when nothing matches', () => {
-    const svc = ch({ id: 'svc', targetKind: 'service', targetId: 'S1' })
-    expect(resolveTargetChannel([svc], { assigneeId: 'A1', serviceIds: ['other'] })).toBeNull()
-  })
-
-  it('channelRowToChannel maps snake_case rows with defaults', () => {
-    const mapped = channelRowToChannel({
-      id: 'c1', integration_id: 'i1', tenant_id: 't1', google_calendar_id: 'cal@g', direction: 'inbound',
-    })
-    expect(mapped.googleCalendarId).toBe('cal@g')
-    expect(mapped.importMode).toBe('appointment')
-    expect(mapped.isActive).toBe(true)
-    expect(mapped.targetKind).toBeNull()
-  })
-})
-
-// Data-plane behaviors — require a live Google account + the deployed
-// google-calendar-sync edge function. Documented as the pending contract (TDD).
-describe('google-calendar · sync data plane (pending — needs edge function)', () => {
-  it.todo('push_event: creating a booking creates a Google event and stores its id on bookings.metadata')
-  it.todo('push_event: updating a booking patches the linked Google event')
-  it.todo('push_event: cancelling a booking deletes the Google event')
-  it.todo('pull_events: a Google reschedule updates the linked booking; a cancel cancels it')
-  it.todo('pull_events: advances and persists the incremental syncToken')
-})