@fayz-ai/plugin-agenda 0.8.0 → 0.8.3

package/src/integrations/google-calendar/components/useAgendaLookups.ts

@@ -0,0 +1,100 @@
+// Host-plugin lookups for the smart-sync de-para target picker.
+//
+// A channel can target one professional (assignee), one service, or one location
+// instead of the whole agenda. To offer real pickers (not raw uuid inputs) the
+// connector reuses plugin-agenda's own data providers — it lives inside the same
+// package, so these are in-process reads under the same RLS:
+//   • professionals + locations  → createSupabaseAgendaProvider()
+//   • services                    → createSupabasePublicBookingProvider() (v_public_services)
+// Everything is loaded once, lazily, and degrades to an empty list (the row then
+// falls back to a plain uuid input) if a lookup is unavailable for the tenant.
+import { useEffect, useState } from 'react'
+import { getActiveTenantId } from '@fayz-ai/core'
+import { createSupabaseAgendaProvider } from '../../../data'
+import { createSupabasePublicBookingProvider } from '../../../public/data.supabase'
+import type { ChannelTargetKind } from '../types'
+
+/** A pickable target option (assignee/service/location) — id + display name. */
+export interface LookupOption {
+  id: string
+  name: string
+}
+
+export interface AgendaLookups {
+  assignee: LookupOption[]
+  service: LookupOption[]
+  location: LookupOption[]
+}
+
+const EMPTY: AgendaLookups = { assignee: [], service: [], location: [] }
+
+export interface UseAgendaLookupsResult {
+  lookups: AgendaLookups
+  loading: boolean
+  /** True when at least one of the three lookups returned rows. */
+  hasAny: boolean
+}
+
+/**
+ * Load professionals / services / locations for the target picker. Failures are
+ * swallowed per-lookup (each falls back to an empty list) so a missing table or
+ * a vertical without services never breaks the whole de-para screen.
+ */
+export function useAgendaLookups(enabled: boolean): UseAgendaLookupsResult {
+  const [lookups, setLookups] = useState<AgendaLookups>(EMPTY)
+  const [loading, setLoading] = useState(false)
+
+  useEffect(() => {
+    if (!enabled) return
+    let cancelled = false
+    setLoading(true)
+    void (async () => {
+      const agenda = createSupabaseAgendaProvider()
+      const tenantId = getActiveTenantId()
+      const publicProvider = tenantId
+        ? createSupabasePublicBookingProvider({ tenantId })
+        : null
+
+      const [assignee, location, service] = await Promise.all([
+        agenda.getProfessionals().then(
+          (rows) => rows.map((p) => ({ id: p.id, name: p.name })),
+          () => [] as LookupOption[],
+        ),
+        (agenda.getLocations?.() ?? Promise.resolve([])).then(
+          (rows) => rows.map((l) => ({ id: l.id, name: l.name })),
+          () => [] as LookupOption[],
+        ),
+        (publicProvider?.getServices() ?? Promise.resolve([])).then(
+          (rows) => rows.map((s) => ({ id: s.id, name: s.name })),
+          () => [] as LookupOption[],
+        ),
+      ])
+
+      if (cancelled) return
+      setLookups({ assignee, service, location })
+      setLoading(false)
+    })()
+
+    return () => {
+      cancelled = true
+    }
+  }, [enabled])
+
+  const hasAny =
+    lookups.assignee.length > 0 ||
+    lookups.service.length > 0 ||
+    lookups.location.length > 0
+
+  return { lookups, loading, hasAny }
+}
+
+/** Options available for a given target kind (empty for whole-agenda / null). */
+export function optionsForKind(
+  lookups: AgendaLookups,
+  kind: ChannelTargetKind,
+): LookupOption[] {
+  if (kind === 'assignee') return lookups.assignee
+  if (kind === 'service') return lookups.service
+  if (kind === 'location') return lookups.location
+  return []
+}

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

@@ -5,74 +5,157 @@
 // 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 } from 'lucide-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 { CalendarSyncLogEntry } from './types'
+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 [calendarId, setCalendarId] = useState('primary')
+  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) { setCalendarId(integ.calendarId); void provider.getSyncLog().then(setLog) }
+    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.
-  if (!loaded || !connected) return null
-
-  async function handleSaveCalendar() {
-    await provider.setCalendar(calendarId)
-    toast.success('Saved')
+  // 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) }
-    catch (e: any) { toast.error(e?.message ?? 'Sync failed') }
+    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) }
   }
 
-  return (
-    <div className="space-y-4 border-t pt-4">
-      <div className="flex flex-wrap items-end gap-3">
-        <label className="block flex-1 min-w-[200px]">
-          <span className="text-xs font-medium text-muted-foreground">Calendar ID</span>
-          <input value={calendarId} onChange={(e) => setCalendarId(e.target.value)} placeholder="primary"
-            className="w-full mt-1 rounded-input border border-input bg-card px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-ring" />
-        </label>
-        <Button variant="outline" size="sm" onClick={handleSaveCalendar}>Save</Button>
-        <Button variant="outline" size="sm" onClick={handleSyncNow} disabled={syncing}>
-          <RefreshCw className={`h-3.5 w-3.5 ${syncing ? 'animate-spin' : ''}`} /> Sync now
-        </Button>
-      </div>
+  const canImport = inboundChannels(channels).length > 0
 
-      {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>
+  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>
   )
 }

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

@@ -1,10 +1,21 @@
 // Google Calendar integration (control plane) — Supabase client.
 //
-// Thin client: reads/writes the calendar_integrations row and invokes the
-// google-calendar-sync edge function for OAuth connect + manual sync. The
-// function holds the OAuth client secret and does the Calendar API work.
-import { getSupabaseClientOptional } from '@fayz-ai/core'
-import type { CalendarIntegration, CalendarSyncLogEntry } from '../types'
+// 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'
 
@@ -14,6 +25,20 @@ function sb() {
   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. */
@@ -21,14 +46,27 @@ export interface GoogleCalendarProvider {
   setCalendar(calendarId: string): Promise<void>
   disconnect(): Promise<void>
   /** Manually pull external changes now (inbound). */
-  syncNow(): Promise<{ fetched: number; written: number }>
+  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('calendar_integrations').select('*').eq('provider', 'google').limit(1).maybeSingle()
+      const { data } = await sb().from(GCAL_TABLES.integrations).select('*').eq('provider', 'google').limit(1).maybeSingle()
       if (!data) return null
       return {
         id: data.id,
@@ -42,33 +80,91 @@ export function createGoogleCalendarProvider(): GoogleCalendarProvider {
 
     async getConnectUrl(redirectTo) {
       const { data, error } = await sb().functions.invoke(FUNCTION, {
-        body: { action: 'oauth_start', redirectTo: redirectTo ?? window.location.href },
+        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('calendar_integrations').update({ calendar_id: calendarId, updated_at: new Date().toISOString() }).eq('provider', 'google')
+      await sb().from(GCAL_TABLES.integrations).update({ calendar_id: calendarId, updated_at: new Date().toISOString() }).eq('provider', 'google')
     },
 
     async disconnect() {
-      await sb().from('calendar_integrations').update({ active: false, oauth_refresh_token: null, oauth_access_token: null }).eq('provider', 'google')
+      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', trigger: 'manual' } })
+      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 }
+      return data as { fetched: number; written: number; discovered?: number }
     },
 
     async getSyncLog() {
-      const { data } = await sb().from('calendar_sync_log').select('*').order('created_at', { ascending: false }).limit(20)
+      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

@@ -0,0 +1,12 @@
+// 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

@@ -14,7 +14,16 @@ import { googleCalendarConnectorDef } from './connectorDef'
 export { createGoogleCalendarProvider } from './data/supabase'
 export { googleCalendarConnector } from './connector'
 export { googleCalendarConnectorDef } from './connectorDef'
-export { bookingToEvent, eventToBookingPatch, bookingSummary } from './mapping'
+export {
+  bookingToEvent,
+  eventToBookingPatch,
+  bookingSummary,
+  appointmentRowToEvent,
+  eventToAppointmentPatch,
+  eventTimes,
+  resolveTargetChannel,
+  channelRowToChannel,
+} from './mapping'
 export * from './types'
 
 // Addon plugin: contributes the Google Calendar connector into its host

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

@@ -8,8 +8,18 @@
 import { describe, it, expect } from 'vitest'
 import { assertConnectorContract } from '@fayz-ai/core/testing'
 import { googleCalendarConnector } from './connector'
-import { bookingToEvent, eventToBookingPatch, bookingSummary } from './mapping'
+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 {
@@ -61,6 +71,121 @@ describe('google-calendar · booking↔event mapping (pure, TDD)', () => {
     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