@fayz-ai/plugin-marketing 0.8.0 → 0.8.2

package/src/data/supabase.ts

@@ -0,0 +1,401 @@
+import { getSupabaseClientOptional, getActiveTenantId } from '@fayz-ai/core'
+import type {
+  AttributionBridge,
+  MarketingDataProvider,
+  SaveCampaignInput,
+  SitesPerformanceBridge,
+} from './types'
+import type {
+  AcquisitionChannel,
+  Campaign,
+  ChannelPerformance,
+  ConversionModel,
+  DateRangeKey,
+  FunnelStage,
+  LandingPagePerf,
+  MarketingOverview,
+  MarketingQuery,
+} from '../types'
+import { T, V } from './tables'
+
+// ---------------------------------------------------------------------------
+// Supabase marketing provider. Channels/campaigns are real CRUD rows
+// (plg_marketing_channels/_campaigns, lazily seeded from the app's channel
+// config); performance is derived from v_marketing_attribution — REAL
+// conversions (bookings/orders/won deals) and leads, attributed by matching
+// the event's origin string against the channel set. Reach has no generic
+// source yet, so it reads 0 until a sites/ads integration feeds it.
+// ---------------------------------------------------------------------------
+
+export interface SupabaseMarketingProviderOptions {
+  channels: AcquisitionChannel[]
+  conversion: ConversionModel
+  attributionBridge?: AttributionBridge
+  sitesBridge?: SitesPerformanceBridge
+}
+
+const RANGE_DAYS: Record<DateRangeKey, number> = { '7d': 7, '30d': 30, '90d': 90 }
+
+function getClient() {
+  const supabase = getSupabaseClientOptional() as any
+  if (!supabase) throw new Error('Supabase not initialized')
+  return supabase
+}
+
+function requireTenantId(): string {
+  const tenantId = getActiveTenantId()
+  if (!tenantId) throw new Error('No active tenant')
+  return tenantId
+}
+
+/** 'Walk-in' → 'walkin', 'paid-search' → 'paidsearch' — origin strings match
+ *  channel ids OR labels regardless of case/punctuation. */
+function normKey(value: string | null | undefined): string {
+  return (value ?? '').toLowerCase().replace(/[^a-z0-9]/g, '')
+}
+
+interface AttributionRow {
+  kind: 'lead' | 'conversion'
+  source: string
+  channel_raw: string | null
+  occurred_at: string
+  value: number | null
+}
+
+export function createSupabaseMarketingProvider(
+  options: SupabaseMarketingProviderOptions,
+): MarketingDataProvider {
+  const { channels, conversion, attributionBridge, sitesBridge } = options
+
+  const channelByNorm = new Map<string, string>()
+  for (const ch of channels) {
+    channelByNorm.set(normKey(ch.id), ch.id)
+    channelByNorm.set(normKey(ch.label), ch.id)
+  }
+  const resolveChannel = (raw: string | null): string | null =>
+    channelByNorm.get(normKey(raw)) ?? null
+
+  // Lazy per-tenant seed: the channel set comes from app config (SQL can't know
+  // the domain), so the first read upserts the preset rows. Idempotent via the
+  // (tenant_id, channel_key) unique index.
+  const seeded = new Set<string>()
+  async function ensureChannels(tenantId: string): Promise<void> {
+    if (seeded.has(tenantId)) return
+    seeded.add(tenantId)
+    await getClient()
+      .from(T.channels)
+      .upsert(
+        channels.map((c) => ({
+          tenant_id: tenantId,
+          channel_key: c.id,
+          label: c.label,
+          icon: c.icon,
+          kind: c.kind,
+        })),
+        { onConflict: 'tenant_id,channel_key', ignoreDuplicates: true },
+      )
+  }
+
+  // One store.load() fans out to overview + channels + funnel + campaigns, and
+  // dashboard widgets pile on top — without dedup that's ~10 concurrent
+  // requests per mount (a stampede the instant mock never surfaced). Share
+  // in-flight promises and cache briefly; writes clear the cache.
+  const CACHE_TTL_MS = 30_000
+  const cache = new Map<string, { at: number; promise: Promise<unknown> }>()
+  function memo<T>(key: string, fn: () => Promise<T>): Promise<T> {
+    const hit = cache.get(key)
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS) return hit.promise as Promise<T>
+    const promise = fn().catch((err) => {
+      cache.delete(key)
+      throw err
+    })
+    cache.set(key, { at: Date.now(), promise })
+    return promise
+  }
+
+  function windowFor(range: DateRangeKey): { since: Date; days: number } {
+    const days = RANGE_DAYS[range]
+    // Quantized to the minute so equal ranges hit the same cache key.
+    const now = Math.floor(Date.now() / 60_000) * 60_000
+    return { since: new Date(now - days * 86_400_000), days }
+  }
+
+  function fetchAttribution(
+    tenantId: string,
+    since: Date,
+    until?: Date,
+  ): Promise<AttributionRow[]> {
+    const key = `attr:${tenantId}:${since.getTime()}:${until?.getTime() ?? ''}`
+    return memo(key, async () => {
+      let q = getClient()
+        .from(V.attribution)
+        .select('kind, source, channel_raw, occurred_at, value')
+        .eq('tenant_id', tenantId)
+        .gte('occurred_at', since.toISOString())
+        // Leads always count; conversions only from the vertical's source.
+        .or(`kind.eq.lead,and(kind.eq.conversion,source.eq.${conversion.source})`)
+      if (until) q = q.lt('occurred_at', until.toISOString())
+      const { data, error } = await q
+      if (error) throw error
+      return (data ?? []) as AttributionRow[]
+    })
+  }
+
+  interface ChannelRollup {
+    leads: number
+    conversions: number
+    value: number
+  }
+
+  function rollup(rows: AttributionRow[]): Map<string, ChannelRollup> {
+    const map = new Map<string, ChannelRollup>()
+    for (const row of rows) {
+      const channelId = resolveChannel(row.channel_raw)
+      if (!channelId) continue
+      const agg = map.get(channelId) ?? { leads: 0, conversions: 0, value: 0 }
+      if (row.kind === 'lead') agg.leads += 1
+      else {
+        agg.conversions += 1
+        agg.value += Number(row.value ?? conversion.avgValue)
+      }
+      map.set(channelId, agg)
+    }
+    return map
+  }
+
+  function fetchSpend(
+    tenantId: string,
+    days: number,
+    since: Date,
+  ): Promise<Map<string, number>> {
+    return memo(`spend:${tenantId}:${days}:${since.getTime()}`, () => fetchSpendRaw(tenantId, days, since))
+  }
+
+  async function fetchSpendRaw(
+    tenantId: string,
+    days: number,
+    since: Date,
+  ): Promise<Map<string, number>> {
+    const client = getClient()
+    const [channelRows, campaignRows] = await Promise.all([
+      client.from(V.channels).select('channel_key, monthly_spend').eq('tenant_id', tenantId),
+      client
+        .from(V.campaigns)
+        .select('channel_key, spend, status, starts_at, ends_at')
+        .eq('tenant_id', tenantId)
+        .neq('status', 'draft'),
+    ])
+    const spend = new Map<string, number>()
+    for (const row of channelRows.data ?? []) {
+      const id = resolveChannel(row.channel_key)
+      if (!id) continue
+      spend.set(id, (spend.get(id) ?? 0) + (Number(row.monthly_spend) * days) / 30)
+    }
+    for (const row of campaignRows.data ?? []) {
+      const id = resolveChannel(row.channel_key)
+      if (!id) continue
+      // Count a campaign's spend when its window overlaps the query window.
+      const ended = row.ends_at ? new Date(row.ends_at) : null
+      if (ended && ended < since) continue
+      spend.set(id, (spend.get(id) ?? 0) + Number(row.spend))
+    }
+    return spend
+  }
+
+  async function channelPerformance(query: MarketingQuery): Promise<ChannelPerformance[]> {
+    const tenantId = requireTenantId()
+    await ensureChannels(tenantId)
+    const { since, days } = windowFor(query.range)
+    const [rows, spend] = await Promise.all([
+      fetchAttribution(tenantId, since),
+      fetchSpend(tenantId, days, since),
+    ])
+    const byChannel = rollup(rows)
+    if (attributionBridge) {
+      const bridged = await attributionBridge.conversionsByChannel(query)
+      for (const b of bridged) {
+        const agg = byChannel.get(b.channelId) ?? { leads: 0, conversions: 0, value: 0 }
+        agg.conversions = b.conversions
+        agg.value = b.value
+        byChannel.set(b.channelId, agg)
+      }
+    }
+    const list = channels.map((ch) => {
+      const agg = byChannel.get(ch.id) ?? { leads: 0, conversions: 0, value: 0 }
+      const chSpend = spend.get(ch.id) ?? 0
+      return {
+        channelId: ch.id,
+        reach: 0,
+        leads: agg.leads,
+        conversions: agg.conversions,
+        spend: Math.round(chSpend),
+        value: Math.round(agg.value),
+        cvr: 0,
+        cpa: agg.conversions > 0 && chSpend > 0 ? chSpend / agg.conversions : 0,
+      }
+    })
+    return query.channelId ? list.filter((c) => c.channelId === query.channelId) : list
+  }
+
+  function campaignFromRow(row: Record<string, any>): Campaign {
+    return {
+      id: row.id,
+      name: row.name,
+      channelId: row.channel_key,
+      status: row.status,
+      start: row.starts_at ?? row.created_at,
+      end: row.ends_at ?? undefined,
+      spend: Number(row.spend ?? 0),
+      reach: 0,
+      leads: 0,
+      conversions: 0,
+      value: 0,
+    }
+  }
+
+  function withDerived(campaign: Campaign, rows: AttributionRow[]): Campaign {
+    const start = new Date(campaign.start).getTime()
+    const end = campaign.end ? new Date(campaign.end).getTime() : Number.POSITIVE_INFINITY
+    let leads = 0
+    let conversions = 0
+    let value = 0
+    for (const row of rows) {
+      if (resolveChannel(row.channel_raw) !== campaign.channelId) continue
+      const at = new Date(row.occurred_at).getTime()
+      if (at < start || at > end) continue
+      if (row.kind === 'lead') leads += 1
+      else {
+        conversions += 1
+        value += Number(row.value ?? conversion.avgValue)
+      }
+    }
+    return { ...campaign, leads, conversions, value: Math.round(value) }
+  }
+
+  return {
+    channelPerformance,
+
+    async overview(query: MarketingQuery): Promise<MarketingOverview> {
+      const tenantId = requireTenantId()
+      const perf = await channelPerformance(query)
+      const { since, days } = windowFor(query.range)
+      const prevRows = await fetchAttribution(
+        tenantId,
+        new Date(since.getTime() - days * 86_400_000),
+        since,
+      )
+      const conversions = perf.reduce((s, c) => s + c.conversions, 0)
+      const spend = perf.reduce((s, c) => s + c.spend, 0)
+      const value = perf.reduce((s, c) => s + c.value, 0)
+      const conversionsPrev = prevRows.filter(
+        (r) => r.kind === 'conversion' && resolveChannel(r.channel_raw),
+      ).length
+      const top = [...perf].sort((a, b) => b.conversions - a.conversions)[0]
+      return {
+        conversions,
+        conversionsPrev,
+        cvr: 0,
+        cvrPrev: 0,
+        spend,
+        cpa: conversions > 0 && spend > 0 ? spend / conversions : 0,
+        value,
+        topChannelId: top && top.conversions > 0 ? top.channelId : null,
+        channelMix: perf.map((c) => ({ channelId: c.channelId, conversions: c.conversions })),
+      }
+    },
+
+    async funnel(query: MarketingQuery): Promise<FunnelStage[]> {
+      if (attributionBridge) return attributionBridge.funnel(query)
+      const tenantId = requireTenantId()
+      const { since } = windowFor(query.range)
+      const rows = await fetchAttribution(tenantId, since)
+      const leads = rows.filter((r) => r.kind === 'lead').length
+      const conversions = rows.filter((r) => r.kind === 'conversion').length
+      return [
+        { id: 'leads', label: 'Leads', count: leads, color: '#0ea5e9' },
+        { id: 'converted', label: conversion.labelPlural, count: conversions, color: '#22c55e' },
+      ]
+    },
+
+    async listCampaigns(query: MarketingQuery): Promise<Campaign[]> {
+      const tenantId = requireTenantId()
+      const fetchRows = () =>
+        memo(`campaigns:${tenantId}`, async () => {
+          const { data, error } = await getClient()
+            .from(V.campaigns)
+            .select('*')
+            .eq('tenant_id', tenantId)
+            .order('created_at', { ascending: false })
+          if (error) throw error
+          return (data ?? []) as Record<string, any>[]
+        })
+      const [data, rows] = await Promise.all([
+        fetchRows(),
+        fetchAttribution(tenantId, windowFor(query.range).since),
+      ])
+      const list = query.channelId ? data.filter((r) => r.channel_key === query.channelId) : data
+      return list.map((row) => withDerived(campaignFromRow(row), rows))
+    },
+
+    async getCampaign(id: string): Promise<Campaign | null> {
+      const tenantId = requireTenantId()
+      const { data, error } = await getClient()
+        .from(V.campaigns)
+        .select('*')
+        .eq('tenant_id', tenantId)
+        .eq('id', id)
+        .maybeSingle()
+      if (error) throw error
+      if (!data) return null
+      const campaign = campaignFromRow(data)
+      const rows = await fetchAttribution(tenantId, new Date(campaign.start))
+      return withDerived(campaign, rows)
+    },
+
+    async saveCampaign(input: SaveCampaignInput): Promise<Campaign> {
+      const tenantId = requireTenantId()
+      const payload = {
+        name: input.name,
+        channel_key: input.channelId,
+        status: input.status,
+        starts_at: input.start || null,
+        ends_at: input.end || null,
+        spend: input.spend ?? 0,
+      }
+      if (input.id) {
+        const { data, error } = await getClient()
+          .from(T.campaigns)
+          .update(payload)
+          .eq('id', input.id)
+          .select('*')
+          .single()
+        if (error) throw error
+        cache.clear()
+        return campaignFromRow(data)
+      }
+      const { data, error } = await getClient()
+        .from(T.campaigns)
+        .insert({ tenant_id: tenantId, ...payload })
+        .select('*')
+        .single()
+      if (error) throw error
+      cache.clear()
+      return campaignFromRow(data)
+    },
+
+    async deleteCampaign(id: string): Promise<void> {
+      const { error } = await getClient().from(T.campaigns).delete().eq('id', id)
+      if (error) throw error
+      cache.clear()
+    },
+
+    invalidateCache() {
+      cache.clear()
+    },
+
+    async landingPages(query: MarketingQuery): Promise<LandingPagePerf[]> {
+      if (sitesBridge) return sitesBridge.landingPages(query)
+      return []
+    },
+  }
+}

package/src/data/tables.ts

@@ -4,4 +4,13 @@ export const T = {
   socialAccounts: 'plg_marketing_social_accounts',
   contentPlans: 'plg_marketing_content_plans',
   contentPosts: 'plg_marketing_content_posts',
+  channels: 'plg_marketing_channels',
+  campaigns: 'plg_marketing_campaigns',
+} as const
+
+// Read views (bridge views over spine + plugin tables; see 006_analytics_views.sql)
+export const V = {
+  channels: 'v_marketing_channels',
+  campaigns: 'v_marketing_campaigns',
+  attribution: 'v_marketing_attribution',
 } as const

package/src/data/types.ts

@@ -34,6 +34,8 @@ export interface MarketingDataProvider {
   deleteCampaign(id: string): Promise<void>
   funnel(query: MarketingQuery): Promise<FunnelStage[]>
   landingPages(query: MarketingQuery): Promise<LandingPagePerf[]>
+  /** Drop any provider-side read cache (external writes, e.g. agent RPCs). */
+  invalidateCache?(): void
 }
 
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -1,6 +1,6 @@
 import React from 'react'
 import type { PluginManifest, PluginRegistryDef, PluginScope, VerticalId } from '@fayz-ai/core'
-import { createSafeDataProvider, getSupabaseClientOptional, registerTranslations } from '@fayz-ai/core'
+import { createSafeDataProvider, registerTranslations } from '@fayz-ai/core'
 import { PluginSettingsPanel } from '@fayz-ai/saas'
 import { MarketingPage } from './MarketingPage'
 import { SettingsView } from './views/SettingsView'
@@ -17,12 +17,15 @@ import type {
   SitesPerformanceBridge,
 } from './data/types'
 import { createMockMarketingProvider } from './data/mock'
+import { createSupabaseMarketingProvider } from './data/supabase'
+import { T } from './data/tables'
 import type { ContentPlannerProvider } from './data/contentTypes'
 import { createMockContentPlannerProvider } from './data/contentMock'
 import { createSupabaseContentPlannerProvider } from './data/contentSupabase'
 import { createMarketingStore } from './store'
 import { createContentPlannerStore } from './views/content/contentStore'
-import { MIGRATION_000_PLG_RENAME, MIGRATION_001_CONTENT_PLANNER, MIGRATION_002_MULTI_PLATFORM, MIGRATION_003_RECORDING_OPS } from './migrations'
+import { MIGRATION_000_PLG_RENAME, MIGRATION_001_CONTENT_PLANNER, MIGRATION_002_MULTI_PLATFORM, MIGRATION_003_RECORDING_OPS, MIGRATION_004_RANKLAYER, MIGRATION_005_ANALYTICS_BASE, MIGRATION_006_ANALYTICS_VIEWS, MIGRATION_007_AGENT_RPCS } from './migrations'
+import { ranklayerConnectorDef } from './integrations/ranklayer/connectorDef'
 import { DEFAULT_CURRENCY, type MarketingCurrency } from './format'
 import { MARKETING_PRESETS, type MarketingDomain, type MarketingDomainModules } from './presets'
 import type { AcquisitionChannel, ConversionModel } from './types'
@@ -74,6 +77,8 @@ const DEFAULT_LABELS: MarketingLabels = {
   funnel: 'Funnel',
   landingPages: 'Landing pages',
   content: 'Content',
+  blog: 'Blog',
+  blogCategories: 'Categorias',
   settings: 'Settings',
 }
 
@@ -90,16 +95,26 @@ function resolveConfig(options?: MarketingPluginOptions): { config: ResolvedMark
   return { config, domain }
 }
 
-function createSafeProvider(config: ResolvedMarketingConfig, domain: MarketingDomain): MarketingDataProvider {
-  // Supabase-backed + bridge-fed providers land later; mock powers it for now.
-  void getSupabaseClientOptional()
-  return createMockMarketingProvider({ channels: config.channels, conversion: config.conversion, domain })
+function createSafeProvider(
+  config: ResolvedMarketingConfig,
+  domain: MarketingDomain,
+  options?: MarketingPluginOptions,
+): MarketingDataProvider {
+  return createSafeDataProvider(
+    () => createSupabaseMarketingProvider({
+      channels: config.channels,
+      conversion: config.conversion,
+      attributionBridge: options?.attributionBridge,
+      sitesBridge: options?.sitesBridge,
+    }),
+    () => createMockMarketingProvider({ channels: config.channels, conversion: config.conversion, domain }),
+  )
 }
 
 export function createMarketingPlugin(options?: MarketingPluginOptions): PluginManifest {
   registerTranslations(marketingLocales)
   const { config, domain } = resolveConfig(options)
-  const provider = options?.dataProvider ?? createSafeProvider(config, domain)
+  const provider = options?.dataProvider ?? createSafeProvider(config, domain, options)
   const store = createMarketingStore(provider)
   const dashboardWidgets = createMarketingDashboardWidgets({ config, provider, store })
 
@@ -130,6 +145,8 @@ export function createMarketingPlugin(options?: MarketingPluginOptions): PluginM
         subtitle: config.labels.pageSubtitle,
         generalSettings: React.createElement(SettingsView),
         registries: marketingRegistries,
+        // Enables the "Integrações" tab (renders manifest connectors for this host).
+        hostPluginId: 'marketing',
         routeBase: '/settings/marketing',
       }))
   SettingsComponent.displayName = 'MarketingSettings'
@@ -150,6 +167,96 @@ export function createMarketingPlugin(options?: MarketingPluginOptions): PluginM
       { id: 'marketing', label: config.labels.pageTitle, group: 'Engage' },
       ...(config.modules.landingPages ? [{ id: 'marketing.landing-pages', label: config.labels.landingPages, group: 'Engage' }] : []),
       ...(config.modules.contentPlanner ? [{ id: 'marketing.content', label: config.labels.content, group: 'Engage' }] : []),
+      ...(config.modules.blog ? [{ id: 'marketing.blog', label: config.labels.blog, group: 'Engage' }] : []),
+    ],
+    declaredLimits: [
+      ...(config.modules.campaigns ? [{ key: 'campaigns_active', label: 'Active campaigns', table: T.campaigns }] : []),
+      ...(config.modules.contentPlanner ? [{ key: 'content_posts_month', label: 'Content posts / month', table: 'plg_marketing_content_posts', period: 'month' as const }] : []),
+      ...(config.modules.blog ? [{ key: 'blog_posts', label: 'Blog posts', table: 'plg_blog_posts' }] : []),
+    ],
+    // Read-models for the agent's data primitives (searchRecords/queryData) —
+    // mirrors agenda's `agenda:appointments`. Keys are stable ASCII; fields are
+    // the provider's camelCase output shape.
+    queryEntities: [
+      ...(config.modules.campaigns ? [{
+        key: 'marketing:campaigns',
+        writable: false,
+        entity: {
+          name: 'Campaign',
+          namePlural: 'Campaigns',
+          icon: 'Megaphone',
+          permission: { feature: 'marketing', action: 'read' as const },
+          fields: [
+            { key: 'name', label: 'Name', type: 'text' as const, searchable: true },
+            { key: 'channelKey', label: 'Channel', type: 'text' as const, searchable: true },
+            { key: 'channelLabel', label: 'Channel label', type: 'text' as const },
+            { key: 'status', label: 'Status', type: 'text' as const },
+            { key: 'startsAt', label: 'Starts at', type: 'text' as const },
+            { key: 'endsAt', label: 'Ends at', type: 'text' as const },
+            { key: 'spend', label: 'Spend', type: 'number' as const },
+            { key: 'createdAt', label: 'Created at', type: 'text' as const },
+          ],
+          data: {
+            table: 'v_marketing_campaigns',
+            tenantScoped: true,
+            searchColumns: ['name', 'channel_key'],
+          },
+        },
+      }] : []),
+      ...(config.modules.channels ? [{
+        key: 'marketing:channels',
+        writable: false,
+        entity: {
+          name: 'Marketing channel',
+          namePlural: 'Marketing channels',
+          icon: 'Radio',
+          permission: { feature: 'marketing', action: 'read' as const },
+          fields: [
+            { key: 'channelKey', label: 'Key', type: 'text' as const, searchable: true },
+            { key: 'label', label: 'Channel', type: 'text' as const, searchable: true },
+            { key: 'kind', label: 'Type', type: 'text' as const },
+            { key: 'isActive', label: 'Active', type: 'boolean' as const },
+            { key: 'monthlySpend', label: 'Monthly spend', type: 'number' as const },
+          ],
+          data: {
+            table: 'v_marketing_channels',
+            tenantScoped: true,
+            searchColumns: ['label', 'channel_key'],
+          },
+        },
+      }] : []),
+      ...(config.modules.contentPlanner ? [{
+        key: 'marketing:contentPosts',
+        writable: false,
+        entity: {
+          name: 'Content post',
+          namePlural: 'Content posts',
+          icon: 'FileText',
+          permission: { feature: 'marketing.content', action: 'read' as const },
+          fields: [
+            { key: 'title', label: 'Title', type: 'text' as const, searchable: true },
+            { key: 'format', label: 'Format', type: 'text' as const },
+            { key: 'status', label: 'Status', type: 'text' as const },
+            { key: 'weekNumber', label: 'Week', type: 'number' as const },
+            { key: 'scheduledDate', label: 'Scheduled date', type: 'text' as const },
+            { key: 'hook', label: 'Hook', type: 'text' as const, searchable: true },
+          ],
+          data: {
+            table: T.contentPosts,
+            tenantScoped: true,
+            searchColumns: ['title', 'hook'],
+          },
+        },
+      }] : []),
+    ],
+    declaredRpcs: [
+      ...(config.modules.campaigns ? [{
+        name: 'agent_marketing_create_campaign',
+        kind: 'write' as const,
+        description:
+          'Guarded campaign create: agent_guard (role→plan→campaigns_active cap), channel validated against the tenant channel set, audited.',
+        audits: true,
+      }] : []),
     ],
     navigation: [
       {
@@ -204,7 +311,34 @@ export function createMarketingPlugin(options?: MarketingPluginOptions): PluginM
         sql: MIGRATION_003_RECORDING_OPS,
         description: 'Recording-day checklist + media asset URL on posts; content-media storage bucket',
       },
+      {
+        id: 'marketing-004-ranklayer',
+        version: '1.3.0',
+        sql: MIGRATION_004_RANKLAYER,
+        description: 'RankLayer connector state: plg_marketing_ranklayer_integrations + _sync_log (tenant RLS)',
+      },
+      {
+        id: 'marketing-005-analytics-base',
+        version: '1.4.0',
+        sql: MIGRATION_005_ANALYTICS_BASE,
+        description: 'Analytics base: plg_marketing_channels + plg_marketing_campaigns with canonical tenant RLS',
+      },
+      {
+        id: 'marketing-006-analytics-views',
+        version: '1.4.0',
+        sql: MIGRATION_006_ANALYTICS_VIEWS,
+        description: 'Read views v_marketing_channels/_campaigns + generic spine-only v_marketing_attribution',
+      },
+      {
+        id: 'marketing-007-agent-rpcs',
+        version: '1.4.0',
+        sql: MIGRATION_007_AGENT_RPCS,
+        description: 'agent_marketing_create_campaign — guarded, audited server-plane campaign create',
+      },
     ],
+    // RankLayer SEO connector — renders in the Integrações settings tab. Scaffold
+    // (control plane only); the real sync lands via an external PR (RANKLAYER.md).
+    connectors: [ranklayerConnectorDef],
     aiTools: [
       {
         id: 'marketing.channel-performance',
@@ -245,18 +379,26 @@ export function createMarketingPlugin(options?: MarketingPluginOptions): PluginM
       {
         id: 'marketing.create-campaign',
         name: 'createCampaign',
-        description: 'Creates an acquisition campaign on a channel.',
+        description:
+          'Creates an acquisition campaign on a channel. Resolve the channel first via queryData/searchRecords on marketing channels (use its channel key). The user confirms before creating.',
         icon: 'Plus',
         mode: 'persist' as const,
+        limitKey: 'campaigns_active',
+        execution: { plane: 'server' as const, kind: 'rpc' as const, rpc: 'agent_marketing_create_campaign' },
         category: 'Marketing',
         parameters: {
           type: 'object' as const,
           properties: {
             name: { type: 'string' as const, description: 'Campaign name' },
-            channelId: { type: 'string' as const, description: 'Acquisition channel id' },
+            channel_key: { type: 'string' as const, description: "Acquisition channel key (e.g. 'instagram') or its label" },
+            status: { type: 'string' as const, enum: ['draft', 'active', 'paused'], description: 'Defaults to draft' },
+            starts_at: { type: 'string' as const, description: 'ISO start date-time (defaults to now)' },
+            ends_at: { type: 'string' as const, description: 'ISO end date-time (optional)' },
+            spend: { type: 'number' as const, description: 'Planned/committed spend (optional)' },
           },
-          required: ['name', 'channelId'],
+          required: ['name', 'channel_key'],
         },
+        suggestions: [{ label: 'Create an Instagram campaign for this month' }],
         permission: { feature: 'marketing', action: 'create' as const },
       },
     ],
@@ -289,6 +431,7 @@ export type {
 } from './types'
 export { MARKETING_PRESETS, type MarketingDomain } from './presets'
 export { createMockMarketingProvider } from './data/mock'
+export { createSupabaseMarketingProvider } from './data/supabase'
 export type {
   ContentPlannerProvider,
   ContentPlan,