@foundrynorth/flux-schema 1.0.0

package/dist/schema.js

@@ -0,0 +1,3802 @@
+/**
+ * FNFlux Database Schema (Drizzle ORM)
+ *
+ * All tables are prefixed with `flux_` to maintain separation from Forge tables.
+ * This schema lives in the same Neon database as Forge.
+ *
+ * CRITICAL: No stubs. All tables are real and will be created on migration.
+ */
+import { pgTable, varchar, text, boolean, timestamp, date, jsonb, integer, bigint, numeric, uuid, real, serial, time, pgEnum, uniqueIndex, index, } from "drizzle-orm/pg-core";
+import { relations, sql } from "drizzle-orm";
+// =============================================================================
+// ENUMS
+// =============================================================================
+export const fluxProjectStatusEnum = pgEnum("flux_project_status", [
+    "active",
+    "paused",
+    "archived",
+]);
+export const fluxEmailVisibilityEnum = pgEnum("flux_email_visibility", [
+    "private",
+    "pending_review",
+    "shared",
+    "auto_hidden",
+]);
+export const fluxViewTierEnum = pgEnum("flux_view_tier", [
+    "full",
+    "limited",
+    "client",
+]);
+export const fluxSubscriptionStatusEnum = pgEnum("flux_subscription_status", [
+    "active",
+    "pending",
+    "expired",
+    "revoked",
+]);
+export const fluxActivityTypeEnum = pgEnum("flux_activity_type", [
+    "email",
+    "task",
+    "ticket",
+    "pacing",
+    "slack",
+    "alert",
+    "campaign",
+]);
+export const fluxSourceSystemEnum = pgEnum("flux_source_system", [
+    "hubspot",
+    "ninjacat",
+    "slack",
+    "trigger",
+    "compass",
+]);
+export const fluxActivityVisibilityEnum = pgEnum("flux_activity_visibility", [
+    "owner_only",
+    "shared",
+    "all",
+]);
+export const fluxSeverityEnum = pgEnum("flux_severity", [
+    "info",
+    "warning",
+    "critical",
+]);
+export const fluxAlertTypeEnum = pgEnum("flux_alert_type", [
+    "pixel_down",
+    "pacing_deviation",
+    "task_overdue",
+    "ticket_stale",
+    "email_no_response",
+    "campaign_ended",
+    "custom",
+]);
+export const fluxPrimaryRoleEnum = pgEnum("flux_primary_role", [
+    "admin",
+    "leader",
+    "strategist",
+    "account_executive",
+    "sentinel_only",
+    "view_only",
+]);
+export const fluxEscalationStateEnum = pgEnum("flux_escalation_state", [
+    "critical_now",
+    "needs_owner_today",
+    "follow_up_soon",
+    "waiting_on_client",
+    "waiting_on_vendor",
+    "monitor",
+]);
+export const fluxEmbedTypeEnum = pgEnum("flux_embed_type", [
+    "ninjacat",
+    "iframe",
+    "custom",
+]);
+export const fluxTaskStatusEnum = pgEnum("flux_task_status", [
+    "backlog",
+    "in_progress",
+    "in_review",
+    "complete",
+]);
+export const fluxTaskPriorityEnum = pgEnum("flux_task_priority", [
+    "low",
+    "medium",
+    "high",
+    "urgent",
+]);
+export const fluxOwnerTypeEnum = pgEnum("flux_owner_type", [
+    "internal",
+    "external",
+    "vendor",
+]);
+// Secrets Management (API keys, billing, rotation tracking)
+export const fluxSecretsProviderCategoryEnum = pgEnum("flux_secrets_provider_category", [
+    "ai",
+    "auth",
+    "database",
+    "storage",
+    "email",
+    "crm",
+    "scraping",
+    "monitoring",
+    "maps",
+    "other",
+]);
+export const fluxSecretsStatusEnum = pgEnum("flux_secrets_status", [
+    "active",
+    "expiring_soon",
+    "expired",
+    "revoked",
+]);
+export const fluxSecretsPlatformEnum = pgEnum("flux_secrets_platform", [
+    "railway",
+    "vercel",
+    "trigger",
+    "local",
+]);
+export const fluxSecretsSyncStatusEnum = pgEnum("flux_secrets_sync_status", [
+    "synced",
+    "pending",
+    "failed",
+    "unknown",
+]);
+export const fluxSecretsAuditActionEnum = pgEnum("flux_secrets_audit_action", [
+    "created",
+    "rotated",
+    "revoked",
+    "synced",
+    "sync_failed",
+]);
+// =============================================================================
+// USERS (Extension table - references Clerk, not Forge users)
+// =============================================================================
+/**
+ * Flux user profiles - extends Clerk user identity with Flux-specific data.
+ *
+ * NOTE: Unlike Forge which uses username/password auth, Flux uses Clerk.
+ * This table stores Flux-specific user data keyed by Clerk user ID.
+ */
+export const fluxUsers = pgTable("flux_users", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    clerkId: varchar("clerk_id").notNull().unique(),
+    email: varchar("email").notNull(),
+    name: varchar("name"),
+    primaryRole: fluxPrimaryRoleEnum("primary_role").notNull().default("strategist"),
+    isAdmin: boolean("is_admin").default(false).notNull(),
+    hasSentinelAccess: boolean("has_sentinel_access").notNull().default(false),
+    hasDashboardAccess: boolean("has_dashboard_access").notNull().default(true),
+    privacyKeywords: jsonb("privacy_keywords").default([]).$type(),
+    /** HubSpot owner ID for reverse lookup (Flux user → HubSpot owner) */
+    hubspotOwnerId: varchar("hubspot_owner_id"),
+    slackUserId: varchar("slack_user_id"),
+    notificationPreferences: jsonb("notification_preferences")
+        .default({})
+        .$type(),
+    onboardingComplete: boolean("onboarding_complete").notNull().default(true),
+    followedKeywords: jsonb("followed_keywords").default([]).$type(),
+    lastActiveAt: timestamp("last_active_at").defaultNow(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    clerkIdIdx: uniqueIndex("flux_users_clerk_id_idx").on(table.clerkId),
+    emailIdx: index("flux_users_email_idx").on(table.email),
+    lastActiveIdx: index("flux_users_last_active_idx").on(table.lastActiveAt),
+}));
+// =============================================================================
+// PROJECTS (HubSpot Companies)
+// =============================================================================
+export const fluxProjects = pgTable("flux_projects", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    hubspotCompanyId: varchar("hubspot_company_id").unique(),
+    name: varchar("name").notNull(),
+    domain: varchar("domain"),
+    /** Account Executive — distinct role (map from HubSpot account_executive if present) */
+    accountExecutiveId: varchar("account_executive_id").references(() => fluxUsers.id),
+    /** Account Manager (HubSpot account_manager) — distinct role */
+    accountManagerId: varchar("account_manager_id").references(() => fluxUsers.id),
+    /** Primary Strategist (HubSpot strategist) */
+    primaryStrategistId: varchar("primary_strategist_id").references(() => fluxUsers.id),
+    /** Secondary Strategist (optional second strategist) */
+    secondaryStrategistId: varchar("secondary_strategist_id").references(() => fluxUsers.id),
+    /** Account Coordinator (HubSpot account_coordinator) — distinct role */
+    accountCoordinatorId: varchar("account_coordinator_id").references(() => fluxUsers.id),
+    /** Paid Search Specialist — Flux-only role (no HubSpot mapping) */
+    paidSearchSpecialistId: varchar("paid_search_specialist_id").references(() => fluxUsers.id),
+    /** Pod name — free-text label (e.g. "Pod A") */
+    pod: varchar("pod"),
+    defaultEmailVisibility: fluxEmailVisibilityEnum("default_email_visibility")
+        .default("pending_review")
+        .notNull(),
+    /** HubSpot tier_level (Tier 1 / Tier 2 / Tier 3) */
+    tierLevel: varchar("tier_level"),
+    /** HubSpot hs_ideal_customer_profile (tier_1 / tier_2 / tier_3) */
+    icpTier: varchar("icp_tier"),
+    /** HubSpot hs_is_target_account */
+    isTargetAccount: boolean("is_target_account").default(false),
+    /** Parent project for account hierarchy (HubSpot hs_parent_company_id) */
+    parentProjectId: varchar("parent_project_id").references(() => fluxProjects.id, { onDelete: "set null" }),
+    // -- HubSpot enrichment fields --
+    /** HubSpot company_status (active/inactive for Rules of Engagement) */
+    companyStatus: varchar("company_status"),
+    /** Forge creative compliance status from HubSpot fn_forge_compliance_status */
+    forgeComplianceStatus: varchar("forge_compliance_status"),
+    /** Forge fact check status from HubSpot fn_forge_fact_check_status */
+    forgeFactCheckStatus: varchar("forge_fact_check_status"),
+    /** HubSpot lifecyclestage */
+    lifecycleStage: varchar("lifecycle_stage"),
+    /** HubSpot hs_lead_status */
+    leadStatus: varchar("lead_status"),
+    /** HubSpot annualrevenue */
+    annualRevenue: numeric("annual_revenue", { precision: 14, scale: 2 }),
+    /** HubSpot type (prospect/partner/customer classification) */
+    companyType: varchar("company_type"),
+    /** SLA profile override — FK to flux_sla_profiles */
+    slaProfileId: text("sla_profile_id").references(() => fluxSlaProfiles.id, { onDelete: "set null" }),
+    ninjacatClientId: varchar("ninjacat_client_id"),
+    slackChannelId: varchar("slack_channel_id"),
+    status: fluxProjectStatusEnum("status").default("active").notNull(),
+    lastHubspotSync: timestamp("last_hubspot_sync"),
+    lastNinjacatSync: timestamp("last_ninjacat_sync"),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    hubspotIdIdx: uniqueIndex("flux_projects_hubspot_id_idx").on(table.hubspotCompanyId),
+    primaryStrategistIdx: index("flux_projects_primary_strategist_idx").on(table.primaryStrategistId),
+    accountManagerIdx: index("flux_projects_account_manager_idx").on(table.accountManagerId),
+    accountCoordinatorIdx: index("flux_projects_account_coordinator_idx").on(table.accountCoordinatorId),
+    paidSearchSpecialistIdx: index("flux_projects_paid_search_specialist_idx").on(table.paidSearchSpecialistId),
+    statusIdx: index("flux_projects_status_idx").on(table.status),
+    parentProjectIdx: index("flux_projects_parent_project_idx").on(table.parentProjectId),
+}));
+// =============================================================================
+// TEAM TEMPLATES
+// =============================================================================
+export const fluxTeamTemplates = pgTable("flux_team_templates", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    name: varchar("name").notNull(),
+    description: text("description"),
+    pod: varchar("pod"),
+    createdById: varchar("created_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+export const fluxTeamTemplateMembers = pgTable("flux_team_template_members", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    templateId: varchar("template_id")
+        .references(() => fluxTeamTemplates.id, { onDelete: "cascade" })
+        .notNull(),
+    userId: varchar("user_id").references(() => fluxUsers.id),
+    placeholderRole: varchar("placeholder_role"), // e.g., "External Vendor"
+    role: varchar("role").default("member").notNull(),
+    viewTier: fluxViewTierEnum("view_tier").default("full").notNull(),
+    displayOrder: integer("display_order").default(0).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    templateIdx: index("flux_template_members_template_idx").on(table.templateId),
+}));
+/** Available pod color labels used across templates and project assignments. */
+export const POD_OPTIONS = [
+    "Yellow",
+    "Purple",
+    "Blue",
+    "Green",
+    "Red",
+    "Orange",
+    "Pink",
+];
+/** Maps template role values to fluxProjects column names for apply-time writes. */
+export const TEMPLATE_ROLE_OPTIONS = [
+    { value: "account_executive", label: "Account Executive", projectField: "accountExecutiveId" },
+    { value: "account_manager", label: "Account Manager", projectField: "accountManagerId" },
+    { value: "strategist", label: "Strategist", projectField: "primaryStrategistId" },
+    { value: "secondary_strategist", label: "Secondary Strategist", projectField: "secondaryStrategistId" },
+    { value: "account_coordinator", label: "Account Coordinator", projectField: "accountCoordinatorId" },
+    { value: "paid_search_specialist", label: "Paid Search Specialist", projectField: "paidSearchSpecialistId" },
+    { value: "member", label: "Team Member", projectField: null },
+];
+// =============================================================================
+// SUBSCRIPTIONS (Team Access)
+// =============================================================================
+export const fluxSubscriptions = pgTable("flux_subscriptions", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    userId: varchar("user_id").references(() => fluxUsers.id),
+    externalEmail: varchar("external_email"), // For non-Clerk users
+    viewTier: fluxViewTierEnum("view_tier").default("full").notNull(),
+    invitedById: varchar("invited_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    appliedTemplateId: varchar("applied_template_id").references(() => fluxTeamTemplates.id),
+    expiresAt: timestamp("expires_at"),
+    status: fluxSubscriptionStatusEnum("status").default("active").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_subscriptions_project_idx").on(table.projectId),
+    userIdx: index("flux_subscriptions_user_idx").on(table.userId),
+    statusIdx: index("flux_subscriptions_status_idx").on(table.status),
+}));
+// =============================================================================
+// EMAIL THREADS
+// =============================================================================
+export const fluxEmailThreads = pgTable("flux_email_threads", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    hubspotEmailId: varchar("hubspot_email_id").unique(),
+    subject: varchar("subject").notNull(),
+    senderEmail: varchar("sender_email").notNull(),
+    senderName: varchar("sender_name"),
+    receivedAt: timestamp("received_at").notNull(),
+    visibility: fluxEmailVisibilityEnum("visibility")
+        .default("pending_review")
+        .notNull(),
+    reviewedById: varchar("reviewed_by_id").references(() => fluxUsers.id),
+    reviewedAt: timestamp("reviewed_at"),
+    hiddenReason: varchar("hidden_reason"),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_email_threads_project_idx").on(table.projectId),
+    visibilityIdx: index("flux_email_threads_visibility_idx").on(table.visibility),
+    hubspotIdx: uniqueIndex("flux_email_threads_hubspot_idx").on(table.hubspotEmailId),
+}));
+// =============================================================================
+// ACTIVITY ITEMS (Unified Feed)
+// =============================================================================
+export const fluxActivityItems = pgTable("flux_activity_items", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    type: fluxActivityTypeEnum("type").notNull(),
+    sourceId: varchar("source_id").notNull(),
+    sourceSystem: fluxSourceSystemEnum("source_system").notNull(),
+    summary: text("summary").notNull(),
+    visibility: fluxActivityVisibilityEnum("visibility")
+        .default("shared")
+        .notNull(),
+    severity: fluxSeverityEnum("severity"),
+    occurredAt: timestamp("occurred_at").notNull(),
+    metadata: jsonb("metadata").default({}).$type(),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_activity_items_project_idx").on(table.projectId),
+    typeIdx: index("flux_activity_items_type_idx").on(table.type),
+    occurredAtIdx: index("flux_activity_items_occurred_at_idx").on(table.occurredAt),
+}));
+// =============================================================================
+// ALERT RULES
+// =============================================================================
+export const fluxAlertRules = pgTable("flux_alert_rules", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id").references(() => fluxProjects.id, {
+        onDelete: "cascade",
+    }),
+    createdById: varchar("created_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    type: fluxAlertTypeEnum("type").notNull(),
+    name: varchar("name").notNull(),
+    config: jsonb("config").default({}).$type(),
+    notifySlack: boolean("notify_slack").default(true).notNull(),
+    notifyEmail: boolean("notify_email").default(false).notNull(),
+    notifyInApp: boolean("notify_in_app").default(true).notNull(),
+    slackChannelOverride: varchar("slack_channel_override"),
+    isActive: boolean("is_active").default(true).notNull(),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_alert_rules_project_idx").on(table.projectId),
+    activeIdx: index("flux_alert_rules_active_idx").on(table.isActive),
+}));
+// =============================================================================
+// ALERTS (Fired)
+// =============================================================================
+export const fluxAlerts = pgTable("flux_alerts", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    ruleId: varchar("rule_id")
+        .references(() => fluxAlertRules.id, { onDelete: "cascade" })
+        .notNull(),
+    severity: fluxSeverityEnum("severity").notNull(),
+    title: varchar("title").notNull(),
+    message: text("message").notNull(),
+    sourceData: jsonb("source_data")
+        .default({})
+        .$type(),
+    firedAt: timestamp("fired_at").defaultNow().notNull(),
+    acknowledgedAt: timestamp("acknowledged_at"),
+    acknowledgedById: varchar("acknowledged_by_id").references(() => fluxUsers.id),
+    resolvedAt: timestamp("resolved_at"),
+    slackMessageTs: varchar("slack_message_ts"),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_alerts_project_idx").on(table.projectId),
+    firedAtIdx: index("flux_alerts_fired_at_idx").on(table.firedAt),
+    unacknowledgedIdx: index("flux_alerts_unacknowledged_idx").on(table.acknowledgedAt),
+}));
+// =============================================================================
+// PROJECT ESCALATIONS
+// =============================================================================
+export const fluxProjectEscalations = pgTable("flux_project_escalations", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull()
+        .unique(),
+    state: fluxEscalationStateEnum("state").notNull(),
+    reason: text("reason"),
+    nextFollowupAt: timestamp("next_followup_at"),
+    lastAutoRecommendationAt: timestamp("last_auto_recommendation_at"),
+    updatedById: varchar("updated_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_project_escalations_project_idx").on(table.projectId),
+    stateIdx: index("flux_project_escalations_state_idx").on(table.state),
+    followupIdx: index("flux_project_escalations_followup_idx").on(table.nextFollowupAt),
+}));
+export const fluxProjectEscalationHistory = pgTable("flux_project_escalation_history", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    fromState: fluxEscalationStateEnum("from_state"),
+    toState: fluxEscalationStateEnum("to_state").notNull(),
+    reason: text("reason"),
+    changedById: varchar("changed_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_project_escalation_history_project_idx").on(table.projectId),
+    toStateIdx: index("flux_project_escalation_history_to_state_idx").on(table.toState),
+    createdAtIdx: index("flux_project_escalation_history_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// EMBEDDED DASHBOARDS
+// =============================================================================
+export const fluxEmbeddedDashboards = pgTable("flux_embedded_dashboards", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    name: varchar("name").notNull(),
+    embedType: fluxEmbedTypeEnum("embed_type").notNull(),
+    embedUrl: varchar("embed_url").notNull(),
+    displayOrder: integer("display_order").default(0).notNull(),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_embedded_dashboards_project_idx").on(table.projectId),
+}));
+// =============================================================================
+// AUDIT LOG
+// =============================================================================
+export const fluxAuditLog = pgTable("flux_audit_log", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    userId: varchar("user_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    action: varchar("action").notNull(),
+    resourceType: varchar("resource_type").notNull(),
+    resourceId: varchar("resource_id").notNull(),
+    previousValue: jsonb("previous_value").$type(),
+    newValue: jsonb("new_value").$type(),
+    ipAddress: varchar("ip_address"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    userIdx: index("flux_audit_log_user_idx").on(table.userId),
+    resourceIdx: index("flux_audit_log_resource_idx").on(table.resourceType, table.resourceId),
+    createdAtIdx: index("flux_audit_log_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// UNIFIED ROLE CONFIG (Cockpit user management)
+// =============================================================================
+export const fluxUnifiedRoleConfig = pgTable("flux_unified_role_config", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    unifiedRole: varchar("unified_role").notNull(),
+    app: varchar("app").notNull(),
+    config: jsonb("config").notNull().$type(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+    updatedBy: varchar("updated_by"),
+}, (table) => ({
+    uniqueRoleApp: uniqueIndex("flux_unified_role_config_role_app_idx").on(table.unifiedRole, table.app),
+}));
+// =============================================================================
+// STRATEGIST TELEMETRY
+// =============================================================================
+export const fluxStrategistEvents = pgTable("flux_strategist_events", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    userId: varchar("user_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    eventName: varchar("event_name").notNull(),
+    page: varchar("page").notNull(),
+    context: jsonb("context").default({}).$type(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    userIdx: index("flux_strategist_events_user_idx").on(table.userId),
+    eventNameIdx: index("flux_strategist_events_event_name_idx").on(table.eventName),
+    pageIdx: index("flux_strategist_events_page_idx").on(table.page),
+    createdAtIdx: index("flux_strategist_events_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// BUDGETS (Monthly budget records per project)
+// =============================================================================
+export const fluxBudgets = pgTable("flux_budgets", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    month: integer("month").notNull(), // 1-12
+    year: integer("year").notNull(),
+    budgetAmount: integer("budget_amount").notNull(), // cents
+    goalAmount: integer("goal_amount"), // revenue goal, cents
+    actualSpend: integer("actual_spend").default(0).notNull(), // cents
+    source: varchar("source").default("manual").notNull(), // "manual" / "hubspot" / "ninjacat"
+    notes: text("notes"),
+    updatedById: varchar("updated_by_id").references(() => fluxUsers.id),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_budgets_project_idx").on(table.projectId),
+    periodIdx: uniqueIndex("flux_budgets_period_idx").on(table.projectId, table.year, table.month),
+}));
+// =============================================================================
+// TASKS (Deliverables / Kanban items)
+// =============================================================================
+export const fluxTasks = pgTable("flux_tasks", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    title: varchar("title").notNull(),
+    description: text("description"),
+    status: fluxTaskStatusEnum("status").default("backlog").notNull(),
+    priority: fluxTaskPriorityEnum("priority").default("medium").notNull(),
+    assigneeId: varchar("assignee_id").references(() => fluxUsers.id),
+    createdById: varchar("created_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    dueDate: timestamp("due_date"),
+    completedAt: timestamp("completed_at"),
+    displayOrder: integer("display_order").default(0).notNull(),
+    hubspotTaskId: varchar("hubspot_task_id"),
+    // Compass provenance (Feature 2)
+    compassMetadata: jsonb("compass_metadata").$type(),
+    // Risk & ownership (Feature 3)
+    blockedByTaskId: varchar("blocked_by_task_id"),
+    ownerName: text("owner_name"),
+    ownerType: fluxOwnerTypeEnum("owner_type"),
+    isInternalOnly: boolean("is_internal_only").default(false).notNull(),
+    // Notification tracking (Feature 4)
+    lastNotifiedAt: timestamp("last_notified_at"),
+    notificationCount: integer("notification_count").default(0).notNull(),
+    isDemo: boolean("is_demo").default(false).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_tasks_project_idx").on(table.projectId),
+    statusIdx: index("flux_tasks_status_idx").on(table.status),
+    assigneeIdx: index("flux_tasks_assignee_idx").on(table.assigneeId),
+    dueDateIdx: index("flux_tasks_due_date_idx").on(table.dueDate),
+    blockedByIdx: index("flux_tasks_blocked_by_idx").on(table.blockedByTaskId),
+}));
+// =============================================================================
+// SECRETS MANAGEMENT (API keys, billing, rotation tracking)
+// =============================================================================
+/**
+ * External service/vendor accounts. Tracks billing info, payment method, dashboard URLs.
+ */
+export const fluxSecretsProviders = pgTable("flux_secrets_providers", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    name: varchar("name").notNull(),
+    category: fluxSecretsProviderCategoryEnum("category").notNull(),
+    dashboardUrl: varchar("dashboard_url"),
+    billingUrl: varchar("billing_url"),
+    paymentMethod: varchar("payment_method"),
+    paymentExpiry: date("payment_expiry"),
+    accountEmail: varchar("account_email"),
+    accountId: varchar("account_id"),
+    pricingModel: varchar("pricing_model"),
+    monthlyBudgetUsd: integer("monthly_budget_usd"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    categoryIdx: index("flux_secrets_providers_category_idx").on(table.category),
+}));
+/**
+ * Individual secrets/keys. Stores only key_prefix (first 8 chars), never full value.
+ */
+export const fluxSecretsRegistry = pgTable("flux_secrets_registry", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    providerId: varchar("provider_id")
+        .references(() => fluxSecretsProviders.id, { onDelete: "cascade" })
+        .notNull(),
+    envVarName: varchar("env_var_name").notNull(),
+    description: varchar("description"),
+    keyPrefix: varchar("key_prefix"),
+    isRequired: boolean("is_required").default(true).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    expiresAt: timestamp("expires_at"),
+    lastRotatedAt: timestamp("last_rotated_at"),
+    rotationIntervalDays: integer("rotation_interval_days")
+        .default(90)
+        .notNull(),
+    status: fluxSecretsStatusEnum("status").default("active").notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    providerIdx: index("flux_secrets_registry_provider_idx").on(table.providerId),
+    statusIdx: index("flux_secrets_registry_status_idx").on(table.status),
+}));
+/**
+ * Maps each secret to its deployment targets (Railway services, Vercel projects).
+ */
+export const fluxSecretsDeployments = pgTable("flux_secrets_deployments", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    secretId: varchar("secret_id")
+        .references(() => fluxSecretsRegistry.id, { onDelete: "cascade" })
+        .notNull(),
+    platform: fluxSecretsPlatformEnum("platform").notNull(),
+    projectName: varchar("project_name").notNull(),
+    projectId: varchar("project_id").notNull(),
+    platformEnvironmentId: varchar("platform_environment_id"),
+    envVarName: varchar("env_var_name").notNull(),
+    environment: varchar("environment").default("production").notNull(),
+    lastSyncedAt: timestamp("last_synced_at"),
+    syncStatus: fluxSecretsSyncStatusEnum("sync_status")
+        .default("unknown")
+        .notNull(),
+    /** Optional link to the app this deployment belongs to (set null if app deleted). */
+    appId: varchar("app_id").references(() => fluxEnvApps.id, { onDelete: "set null" }),
+}, (table) => ({
+    secretIdx: index("flux_secrets_deployments_secret_idx").on(table.secretId),
+    platformIdx: index("flux_secrets_deployments_platform_idx").on(table.platform),
+}));
+/**
+ * Encrypted secret values — ciphertext stored here, decrypted via OVH KMS.
+ * Each write creates a new version (append-only).
+ */
+export const fluxSecretsVault = pgTable("flux_secrets_vault", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** Vault path (e.g. foundry/fn-legacy/DATABASE_URL) */
+    vaultPath: varchar("vault_path").notNull(),
+    /** JWE-encrypted value from OVH KMS */
+    encryptedValue: text("encrypted_value").notNull(),
+    /** Auto-incrementing version per path */
+    version: integer("version").notNull().default(1),
+    /** KMS key ID used for encryption (for key rotation tracking) */
+    kmsKeyId: varchar("kms_key_id").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    pathVersionIdx: uniqueIndex("flux_secrets_vault_path_version_idx").on(table.vaultPath, table.version),
+    pathIdx: index("flux_secrets_vault_path_idx").on(table.vaultPath),
+}));
+/**
+ * Immutable audit trail for rotations, syncs, and revocations.
+ */
+export const fluxSecretsAuditLog = pgTable("flux_secrets_audit_log", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    secretId: varchar("secret_id")
+        .references(() => fluxSecretsRegistry.id, { onDelete: "cascade" })
+        .notNull(),
+    action: fluxSecretsAuditActionEnum("action").notNull(),
+    performedBy: varchar("performed_by").notNull(),
+    details: jsonb("details").$type(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    secretIdx: index("flux_secrets_audit_log_secret_idx").on(table.secretId),
+    createdAtIdx: index("flux_secrets_audit_log_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// ENV MANAGER (App-centric env var tracking + completeness)
+// =============================================================================
+/**
+ * Registered applications. Each row maps to one `env-manifest.json` file.
+ * Stores the platform config and a hash of the last imported manifest so
+ * re-imports can detect drift.
+ */
+export const fluxEnvApps = pgTable("flux_envmanager_apps", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** URL-safe slug, matches the manifest's `app` field (e.g. "fn-flux"). */
+    slug: varchar("slug").notNull(),
+    /** Human-readable display name. */
+    name: varchar("name").notNull(),
+    /** Optional description from the manifest. */
+    description: varchar("description"),
+    /** Platform deployment configs keyed by platform slug. */
+    platforms: jsonb("platforms").$type(),
+    /** SHA-256 of the raw manifest JSON — used to skip no-op re-imports. */
+    manifestHash: varchar("manifest_hash"),
+    /** When the manifest was last successfully imported. */
+    manifestImportedAt: timestamp("manifest_imported_at"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    slugIdx: uniqueIndex("flux_envmanager_apps_slug_idx").on(table.slug),
+}));
+/**
+ * Many-to-many join between apps and secrets. Each row says "app X needs
+ * secret Y on platforms P with sensitivity S". The `why` column captures the
+ * app-specific justification from the manifest, distinct from the secret's
+ * own `description`.
+ */
+export const fluxEnvAppVars = pgTable("flux_envmanager_app_vars", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** The application that requires this secret. */
+    appId: varchar("app_id")
+        .references(() => fluxEnvApps.id, { onDelete: "cascade" })
+        .notNull(),
+    /** The secret being required. */
+    secretId: varchar("secret_id")
+        .references(() => fluxSecretsRegistry.id, { onDelete: "cascade" })
+        .notNull(),
+    /** Subset of the app's platforms that consume this var. */
+    platforms: jsonb("platforms").$type(),
+    /** Whether the app fails to start without this var. */
+    required: boolean("required").default(true).notNull(),
+    /** Whether the value is a secret (true) or a public config (false). */
+    sensitive: boolean("sensitive").default(true).notNull(),
+    /** Default value — only meaningful when sensitive=false. */
+    defaultValue: varchar("default_value"),
+    /** App-specific explanation from the manifest's `why` field. */
+    why: varchar("why"),
+    /** Optional OVH Secret Manager vault path override. Null = use default convention. */
+    vaultPath: varchar("vault_path"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    appIdx: index("flux_envmanager_app_vars_app_idx").on(table.appId),
+    secretIdx: index("flux_envmanager_app_vars_secret_idx").on(table.secretId),
+    appSecretIdx: uniqueIndex("flux_envmanager_app_vars_app_secret_idx").on(table.appId, table.secretId),
+}));
+// ---------------------------------------------------------------------------
+// Admin Settings (feature flags)
+// ---------------------------------------------------------------------------
+export const fluxAdminSettings = pgTable("flux_admin_settings", {
+    id: varchar("id").primaryKey().default(sql `gen_random_uuid()`),
+    key: text("key").notNull().unique(),
+    value: jsonb("value").notNull().default(false),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+    updatedBy: text("updated_by"),
+});
+// =============================================================================
+// RELATIONS
+// =============================================================================
+export const fluxUsersRelations = relations(fluxUsers, ({ many }) => ({
+    ownedProjects: many(fluxProjects, { relationName: "accountExecutive" }),
+    accountManagerProjects: many(fluxProjects, {
+        relationName: "accountManager",
+    }),
+    primaryProjects: many(fluxProjects, { relationName: "primaryStrategist" }),
+    secondaryProjects: many(fluxProjects, {
+        relationName: "secondaryStrategist",
+    }),
+    accountCoordinatorProjects: many(fluxProjects, {
+        relationName: "accountCoordinator",
+    }),
+    paidSearchSpecialistProjects: many(fluxProjects, {
+        relationName: "paidSearchSpecialist",
+    }),
+    subscriptions: many(fluxSubscriptions),
+    createdTemplates: many(fluxTeamTemplates),
+    auditLogs: many(fluxAuditLog),
+    assignedTasks: many(fluxTasks, { relationName: "taskAssignee" }),
+    createdTasks: many(fluxTasks, { relationName: "taskCreator" }),
+    updatedBudgets: many(fluxBudgets),
+}));
+export const fluxProjectsRelations = relations(fluxProjects, ({ one, many }) => ({
+    parentProject: one(fluxProjects, {
+        fields: [fluxProjects.parentProjectId],
+        references: [fluxProjects.id],
+        relationName: "projectHierarchy",
+    }),
+    childProjects: many(fluxProjects, {
+        relationName: "projectHierarchy",
+    }),
+    accountExecutive: one(fluxUsers, {
+        fields: [fluxProjects.accountExecutiveId],
+        references: [fluxUsers.id],
+        relationName: "accountExecutive",
+    }),
+    accountManager: one(fluxUsers, {
+        fields: [fluxProjects.accountManagerId],
+        references: [fluxUsers.id],
+        relationName: "accountManager",
+    }),
+    primaryStrategist: one(fluxUsers, {
+        fields: [fluxProjects.primaryStrategistId],
+        references: [fluxUsers.id],
+        relationName: "primaryStrategist",
+    }),
+    secondaryStrategist: one(fluxUsers, {
+        fields: [fluxProjects.secondaryStrategistId],
+        references: [fluxUsers.id],
+        relationName: "secondaryStrategist",
+    }),
+    accountCoordinator: one(fluxUsers, {
+        fields: [fluxProjects.accountCoordinatorId],
+        references: [fluxUsers.id],
+        relationName: "accountCoordinator",
+    }),
+    paidSearchSpecialist: one(fluxUsers, {
+        fields: [fluxProjects.paidSearchSpecialistId],
+        references: [fluxUsers.id],
+        relationName: "paidSearchSpecialist",
+    }),
+    subscriptions: many(fluxSubscriptions),
+    emailThreads: many(fluxEmailThreads),
+    activityItems: many(fluxActivityItems),
+    alertRules: many(fluxAlertRules),
+    alerts: many(fluxAlerts),
+    embeddedDashboards: many(fluxEmbeddedDashboards),
+    budgets: many(fluxBudgets),
+    tasks: many(fluxTasks),
+    escalation: many(fluxProjectEscalations),
+    escalationHistory: many(fluxProjectEscalationHistory),
+}));
+export const fluxTeamTemplatesRelations = relations(fluxTeamTemplates, ({ one, many }) => ({
+    createdBy: one(fluxUsers, {
+        fields: [fluxTeamTemplates.createdById],
+        references: [fluxUsers.id],
+    }),
+    members: many(fluxTeamTemplateMembers),
+}));
+export const fluxTeamTemplateMembersRelations = relations(fluxTeamTemplateMembers, ({ one }) => ({
+    template: one(fluxTeamTemplates, {
+        fields: [fluxTeamTemplateMembers.templateId],
+        references: [fluxTeamTemplates.id],
+    }),
+    user: one(fluxUsers, {
+        fields: [fluxTeamTemplateMembers.userId],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxSubscriptionsRelations = relations(fluxSubscriptions, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxSubscriptions.projectId],
+        references: [fluxProjects.id],
+    }),
+    user: one(fluxUsers, {
+        fields: [fluxSubscriptions.userId],
+        references: [fluxUsers.id],
+    }),
+    invitedBy: one(fluxUsers, {
+        fields: [fluxSubscriptions.invitedById],
+        references: [fluxUsers.id],
+    }),
+    appliedTemplate: one(fluxTeamTemplates, {
+        fields: [fluxSubscriptions.appliedTemplateId],
+        references: [fluxTeamTemplates.id],
+    }),
+}));
+export const fluxEmailThreadsRelations = relations(fluxEmailThreads, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxEmailThreads.projectId],
+        references: [fluxProjects.id],
+    }),
+    reviewedBy: one(fluxUsers, {
+        fields: [fluxEmailThreads.reviewedById],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxActivityItemsRelations = relations(fluxActivityItems, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxActivityItems.projectId],
+        references: [fluxProjects.id],
+    }),
+}));
+export const fluxAlertRulesRelations = relations(fluxAlertRules, ({ one, many }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxAlertRules.projectId],
+        references: [fluxProjects.id],
+    }),
+    createdBy: one(fluxUsers, {
+        fields: [fluxAlertRules.createdById],
+        references: [fluxUsers.id],
+    }),
+    alerts: many(fluxAlerts),
+}));
+export const fluxAlertsRelations = relations(fluxAlerts, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxAlerts.projectId],
+        references: [fluxProjects.id],
+    }),
+    rule: one(fluxAlertRules, {
+        fields: [fluxAlerts.ruleId],
+        references: [fluxAlertRules.id],
+    }),
+    acknowledgedBy: one(fluxUsers, {
+        fields: [fluxAlerts.acknowledgedById],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxProjectEscalationsRelations = relations(fluxProjectEscalations, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxProjectEscalations.projectId],
+        references: [fluxProjects.id],
+    }),
+    updatedBy: one(fluxUsers, {
+        fields: [fluxProjectEscalations.updatedById],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxProjectEscalationHistoryRelations = relations(fluxProjectEscalationHistory, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxProjectEscalationHistory.projectId],
+        references: [fluxProjects.id],
+    }),
+    changedBy: one(fluxUsers, {
+        fields: [fluxProjectEscalationHistory.changedById],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxEmbeddedDashboardsRelations = relations(fluxEmbeddedDashboards, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxEmbeddedDashboards.projectId],
+        references: [fluxProjects.id],
+    }),
+}));
+export const fluxAuditLogRelations = relations(fluxAuditLog, ({ one }) => ({
+    user: one(fluxUsers, {
+        fields: [fluxAuditLog.userId],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxStrategistEventsRelations = relations(fluxStrategistEvents, ({ one }) => ({
+    user: one(fluxUsers, {
+        fields: [fluxStrategistEvents.userId],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxBudgetsRelations = relations(fluxBudgets, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxBudgets.projectId],
+        references: [fluxProjects.id],
+    }),
+    updatedBy: one(fluxUsers, {
+        fields: [fluxBudgets.updatedById],
+        references: [fluxUsers.id],
+    }),
+}));
+export const fluxTasksRelations = relations(fluxTasks, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxTasks.projectId],
+        references: [fluxProjects.id],
+    }),
+    assignee: one(fluxUsers, {
+        fields: [fluxTasks.assigneeId],
+        references: [fluxUsers.id],
+        relationName: "taskAssignee",
+    }),
+    createdBy: one(fluxUsers, {
+        fields: [fluxTasks.createdById],
+        references: [fluxUsers.id],
+        relationName: "taskCreator",
+    }),
+    blockedBy: one(fluxTasks, {
+        fields: [fluxTasks.blockedByTaskId],
+        references: [fluxTasks.id],
+        relationName: "taskBlockedBy",
+    }),
+}));
+export const fluxSecretsProvidersRelations = relations(fluxSecretsProviders, ({ many }) => ({
+    secrets: many(fluxSecretsRegistry),
+}));
+export const fluxSecretsRegistryRelations = relations(fluxSecretsRegistry, ({ one, many }) => ({
+    provider: one(fluxSecretsProviders, {
+        fields: [fluxSecretsRegistry.providerId],
+        references: [fluxSecretsProviders.id],
+    }),
+    deployments: many(fluxSecretsDeployments),
+    auditLog: many(fluxSecretsAuditLog),
+    appVars: many(fluxEnvAppVars),
+}));
+export const fluxSecretsDeploymentsRelations = relations(fluxSecretsDeployments, ({ one }) => ({
+    secret: one(fluxSecretsRegistry, {
+        fields: [fluxSecretsDeployments.secretId],
+        references: [fluxSecretsRegistry.id],
+    }),
+    app: one(fluxEnvApps, {
+        fields: [fluxSecretsDeployments.appId],
+        references: [fluxEnvApps.id],
+    }),
+}));
+export const fluxSecretsVaultRelations = relations(fluxSecretsVault, () => ({}));
+export const fluxSecretsAuditLogRelations = relations(fluxSecretsAuditLog, ({ one }) => ({
+    secret: one(fluxSecretsRegistry, {
+        fields: [fluxSecretsAuditLog.secretId],
+        references: [fluxSecretsRegistry.id],
+    }),
+}));
+export const fluxEnvAppsRelations = relations(fluxEnvApps, ({ many }) => ({
+    appVars: many(fluxEnvAppVars),
+}));
+export const fluxEnvAppVarsRelations = relations(fluxEnvAppVars, ({ one }) => ({
+    app: one(fluxEnvApps, {
+        fields: [fluxEnvAppVars.appId],
+        references: [fluxEnvApps.id],
+    }),
+    secret: one(fluxSecretsRegistry, {
+        fields: [fluxEnvAppVars.secretId],
+        references: [fluxSecretsRegistry.id],
+    }),
+}));
+// =============================================================================
+// BRAND NARRATIVES — Team-level messaging baselines for drift detection
+// =============================================================================
+export const fluxSentinelTeamEnum = pgEnum("flux_sentinel_team", [
+    "pr_comms",
+    "newsroom",
+    "agency",
+    "philanthropy",
+    "audience",
+]);
+// =============================================================================
+// SENTINEL CAMPAIGNS — Group keywords by PR initiative
+// =============================================================================
+export const fluxSentinelCampaigns = pgTable("flux_sentinel_campaigns", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    description: text("description"),
+    startDate: timestamp("start_date", { withTimezone: true }),
+    endDate: timestamp("end_date", { withTimezone: true }),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    activeIdx: index("flux_sentinel_campaigns_active_idx").on(table.isActive),
+    nameIdx: index("flux_sentinel_campaigns_name_idx").on(table.name),
+}));
+// =============================================================================
+// SENTINEL KEY MESSAGES — Trackable messages for pull-through measurement
+// =============================================================================
+export const fluxSentinelMessages = pgTable("flux_sentinel_messages", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    team: fluxSentinelTeamEnum("team"),
+    label: text("label").notNull(),
+    description: text("description"),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    activeIdx: index("flux_sentinel_messages_active_idx").on(table.isActive),
+    teamIdx: index("flux_sentinel_messages_team_idx").on(table.team),
+}));
+export const fluxBrandNarratives = pgTable("flux_brand_narratives", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    team: fluxSentinelTeamEnum("team").notNull(),
+    narrative: text("narrative").notNull(),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    teamIdx: index("flux_brand_narratives_team_idx").on(table.team),
+    activeIdx: index("flux_brand_narratives_active_idx").on(table.isActive),
+}));
+// =============================================================================
+// SENTINEL DIGEST REPORTS — Shareable pre-computed digests
+// =============================================================================
+export const fluxSentinelDigestReports = pgTable("flux_sentinel_digest_reports", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    shareToken: text("share_token").notNull().unique(),
+    period: text("period").notNull(),
+    generatedAt: timestamp("generated_at", { withTimezone: true }).defaultNow().notNull(),
+    dateFrom: timestamp("date_from", { withTimezone: true }).notNull(),
+    dateTo: timestamp("date_to", { withTimezone: true }).notNull(),
+    reportData: jsonb("report_data").notNull().$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+    shareTokenIdx: uniqueIndex("flux_sentinel_digest_reports_token_idx").on(table.shareToken),
+    generatedAtIdx: index("flux_sentinel_digest_reports_generated_at_idx").on(table.generatedAt),
+}));
+// =============================================================================
+// DONOR SENTINEL — Philanthropy Prospect Discovery & Qualification
+// =============================================================================
+export const fluxDonorLeadStageEnum = pgEnum("flux_donor_lead_stage", [
+    "discovered",
+    "researching",
+    "qualified",
+    "priority",
+    "archived",
+]);
+export const fluxDonorEntityTypeEnum = pgEnum("flux_donor_entity_type", [
+    "foundation",
+    "individual",
+    "corporate",
+    "daf",
+]);
+export const fluxDonorSignalTypeEnum = pgEnum("flux_donor_signal_type", [
+    "grant_announcement",
+    "leadership_change",
+    "rfi",
+    "board_appointment",
+    "mission_statement",
+    "donation",
+    "partnership",
+    "general",
+]);
+/**
+ * Donor prospects — entity-centric records consolidating multiple signals.
+ * One person/org across many articles = one prospect.
+ */
+export const fluxDonorProspects = pgTable("flux_donor_prospects", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    entityType: fluxDonorEntityTypeEnum("entity_type"),
+    website: text("website"),
+    location: text("location"),
+    focusAreas: text("focus_areas")
+        .array()
+        .default(sql `'{}'::text[]`)
+        .notNull(),
+    leadStage: fluxDonorLeadStageEnum("lead_stage")
+        .default("discovered")
+        .notNull(),
+    score: integer("score").default(0).notNull(),
+    scoreFactors: jsonb("score_factors")
+        .default({})
+        .$type(),
+    notes: text("notes"),
+    contactEmail: text("contact_email"),
+    contactPhone: text("contact_phone"),
+    linkedinUrl: text("linkedin_url"),
+    slackChannelId: text("slack_channel_id"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    nameIdx: index("flux_donor_prospects_name_idx").on(table.name),
+    leadStageIdx: index("flux_donor_prospects_lead_stage_idx").on(table.leadStage),
+    scoreIdx: index("flux_donor_prospects_score_idx").on(table.score),
+    entityTypeIdx: index("flux_donor_prospects_entity_type_idx").on(table.entityType),
+    createdAtIdx: index("flux_donor_prospects_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Donor signals — article/evidence records linking to prospects.
+ * Mirrors flux_media_mentions shape but with donor-specific fields.
+ */
+export const fluxDonorSignals = pgTable("flux_donor_signals", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    prospectId: text("prospect_id").references(() => fluxDonorProspects.id, {
+        onDelete: "set null",
+    }),
+    keywordId: text("keyword_id")
+        .references(() => fluxSentinelKeywords.id, { onDelete: "cascade" })
+        .notNull(),
+    url: text("url").notNull().unique(),
+    title: text("title").notNull(),
+    author: text("author"),
+    publishedAt: timestamp("published_at", { withTimezone: true }),
+    sourceDomain: text("source_domain"),
+    snippet: text("snippet"),
+    sourceType: text("source_type").default("article").notNull(),
+    signalType: fluxDonorSignalTypeEnum("signal_type")
+        .default("general")
+        .notNull(),
+    relevanceScore: real("relevance_score"),
+    analysisRationale: text("analysis_rationale"),
+    suggestedAction: text("suggested_action"),
+    sentiment: real("sentiment"),
+    extractedEntities: jsonb("extracted_entities")
+        .default([])
+        .$type(),
+    slackMessageTs: text("slack_message_ts"),
+    notifiedAt: timestamp("notified_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    urlIdx: uniqueIndex("flux_donor_signals_url_idx").on(table.url),
+    prospectIdx: index("flux_donor_signals_prospect_idx").on(table.prospectId),
+    keywordIdx: index("flux_donor_signals_keyword_idx").on(table.keywordId),
+    signalTypeIdx: index("flux_donor_signals_signal_type_idx").on(table.signalType),
+    createdAtIdx: index("flux_donor_signals_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Donor scan run log — tracks each donor pipeline cycle for observability.
+ */
+export const fluxDonorScanRuns = pgTable("flux_donor_scan_runs", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    runAt: timestamp("run_at", { withTimezone: true }).defaultNow().notNull(),
+    triggeredBy: text("triggered_by").notNull(),
+    keywordsScanned: integer("keywords_scanned").default(0).notNull(),
+    signalsFound: integer("signals_found").default(0).notNull(),
+    signalsNew: integer("signals_new").default(0).notNull(),
+    prospectsCreated: integer("prospects_created").default(0).notNull(),
+    alertsSent: integer("alerts_sent").default(0).notNull(),
+    durationMs: integer("duration_ms"),
+    error: text("error"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    runAtIdx: index("flux_donor_scan_runs_run_at_idx").on(table.runAt),
+}));
+// Donor relations
+export const fluxDonorProspectsRelations = relations(fluxDonorProspects, ({ many }) => ({
+    signals: many(fluxDonorSignals),
+}));
+export const fluxDonorSignalsRelations = relations(fluxDonorSignals, ({ one }) => ({
+    prospect: one(fluxDonorProspects, {
+        fields: [fluxDonorSignals.prospectId],
+        references: [fluxDonorProspects.id],
+    }),
+    keyword: one(fluxSentinelKeywords, {
+        fields: [fluxDonorSignals.keywordId],
+        references: [fluxSentinelKeywords.id],
+    }),
+}));
+// =============================================================================
+// LEGACY EVENT INGEST (tracking table for events from Compass)
+// =============================================================================
+export const fluxLegacyEventIngest = pgTable("flux_legacy_event_ingest", {
+    id: text("id").primaryKey(),
+    eventId: text("event_id").notNull(),
+    eventType: text("event_type").notNull(),
+    idempotencyKey: text("idempotency_key").notNull().unique(),
+    emittedAt: timestamp("emitted_at", { withTimezone: true }).notNull(),
+    actorUserId: text("actor_user_id"),
+    actorUsername: text("actor_username"),
+    payload: jsonb("payload").notNull(),
+    receivedAt: timestamp("received_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    typeTimeIdx: index("idx_flux_legacy_event_ingest_type_time").on(table.eventType, table.emittedAt),
+}));
+// =============================================================================
+// COMPASS SNAPSHOTS (Projected state from Compass events)
+// =============================================================================
+export const fluxCompassOrderStatusEnum = pgEnum("flux_compass_order_status", [
+    "draft",
+    "pending_approval",
+    "approved",
+    "sent",
+    "active",
+    "completed",
+]);
+export const fluxCompassHoldStatusEnum = pgEnum("flux_compass_hold_status", [
+    "tentative",
+    "confirmed",
+    "released",
+    "expired",
+]);
+/**
+ * Current state of all Compass media orders.
+ * Upserted on every order.created / order.status_changed event.
+ */
+export const fluxCompassOrderSnapshots = pgTable("flux_compass_order_snapshots", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    compassOrderId: text("compass_order_id").notNull().unique(),
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "set null",
+    }),
+    hubspotDealId: text("hubspot_deal_id"),
+    hubspotCompanyId: text("hubspot_company_id"),
+    clientName: text("client_name"),
+    status: fluxCompassOrderStatusEnum("status").default("draft").notNull(),
+    totalInvestment: numeric("total_investment"),
+    ownerEmail: text("owner_email"),
+    ownerName: text("owner_name"),
+    lastStatusChangeAt: timestamp("last_status_change_at", {
+        withTimezone: true,
+    }),
+    lastEventAt: timestamp("last_event_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    compassOrderIdx: uniqueIndex("flux_compass_order_snapshots_order_idx").on(table.compassOrderId),
+    projectIdx: index("flux_compass_order_snapshots_project_idx").on(table.projectId),
+    statusIdx: index("flux_compass_order_snapshots_status_idx").on(table.status),
+    ownerIdx: index("flux_compass_order_snapshots_owner_idx").on(table.ownerEmail),
+}));
+/**
+ * Current state of Compass inventory holds.
+ * Upserted on every hold.created / hold.confirmed / hold.released event.
+ */
+export const fluxCompassHoldSnapshots = pgTable("flux_compass_hold_snapshots", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    compassHoldId: text("compass_hold_id").notNull().unique(),
+    compassOrderId: text("compass_order_id"),
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "set null",
+    }),
+    productId: text("product_id"),
+    holdDate: date("hold_date"),
+    holdEndDate: date("hold_end_date"),
+    status: fluxCompassHoldStatusEnum("status").default("tentative").notNull(),
+    clientName: text("client_name"),
+    lastEventAt: timestamp("last_event_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    compassHoldIdx: uniqueIndex("flux_compass_hold_snapshots_hold_idx").on(table.compassHoldId),
+    orderIdx: index("flux_compass_hold_snapshots_order_idx").on(table.compassOrderId),
+    statusIdx: index("flux_compass_hold_snapshots_status_idx").on(table.status),
+}));
+// =============================================================================
+// DELIVERY MONITORING (GAM Campaign Delivery Tracking)
+// =============================================================================
+export const fluxDeliveryReportConfig = pgTable("flux_delivery_report_config", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    enabled: boolean("enabled").default(true).notNull(),
+    scheduleCadence: text("schedule_cadence").default("daily").notNull(),
+    scheduleTimeUtc: time("schedule_time_utc").default("08:00:00").notNull(),
+    scheduleDays: integer("schedule_days").array(),
+    warningThresholdPercent: numeric("warning_threshold_percent")
+        .default("85")
+        .notNull(),
+    criticalThresholdPercent: numeric("critical_threshold_percent")
+        .default("70")
+        .notNull(),
+    daysUntilEndEscalate: integer("days_until_end_escalate").default(7).notNull(),
+    campaignTagFilters: text("campaign_tag_filters").array(),
+    advertiserNamePatterns: text("advertiser_name_patterns").array(),
+    minBudgetFilter: numeric("min_budget_filter"),
+    emailRecipients: text("email_recipients").array(),
+    slackChannel: text("slack_channel").default("").notNull(),
+    slackChannelId: text("slack_channel_id"),
+    emailFormat: text("email_format").default("csv").notNull(),
+    includeRecommendations: boolean("include_recommendations")
+        .default(true)
+        .notNull(),
+    hubspotDealCustomField: text("hubspot_deal_custom_field"),
+    fallbackNameMatching: boolean("fallback_name_matching")
+        .default(true)
+        .notNull(),
+    postMortemGoalPercent: numeric("post_mortem_goal_percent").default("95"),
+    endingSoonDays: integer("ending_soon_days").default(7),
+    endingThisMonthDays: integer("ending_this_month_days").default(14),
+    recentlyEndedDays: integer("recently_ended_days").default(14),
+    dmEscalationThreshold: text("dm_escalation_threshold").default("critical"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+});
+export const fluxDeliveryReports = pgTable("flux_delivery_reports", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    runAt: timestamp("run_at", { withTimezone: true }).defaultNow().notNull(),
+    triggeredBy: text("triggered_by").notNull(),
+    totalCampaigns: integer("total_campaigns").default(0).notNull(),
+    atRiskCount: integer("at_risk_count").default(0).notNull(),
+    criticalCount: integer("critical_count").default(0).notNull(),
+    postMortemCount: integer("post_mortem_count").default(0).notNull(),
+    configSnapshot: jsonb("config_snapshot"),
+    errorMessage: text("error_message"),
+    status: text("status").default("success").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    runAtIdx: index("idx_flux_delivery_reports_run_at").on(table.runAt),
+}));
+export const fluxDeliveryLineItems = pgTable("flux_delivery_line_items", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    reportId: text("report_id")
+        .references(() => fluxDeliveryReports.id, { onDelete: "cascade" })
+        .notNull(),
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "set null",
+    }),
+    gamOrderId: text("gam_order_id").notNull(),
+    gamLineItemId: text("gam_line_item_id").notNull(),
+    advertiserName: text("advertiser_name").notNull(),
+    lineItemName: text("line_item_name").notNull(),
+    orderName: text("order_name").notNull(),
+    impressionsContracted: bigint("impressions_contracted", { mode: "number" })
+        .notNull(),
+    impressionsDelivered: bigint("impressions_delivered", { mode: "number" })
+        .notNull(),
+    deliveryPercent: numeric("delivery_percent").notNull(),
+    startDate: date("start_date").notNull(),
+    endDate: date("end_date").notNull(),
+    daysRemaining: integer("days_remaining"),
+    riskLevel: text("risk_level"),
+    recommendedAction: text("recommended_action"),
+    mappingMethod: text("mapping_method"),
+    mappingConfidence: numeric("mapping_confidence"),
+    timeHorizon: text("time_horizon"),
+    postMortemStatus: text("post_mortem_status"),
+    ownerUserId: text("owner_user_id"),
+    ownerSlackId: text("owner_slack_id"),
+    ownerName: text("owner_name"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    reportIdx: index("idx_flux_delivery_line_items_report").on(table.reportId),
+    projectIdx: index("idx_flux_delivery_line_items_project").on(table.projectId),
+    riskIdx: index("idx_flux_delivery_line_items_risk").on(table.riskLevel),
+    uniqueLineItem: uniqueIndex("flux_delivery_line_items_unique").on(table.reportId, table.gamLineItemId),
+}));
+export const fluxDeliveryProjectMappings = pgTable("flux_delivery_project_mappings", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    advertiserNamePattern: text("advertiser_name_pattern").notNull().unique(),
+    projectId: text("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    createdBy: text("created_by").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+});
+// =============================================================================
+// ZIP TARGETING (ZIP radius resolution + platform export)
+// =============================================================================
+/** US ZIP centroid reference data used for radius resolution. */
+export const fluxZipGeo = pgTable("flux_zip_geo", {
+    zip: text("zip").primaryKey(),
+    lat: numeric("lat", { precision: 10, scale: 6 }).notNull(),
+    lng: numeric("lng", { precision: 10, scale: 6 }).notNull(),
+    city: text("city"),
+    state: text("state"),
+    countryCode: text("country_code").default("US").notNull(),
+    population: integer("population"),
+    households: integer("households"),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    stateIdx: index("flux_zip_geo_state_idx").on(table.state),
+    countryIdx: index("flux_zip_geo_country_idx").on(table.countryCode),
+}));
+/** Google geo-target constants for ZIP/postal code exports. */
+export const fluxGoogleGeoTargets = pgTable("flux_google_geo_targets", {
+    criterionId: text("criterion_id").primaryKey(),
+    resourceName: text("resource_name"),
+    targetType: text("target_type"),
+    canonicalName: text("canonical_name"),
+    postalCode: text("postal_code"),
+    countryCode: text("country_code").default("US").notNull(),
+    status: text("status"),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    postalIdx: index("flux_google_geo_targets_postal_idx").on(table.postalCode, table.countryCode),
+    statusIdx: index("flux_google_geo_targets_status_idx").on(table.status),
+}));
+/** Saved ZIP radius target sets by project/ticket. */
+export const fluxZipTargetSets = pgTable("flux_zip_target_sets", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    projectId: text("project_id")
+        .references(() => fluxProjects.id, { onDelete: "cascade" })
+        .notNull(),
+    fulfillmentTicketId: text("fulfillment_ticket_id").references(() => fluxFulfillmentTickets.id, { onDelete: "set null" }),
+    mode: text("mode").notNull().default("radius"),
+    label: text("label"),
+    centerZip: text("center_zip").notNull(),
+    radiusMiles: numeric("radius_miles", { precision: 8, scale: 2 }).notNull(),
+    centerLat: numeric("center_lat", { precision: 10, scale: 6 }).notNull(),
+    centerLng: numeric("center_lng", { precision: 10, scale: 6 }).notNull(),
+    zipCount: integer("zip_count").notNull(),
+    zipCodes: jsonb("zip_codes").$type().notNull(),
+    boundaryGeoJson: jsonb("boundary_geojson"),
+    createdById: text("created_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    isActive: boolean("is_active").default(true).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    projectIdx: index("flux_zip_target_sets_project_idx").on(table.projectId),
+    ticketIdx: index("flux_zip_target_sets_ticket_idx").on(table.fulfillmentTicketId),
+    createdAtIdx: index("flux_zip_target_sets_created_at_idx").on(table.createdAt),
+}));
+/** Export history for auditability. */
+export const fluxZipTargetExports = pgTable("flux_zip_target_exports", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    targetSetId: text("target_set_id")
+        .references(() => fluxZipTargetSets.id, { onDelete: "cascade" })
+        .notNull(),
+    platform: text("platform").notNull(),
+    rowCount: integer("row_count").notNull(),
+    exportedById: text("exported_by_id")
+        .references(() => fluxUsers.id)
+        .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    targetSetIdx: index("flux_zip_target_exports_target_set_idx").on(table.targetSetId),
+    platformIdx: index("flux_zip_target_exports_platform_idx").on(table.platform),
+    createdAtIdx: index("flux_zip_target_exports_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// SENTINEL INVITES — Invite-only access for sentinel-only users
+// =============================================================================
+export const fluxSentinelInvites = pgTable("flux_sentinel_invites", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    email: varchar("email", { length: 255 }).notNull(),
+    invitedBy: varchar("invited_by").references(() => fluxUsers.id),
+    token: varchar("token", { length: 64 }).notNull().unique(),
+    acceptedAt: timestamp("accepted_at"),
+    expiresAt: timestamp("expires_at")
+        .notNull()
+        .default(sql `NOW() + INTERVAL '7 days'`),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+}, (table) => ({
+    tokenIdx: index("idx_sentinel_invites_token").on(table.token),
+    emailIdx: index("idx_sentinel_invites_email").on(table.email),
+}));
+export const fluxSentinelInvitesRelations = relations(fluxSentinelInvites, ({ one }) => ({
+    inviter: one(fluxUsers, {
+        fields: [fluxSentinelInvites.invitedBy],
+        references: [fluxUsers.id],
+    }),
+}));
+// =============================================================================
+// PR SENTINEL — Media Monitoring & Crisis Detection
+// =============================================================================
+export const fluxSentinelSeverityEnum = pgEnum("flux_sentinel_severity", [
+    "routine",
+    "notable",
+    "urgent",
+    "crisis",
+]);
+/**
+ * Configurable search keywords/topics for the PR Sentinel.
+ * Each keyword group can target specific Slack channels for alerts.
+ */
+export const fluxSentinelKeywords = pgTable("flux_sentinel_keywords", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    label: text("label").notNull(),
+    query: text("query").notNull(),
+    isActive: boolean("is_active").default(true).notNull(),
+    searchSocial: boolean("search_social").default(false).notNull(),
+    socialPlatforms: text("social_platforms")
+        .array()
+        .default(sql `'{}'::text[]`)
+        .notNull(),
+    slackChannelId: text("slack_channel_id"),
+    team: fluxSentinelTeamEnum("team"),
+    /** Keyword role: self (brand), competitor, or topic */
+    keywordRole: text("keyword_role").default("self").notNull(),
+    /** For competitor keywords — the competitor's name */
+    competitorName: text("competitor_name"),
+    /** Optional campaign grouping */
+    campaignId: text("campaign_id").references(() => fluxSentinelCampaigns.id, {
+        onDelete: "set null",
+    }),
+    /** Trigify workflow configuration tracking */
+    trigifyConfigured: boolean("trigify_configured").default(false).notNull(),
+    trigifyConfiguredAt: timestamp("trigify_configured_at", { withTimezone: true }),
+    trigifyConfiguredBy: text("trigify_configured_by"),
+    /** AI-generated Trigify query: { andKeywords, orKeywords, notKeywords, goal, platform, generatedFrom } */
+    trigifyQuery: jsonb("trigify_query"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    activeIdx: index("flux_sentinel_keywords_active_idx").on(table.isActive),
+    roleIdx: index("flux_sentinel_keywords_role_idx").on(table.keywordRole),
+}));
+/**
+ * Discovered media mentions. Deduplication by URL.
+ * Stores Exa search results with LLM-derived severity classification.
+ */
+export const fluxMediaMentions = pgTable("flux_media_mentions", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    keywordId: text("keyword_id")
+        .references(() => fluxSentinelKeywords.id, { onDelete: "cascade" })
+        .notNull(),
+    url: text("url").notNull().unique(),
+    title: text("title").notNull(),
+    author: text("author"),
+    publishedAt: timestamp("published_at", { withTimezone: true }),
+    sourceDomain: text("source_domain"),
+    snippet: text("snippet"),
+    severity: fluxSentinelSeverityEnum("severity").default("routine").notNull(),
+    analysisRationale: text("analysis_rationale"),
+    suggestedAction: text("suggested_action"),
+    isMisinformation: boolean("is_misinformation").default(false).notNull(),
+    sentiment: real("sentiment"),
+    sourceType: text("source_type").default("article").notNull(),
+    thumbnailUrl: text("thumbnail_url"),
+    thumbnailCredit: text("thumbnail_credit"),
+    narrativeDrift: boolean("narrative_drift").default(false).notNull(),
+    driftSummary: text("drift_summary"),
+    slackMessageTs: text("slack_message_ts"),
+    notifiedAt: timestamp("notified_at", { withTimezone: true }),
+    /** Per-article message pull-through scores from LLM analysis */
+    messageScores: jsonb("message_scores").$type(),
+    /** Social engagement metrics from Trigify (likes, comments, shares, views) */
+    engagement: jsonb("engagement").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    urlIdx: uniqueIndex("flux_media_mentions_url_idx").on(table.url),
+    keywordIdx: index("flux_media_mentions_keyword_idx").on(table.keywordId),
+    severityIdx: index("flux_media_mentions_severity_idx").on(table.severity),
+    sourceTypeIdx: index("flux_media_mentions_source_type_idx").on(table.sourceType),
+    createdAtIdx: index("flux_media_mentions_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Cached journalist contact info from Hunter.io lookups.
+ * Avoids redundant API calls for known journalists.
+ */
+export const fluxJournalistContacts = pgTable("flux_journalist_contacts", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    email: text("email"),
+    domain: text("domain"),
+    twitterHandle: text("twitter_handle"),
+    linkedinUrl: text("linkedin_url"),
+    confidence: integer("confidence"),
+    lastVerifiedAt: timestamp("last_verified_at", { withTimezone: true }),
+    twitterFollowers: integer("twitter_followers"),
+    twitterBio: text("twitter_bio"),
+    twitterVerified: boolean("twitter_verified"),
+    twitterProfileImage: text("twitter_profile_image"),
+    socialEnrichedAt: timestamp("social_enriched_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    nameIdx: index("flux_journalist_contacts_name_idx").on(table.name),
+    domainIdx: index("flux_journalist_contacts_domain_idx").on(table.domain),
+    nameDomainUnique: uniqueIndex("flux_journalist_contacts_name_domain_idx").on(table.name, table.domain),
+}));
+/**
+ * Sentinel run log — tracks each scan cycle for observability.
+ */
+export const fluxSentinelRuns = pgTable("flux_sentinel_runs", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    runAt: timestamp("run_at", { withTimezone: true }).defaultNow().notNull(),
+    triggeredBy: text("triggered_by").notNull(),
+    keywordsScanned: integer("keywords_scanned").default(0).notNull(),
+    mentionsFound: integer("mentions_found").default(0).notNull(),
+    mentionsNew: integer("mentions_new").default(0).notNull(),
+    alertsSent: integer("alerts_sent").default(0).notNull(),
+    errorMessage: text("error_message"),
+    durationMs: integer("duration_ms"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    runAtIdx: index("flux_sentinel_runs_run_at_idx").on(table.runAt),
+}));
+// Sentinel relations
+export const fluxSentinelKeywordsRelations = relations(fluxSentinelKeywords, ({ one, many }) => ({
+    mentions: many(fluxMediaMentions),
+    donorSignals: many(fluxDonorSignals),
+    campaign: one(fluxSentinelCampaigns, {
+        fields: [fluxSentinelKeywords.campaignId],
+        references: [fluxSentinelCampaigns.id],
+    }),
+}));
+export const fluxSentinelCampaignsRelations = relations(fluxSentinelCampaigns, ({ many }) => ({
+    keywords: many(fluxSentinelKeywords),
+}));
+// =============================================================================
+// SENTINEL INCIDENTS — Escalation & Response Tracking
+// =============================================================================
+export const fluxSentinelIncidentStatusEnum = pgEnum("flux_sentinel_incident_status", ["new", "investigating", "responding", "resolved", "closed"]);
+export const fluxSentinelIncidentPriorityEnum = pgEnum("flux_sentinel_incident_priority", ["low", "medium", "high", "critical"]);
+/**
+ * Sentinel incidents — escalated media mentions tracked as response efforts.
+ */
+export const fluxSentinelIncidents = pgTable("flux_sentinel_incidents", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    mentionId: text("mention_id").references(() => fluxMediaMentions.id, {
+        onDelete: "set null",
+    }),
+    title: text("title").notNull(),
+    status: fluxSentinelIncidentStatusEnum("status").default("new").notNull(),
+    priority: fluxSentinelIncidentPriorityEnum("priority")
+        .default("medium")
+        .notNull(),
+    ownerSlackId: text("owner_slack_id"),
+    ownerName: text("owner_name"),
+    notes: text("notes"),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTs: text("slack_message_ts"),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    closedAt: timestamp("closed_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    mentionIdx: index("flux_sentinel_incidents_mention_idx").on(table.mentionId),
+    statusIdx: index("flux_sentinel_incidents_status_idx").on(table.status),
+    priorityIdx: index("flux_sentinel_incidents_priority_idx").on(table.priority),
+    createdAtIdx: index("flux_sentinel_incidents_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Incident tasks — checklist items for tracking response actions.
+ */
+export const fluxSentinelIncidentTasks = pgTable("flux_sentinel_incident_tasks", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    incidentId: text("incident_id")
+        .notNull()
+        .references(() => fluxSentinelIncidents.id, { onDelete: "cascade" }),
+    title: text("title").notNull(),
+    assigneeName: text("assignee_name"),
+    dueDate: timestamp("due_date", { withTimezone: true }),
+    isComplete: boolean("is_complete").default(false).notNull(),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    displayOrder: integer("display_order").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    incidentIdx: index("flux_sentinel_incident_tasks_incident_idx").on(table.incidentId),
+    completeIdx: index("flux_sentinel_incident_tasks_complete_idx").on(table.isComplete),
+}));
+/**
+ * Incident activity log — audit trail for all incident actions.
+ */
+export const fluxSentinelIncidentActivity = pgTable("flux_sentinel_incident_activity", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    incidentId: text("incident_id")
+        .notNull()
+        .references(() => fluxSentinelIncidents.id, { onDelete: "cascade" }),
+    action: text("action").notNull(),
+    actorName: text("actor_name"),
+    details: jsonb("details"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    incidentIdx: index("flux_sentinel_incident_activity_incident_idx").on(table.incidentId),
+    createdAtIdx: index("flux_sentinel_incident_activity_created_at_idx").on(table.createdAt),
+}));
+// Sentinel incident relations
+export const fluxSentinelIncidentsRelations = relations(fluxSentinelIncidents, ({ one, many }) => ({
+    mention: one(fluxMediaMentions, {
+        fields: [fluxSentinelIncidents.mentionId],
+        references: [fluxMediaMentions.id],
+    }),
+    tasks: many(fluxSentinelIncidentTasks),
+    activity: many(fluxSentinelIncidentActivity),
+}));
+export const fluxSentinelIncidentTasksRelations = relations(fluxSentinelIncidentTasks, ({ one }) => ({
+    incident: one(fluxSentinelIncidents, {
+        fields: [fluxSentinelIncidentTasks.incidentId],
+        references: [fluxSentinelIncidents.id],
+    }),
+}));
+export const fluxSentinelIncidentActivityRelations = relations(fluxSentinelIncidentActivity, ({ one }) => ({
+    incident: one(fluxSentinelIncidents, {
+        fields: [fluxSentinelIncidentActivity.incidentId],
+        references: [fluxSentinelIncidents.id],
+    }),
+}));
+// =============================================================================
+// SENTINEL PITCH TRACKING — Outreach & Relationship History
+// =============================================================================
+export const fluxSentinelPitchStatusEnum = pgEnum("flux_sentinel_pitch_status", [
+    "draft",
+    "sent",
+    "opened",
+    "replied",
+    "declined",
+    "no_response",
+]);
+/**
+ * Pitches — logged outreach to journalists.
+ * Links to journalist contacts, media mentions, and media lists.
+ */
+export const fluxSentinelPitches = pgTable("flux_sentinel_pitches", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    journalistId: text("journalist_id").references(() => fluxJournalistContacts.id, { onDelete: "set null" }),
+    journalistName: text("journalist_name").notNull(),
+    journalistEmail: text("journalist_email"),
+    subject: text("subject").notNull(),
+    body: text("body"),
+    status: fluxSentinelPitchStatusEnum("status").default("draft").notNull(),
+    sentAt: timestamp("sent_at", { withTimezone: true }),
+    sentBySlackId: text("sent_by_slack_id").notNull(),
+    sentByName: text("sent_by_name"),
+    followUpAt: timestamp("follow_up_at", { withTimezone: true }),
+    lastStatusAt: timestamp("last_status_at", { withTimezone: true }),
+    mentionId: text("mention_id").references(() => fluxMediaMentions.id, {
+        onDelete: "set null",
+    }),
+    mediaListId: text("media_list_id").references(() => fluxSentinelMediaLists.id, { onDelete: "set null" }),
+    notes: text("notes"),
+    zeroClickHeadline: text("zero_click_headline"),
+    zeroClickBullets: text("zero_click_bullets").array(),
+    zeroClickQuote: text("zero_click_quote"),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTs: text("slack_message_ts"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    journalistIdx: index("flux_sentinel_pitches_journalist_idx").on(table.journalistId),
+    statusIdx: index("flux_sentinel_pitches_status_idx").on(table.status),
+    sentByIdx: index("flux_sentinel_pitches_sent_by_idx").on(table.sentBySlackId),
+    followUpIdx: index("flux_sentinel_pitches_follow_up_idx").on(table.followUpAt),
+    createdAtIdx: index("flux_sentinel_pitches_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Pitch activity log — audit trail for all pitch actions.
+ */
+export const fluxSentinelPitchActivity = pgTable("flux_sentinel_pitch_activity", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    pitchId: text("pitch_id")
+        .notNull()
+        .references(() => fluxSentinelPitches.id, { onDelete: "cascade" }),
+    action: text("action").notNull(),
+    actorName: text("actor_name"),
+    details: jsonb("details"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    pitchIdx: index("flux_sentinel_pitch_activity_pitch_idx").on(table.pitchId),
+    createdAtIdx: index("flux_sentinel_pitch_activity_created_at_idx").on(table.createdAt),
+}));
+// Sentinel pitch relations
+export const fluxSentinelPitchesRelations = relations(fluxSentinelPitches, ({ one, many }) => ({
+    journalist: one(fluxJournalistContacts, {
+        fields: [fluxSentinelPitches.journalistId],
+        references: [fluxJournalistContacts.id],
+    }),
+    mention: one(fluxMediaMentions, {
+        fields: [fluxSentinelPitches.mentionId],
+        references: [fluxMediaMentions.id],
+    }),
+    mediaList: one(fluxSentinelMediaLists, {
+        fields: [fluxSentinelPitches.mediaListId],
+        references: [fluxSentinelMediaLists.id],
+    }),
+    activity: many(fluxSentinelPitchActivity),
+}));
+export const fluxSentinelPitchActivityRelations = relations(fluxSentinelPitchActivity, ({ one }) => ({
+    pitch: one(fluxSentinelPitches, {
+        fields: [fluxSentinelPitchActivity.pitchId],
+        references: [fluxSentinelPitches.id],
+    }),
+}));
+// =============================================================================
+// SENTINEL MEDIA LISTS — Organized Journalist Groups
+// =============================================================================
+/**
+ * Media lists — curated groups of journalists for organized outreach.
+ */
+export const fluxSentinelMediaLists = pgTable("flux_sentinel_media_lists", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    name: text("name").notNull(),
+    description: text("description"),
+    createdBySlackId: text("created_by_slack_id").notNull(),
+    createdByName: text("created_by_name"),
+    isShared: boolean("is_shared").default(true).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    nameIdx: index("flux_sentinel_media_lists_name_idx").on(table.name),
+    createdAtIdx: index("flux_sentinel_media_lists_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Media list members — journalists belonging to a media list.
+ */
+export const fluxSentinelMediaListMembers = pgTable("flux_sentinel_media_list_members", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    listId: text("list_id")
+        .notNull()
+        .references(() => fluxSentinelMediaLists.id, { onDelete: "cascade" }),
+    journalistId: text("journalist_id")
+        .notNull()
+        .references(() => fluxJournalistContacts.id, { onDelete: "cascade" }),
+    addedByName: text("added_by_name"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    listIdx: index("flux_sentinel_media_list_members_list_idx").on(table.listId),
+    journalistIdx: index("flux_sentinel_media_list_members_journalist_idx").on(table.journalistId),
+    uniqueMember: uniqueIndex("flux_sentinel_media_list_members_unique_idx").on(table.listId, table.journalistId),
+}));
+// Media list relations
+export const fluxSentinelMediaListsRelations = relations(fluxSentinelMediaLists, ({ many }) => ({
+    members: many(fluxSentinelMediaListMembers),
+    pitches: many(fluxSentinelPitches),
+}));
+export const fluxSentinelMediaListMembersRelations = relations(fluxSentinelMediaListMembers, ({ one }) => ({
+    list: one(fluxSentinelMediaLists, {
+        fields: [fluxSentinelMediaListMembers.listId],
+        references: [fluxSentinelMediaLists.id],
+    }),
+    journalist: one(fluxJournalistContacts, {
+        fields: [fluxSentinelMediaListMembers.journalistId],
+        references: [fluxJournalistContacts.id],
+    }),
+}));
+// Media mention relations (placed after all tables to avoid forward references)
+export const fluxMediaMentionsRelations = relations(fluxMediaMentions, ({ one, many }) => ({
+    keyword: one(fluxSentinelKeywords, {
+        fields: [fluxMediaMentions.keywordId],
+        references: [fluxSentinelKeywords.id],
+    }),
+    incidents: many(fluxSentinelIncidents),
+    pitches: many(fluxSentinelPitches),
+}));
+export const fluxJournalistContactsRelations = relations(fluxJournalistContacts, ({ many }) => ({
+    pitches: many(fluxSentinelPitches),
+    listMemberships: many(fluxSentinelMediaListMembers),
+}));
+// =============================================================================
+// FEEDBACK & FEATURE REQUESTS
+// =============================================================================
+export const fluxFeedbackCategoryEnum = pgEnum("flux_feedback_category", [
+    "bug",
+    "feature_request",
+    "roadmap_vote",
+    "general",
+]);
+export const fluxFeedbackStatusEnum = pgEnum("flux_feedback_status", [
+    "new",
+    "acknowledged",
+    "planned",
+    "in_progress",
+    "completed",
+    "declined",
+]);
+/**
+ * User feedback and feature requests — submitted via /ideas slash command.
+ * General-purpose: covers bugs, feature requests, roadmap votes, and general input.
+ */
+export const fluxFeedback = pgTable("flux_feedback", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    slackUserId: text("slack_user_id").notNull(),
+    slackUserName: text("slack_user_name"),
+    category: fluxFeedbackCategoryEnum("category").default("general").notNull(),
+    title: text("title").notNull(),
+    description: text("description"),
+    status: fluxFeedbackStatusEnum("status").default("new").notNull(),
+    adminNotes: text("admin_notes"),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTs: text("slack_message_ts"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    categoryIdx: index("flux_feedback_category_idx").on(table.category),
+    statusIdx: index("flux_feedback_status_idx").on(table.status),
+    createdAtIdx: index("flux_feedback_created_at_idx").on(table.createdAt),
+}));
+// =============================================================================
+// FULFILLMENT PIPELINE — HubSpot Fulfillment Ticket Projections
+// =============================================================================
+/**
+ * Fulfillment pipeline stage enum — mirrors HubSpot pipeline 1230947033 stages.
+ * Used by the fulfillment board, webhook handler, and SLA tracking.
+ */
+export const fluxFulfillmentStageEnum = pgEnum("flux_fulfillment_stage", [
+    "pending_form",
+    "submitted",
+    "pending_creative",
+    "pending_fulfillment",
+    "ready",
+    "running",
+    "paused",
+    "completed",
+    "cancelled",
+    "change_required",
+    "billing_change_required",
+]);
+/**
+ * Fulfillment team enum — the operational team responsible for the ticket.
+ */
+export const fluxFulfillmentTeamEnum = pgEnum("flux_fulfillment_team", [
+    "creative_team",
+    "campaign_manager",
+    "media_buyer",
+]);
+/**
+ * Fulfillment tickets — projected from HubSpot Fulfillment Pipeline (1230947033).
+ *
+ * Each row represents a fulfillment ticket synced from HubSpot via periodic sync
+ * or real-time webhook. HubSpot is the system of record; this table is a read
+ * projection enriched with stage history for SLA tracking and board display.
+ *
+ * Associated with a flux_project via the company → project mapping.
+ */
+export const fluxFulfillmentTickets = pgTable("flux_fulfillment_tickets", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    /** HubSpot ticket ID — unique constraint ensures no duplicate projections */
+    hubspotTicketId: text("hubspot_ticket_id").notNull(),
+    /** FK to flux_projects — resolved from HubSpot company association */
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "cascade",
+    }),
+    // -- Core ticket fields --
+    /** Ticket name / subject line */
+    subject: text("subject").notNull(),
+    /** Ticket description / content */
+    content: text("content"),
+    /** Current pipeline stage — enum for type-safe queries */
+    pipelineStage: fluxFulfillmentStageEnum("pipeline_stage")
+        .notNull()
+        .default("pending_form"),
+    /** HubSpot numeric pipeline stage ID (e.g. "2056920807") for API round-trips */
+    hubspotStageId: text("hubspot_stage_id"),
+    // -- Team & Ownership --
+    /** Operational team: creative_team, campaign_manager, media_buyer */
+    fulfillmentTeam: fluxFulfillmentTeamEnum("fulfillment_team"),
+    /** HubSpot owner ID for the fulfillment assignee */
+    fulfillmentOwnerId: text("fulfillment_owner_id"),
+    /** HubSpot owner ID for the sales owner on the ticket */
+    salesOwnerId: text("sales_owner_id"),
+    /** HubSpot owner ID for the trafficking assignee */
+    traffickingOwnerId: text("trafficking_owner_id"),
+    // -- Account Team --
+    /** Account Executive owner ID */
+    accountExecutiveId: text("account_executive_id"),
+    /** Account Manager owner ID */
+    accountManagerId: text("account_manager_id"),
+    /** Media Strategist owner ID */
+    mediaStrategistId: text("media_strategist_id"),
+    // -- Campaign Details --
+    /** Campaign type (e.g. Affiliate Marketing, Automotive) */
+    campaignType: text("campaign_type"),
+    /** Ad type */
+    adType: text("ad_type"),
+    /** Product name from the associated line item */
+    productName: text("product_name"),
+    /** Product code / SKU */
+    productCode: text("product_code"),
+    // -- Deal Type --
+    /** Deal type from HubSpot (e.g., "newbusiness", "existingbusiness") */
+    dealType: text("deal_type"),
+    // -- Creative Status --
+    /** "true" = Needs Creative, "false" = Camera Ready */
+    creativeRequest: text("creative_request"),
+    /** "Camera Ready" | "Needs Creative" */
+    creativeProvided: text("creative_provided"),
+    // -- Change Request --
+    /** Change type if this is a change request: Date, Pause, Cancel, Budget, Extension, etc. */
+    changeType: text("change_type"),
+    /** Whether this is a change request */
+    isChangeRequest: boolean("is_change_request").default(false),
+    /** Date the change was requested */
+    changeRequestDate: timestamp("change_request_date", {
+        withTimezone: true,
+    }),
+    // -- Dates --
+    /** Campaign start date */
+    startDate: date("start_date"),
+    /** Campaign end date */
+    endDate: date("end_date"),
+    /** Cancel date if applicable */
+    cancelDate: date("cancel_date"),
+    // -- Investment --
+    /** Monthly investment amount in dollars */
+    monthlyInvestment: numeric("monthly_investment", {
+        precision: 12,
+        scale: 2,
+    }),
+    /** Total investment amount in dollars */
+    totalInvestment: numeric("total_investment", { precision: 12, scale: 2 }),
+    // -- Line Item Link --
+    /** HubSpot line item ID — bridges to Compass order data */
+    lineItemId: text("line_item_id"),
+    // -- Jotform --
+    /** Jotform status: Incomplete | Complete */
+    jotformStatus: text("jotform_status"),
+    // -- Stage Tracking (for SLA) --
+    /** When the ticket entered its current stage (from HubSpot hs_v2_date_entered_current_stage) */
+    stageEnteredAt: timestamp("stage_entered_at", { withTimezone: true }),
+    /**
+     * Full stage history as JSONB array. Each entry:
+     * { stage: string, enteredAt: string, exitedAt?: string, durationSeconds?: number }
+     */
+    stageHistory: jsonb("stage_history").default(sql `'[]'::jsonb`),
+    // -- Compass Order Context --
+    /** Deep link URL to the Compass order that generated this ticket */
+    compassOrderUrl: text("compass_order_url"),
+    /** Compass product family code (e.g., "SEM", "Display", "Social") */
+    compassProductFamily: text("compass_product_family"),
+    /** Compass product code */
+    compassProductCode: text("compass_product_code"),
+    /** Impressions from Compass order line item */
+    compassImpressions: text("compass_impressions"),
+    /** Creative source from Compass order */
+    compassCreativeSource: text("compass_creative_source"),
+    /** Targeting details from Compass order */
+    compassTargeting: text("compass_targeting"),
+    /** HubSpot deal ID associated with this ticket's line item */
+    dealId: text("deal_id"),
+    /** Deal name for display */
+    dealName: text("deal_name"),
+    /** Total order value from the deal */
+    dealOrderTotal: numeric("deal_order_total", { precision: 12, scale: 2 }),
+    /** Compass order status (e.g., "signed", "draft", "amended") */
+    compassOrderStatus: text("compass_order_status"),
+    // -- Native HubSpot SLA --
+    /** HubSpot SLA status for first response (Overdue, Due Soon, Active SLA, etc.) */
+    hubspotSlaFirstResponse: varchar("hubspot_sla_first_response"),
+    /** HubSpot SLA status for time to close */
+    hubspotSlaClose: varchar("hubspot_sla_close"),
+    /** HubSpot SLA status for next response */
+    hubspotSlaNextResponse: varchar("hubspot_sla_next_response"),
+    // -- Additional HubSpot Properties --
+    /** Date creative was requested */
+    creativeRequestDate: timestamp("creative_request_date", { withTimezone: true }),
+    /** Whether creative upload is completed */
+    uploadCreativeCompleted: text("upload_creative_completed"),
+    /** Content in progress status */
+    contentInProgress: text("content_in_progress"),
+    /** Naviga campaign ID */
+    navigaCampaignId: text("na_campaign_id"),
+    /** Platform campaign name */
+    platformCampaignName: text("platform_campaign_name"),
+    // -- Additional operational fields --
+    /** Trafficking request status */
+    traffickingRequest: text("trafficking_request"),
+    /** When trafficking was requested */
+    traffickingRequestDate: timestamp("trafficking_request_date", { withTimezone: true }),
+    /** When ticket was accepted */
+    acceptedDate: timestamp("accepted_date", { withTimezone: true }),
+    /** Urgency flag for triage prioritization */
+    isUrgent: boolean("is_urgent").default(false),
+    /** Internal flags */
+    flag: text("flag"),
+    /** PO number for billing */
+    purchaseOrder: text("purchase_order"),
+    /** Creative brief lifecycle status */
+    creativeBriefStatus: text("creative_brief_status"),
+    /** Which operations center handles this */
+    operationsCenter: text("operations_center"),
+    // -- HubSpot Metadata --
+    /** Ticket priority from HubSpot */
+    priority: text("priority"),
+    /** HubSpot URL for quick navigation */
+    hubspotUrl: text("hubspot_url"),
+    /** Original ticket creation date in HubSpot */
+    hubspotCreatedAt: timestamp("hubspot_created_at", { withTimezone: true }),
+    /** Last modification date in HubSpot */
+    hubspotUpdatedAt: timestamp("hubspot_updated_at", { withTimezone: true }),
+    // -- SLA Profile Override --
+    /** SLA profile override — FK to flux_sla_profiles (takes precedence over project profile) */
+    slaProfileId: text("sla_profile_id").references(() => fluxSlaProfiles.id, { onDelete: "set null" }),
+    /** Source of the SLA override: admin or compass_sla_exception */
+    slaOverrideSource: text("sla_override_source"),
+    /** When the override expires (null = permanent) */
+    slaOverrideExpiresAt: timestamp("sla_override_expires_at", { withTimezone: true }),
+    // -- Local tracking --
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    /** Unique constraint on HubSpot ticket ID — prevents duplicate projections */
+    hubspotTicketIdx: uniqueIndex("flux_fulfillment_tickets_hs_id_idx").on(table.hubspotTicketId),
+    /** Filter by project for project-level board */
+    projectIdx: index("flux_fulfillment_tickets_project_idx").on(table.projectId),
+    /** Filter by pipeline stage for board columns */
+    stageIdx: index("flux_fulfillment_tickets_stage_idx").on(table.pipelineStage),
+    /** Filter by team for team-based views */
+    teamIdx: index("flux_fulfillment_tickets_team_idx").on(table.fulfillmentTeam),
+    /** Filter change requests */
+    changeRequestIdx: index("flux_fulfillment_tickets_change_request_idx").on(table.isChangeRequest),
+    /** Sort by start date for timeline views */
+    startDateIdx: index("flux_fulfillment_tickets_start_date_idx").on(table.startDate),
+    /** SLA tracking — find tickets by stage entry time */
+    stageEnteredIdx: index("flux_fulfillment_tickets_stage_entered_idx").on(table.stageEnteredAt),
+}));
+/** Fulfillment ticket relations */
+export const fluxFulfillmentTicketsRelations = relations(fluxFulfillmentTickets, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxFulfillmentTickets.projectId],
+        references: [fluxProjects.id],
+    }),
+}));
+// =============================================================================
+// FULFILLMENT TASK TEMPLATES
+// =============================================================================
+/**
+ * Fulfillment Task Templates — auto-generate tasks when tickets transition stages.
+ *
+ * Each template defines a task that should be created when a fulfillment ticket
+ * enters a specific pipeline stage. Templates can be customized per stage, with
+ * default titles that support {subject} placeholder interpolation.
+ */
+export const fluxFulfillmentTaskTemplates = pgTable("flux_fulfillment_task_templates", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** Pipeline stage that triggers this task template */
+    triggerStage: fluxFulfillmentStageEnum("trigger_stage").notNull(),
+    /** Task title template — supports {subject} placeholder */
+    titleTemplate: text("title_template").notNull(),
+    /** Task description template */
+    descriptionTemplate: text("description_template"),
+    /** Default priority for the generated task */
+    priority: text("priority").default("medium").notNull(),
+    /** Role hint for assignment (e.g., "creative_team", "strategist", "ae") */
+    assigneeRole: text("assignee_role"),
+    /** Days until due from stage entry */
+    dueDaysFromTransition: integer("due_days_from_transition").default(2).notNull(),
+    /** Whether this template is active */
+    isActive: boolean("is_active").default(true).notNull(),
+    /** Display order for admin management */
+    displayOrder: integer("display_order").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    stageIdx: index("flux_fulfillment_task_templates_stage_idx").on(table.triggerStage),
+}));
+// =============================================================================
+// FULFILLMENT EVENT OUTBOX
+// =============================================================================
+/**
+ * Delivery status for fulfillment events sent from Flux to Forge.
+ * Mirrors Forge's execution_event_outbox delivery lifecycle.
+ */
+export const fluxFulfillmentEventDeliveryEnum = pgEnum("flux_fulfillment_event_delivery", ["pending", "delivered", "failed", "dead_letter"]);
+/**
+ * Outbox table for fulfillment events emitted by Flux to Forge.
+ *
+ * When a fulfillment ticket enters a stage that requires action in Forge
+ * (e.g., pending_creative), an event is queued here. A delivery worker
+ * reads pending events, signs them with HMAC-SHA256, and POSTs to Forge's
+ * /api/fulfillment-events endpoint.
+ *
+ * Uses the same FORGE_EXECUTION_EVENT_SHARED_SECRET as the Forge → Flux
+ * direction for symmetric HMAC verification.
+ */
+export const fluxFulfillmentEventOutbox = pgTable("flux_fulfillment_event_outbox", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** Unique event identifier for deduplication */
+    eventId: varchar("event_id").notNull(),
+    /** Event type (e.g., "fulfillment.creative_needed") */
+    eventType: text("event_type").notNull(),
+    /** HubSpot ticket ID this event relates to */
+    hubspotTicketId: text("hubspot_ticket_id").notNull(),
+    /** Flux fulfillment ticket UUID */
+    fulfillmentTicketId: text("fulfillment_ticket_id").notNull(),
+    /** Idempotency key for dedup on the receiver side */
+    idempotencyKey: text("idempotency_key").notNull().unique(),
+    /** ISO timestamp when the event was emitted */
+    emittedAt: timestamp("emitted_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    /** Full event payload as JSONB */
+    payload: jsonb("payload").notNull(),
+    /** Delivery status lifecycle: pending → delivered | failed → dead_letter */
+    deliveryStatus: fluxFulfillmentEventDeliveryEnum("delivery_status")
+        .default("pending")
+        .notNull(),
+    /** Number of delivery attempts so far */
+    attemptCount: integer("attempt_count").default(0).notNull(),
+    /** When to next attempt delivery (for backoff) */
+    nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    /** Timestamp of successful delivery */
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+    /** Last error message from delivery attempt */
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    pendingIdx: index("flux_fulfillment_event_outbox_pending_idx").on(table.deliveryStatus, table.nextAttemptAt),
+    ticketIdx: index("flux_fulfillment_event_outbox_ticket_idx").on(table.hubspotTicketId),
+}));
+/** Relations for fulfillment event outbox (standalone — no foreign keys) */
+export const fluxFulfillmentEventOutboxRelations = relations(fluxFulfillmentEventOutbox, () => ({}));
+// =============================================================================
+// PROGRAMMATIC SHELL — Enums
+// =============================================================================
+export const fluxProgrammaticShellStatusEnum = pgEnum("flux_programmatic_shell_status", [
+    "draft",
+    "edited",
+    "vendor_locked",
+    "activated",
+    "completed",
+]);
+export const fluxProgrammaticDecisionTypeEnum = pgEnum("flux_programmatic_decision_type", [
+    "vendor_select",
+    "recommendation_accept",
+    "recommendation_edit",
+    "recommendation_dismiss",
+    "activation",
+]);
+export const fluxProgrammaticFeedbackActionEnum = pgEnum("flux_programmatic_feedback_action", [
+    "accept",
+    "edit",
+    "dismiss",
+]);
+// =============================================================================
+// PROGRAMMATIC SHELLS
+// =============================================================================
+/**
+ * flux_programmatic_shells — Draft campaign shells prefilled from Compass order context.
+ * Created when a programmatic fulfillment ticket enters the pipeline.
+ * No DSP campaigns are created until vendor_locked status.
+ */
+export const fluxProgrammaticShells = pgTable("flux_programmatic_shells", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    /** FK to the fulfillment ticket that spawned this shell (1:1 relationship) */
+    fulfillmentTicketId: text("fulfillment_ticket_id")
+        .references(() => fluxFulfillmentTickets.id, { onDelete: "cascade" })
+        .notNull()
+        .unique(),
+    /** HubSpot deal ID for order-level correlation */
+    dealId: text("deal_id"),
+    /** HubSpot line item ID for precise routing */
+    lineItemId: text("line_item_id"),
+    /** Shell lifecycle status */
+    status: fluxProgrammaticShellStatusEnum("status")
+        .notNull()
+        .default("draft"),
+    /** Whether a vendor has been selected */
+    vendorSelected: boolean("vendor_selected").default(false).notNull(),
+    /** Selected vendor identifier (e.g., "ttd", "datasys") */
+    selectedVendor: text("selected_vendor"),
+    /** Raw lookup response from fn-legacy POST /api/programmatic/lookup */
+    lookupData: jsonb("lookup_data").$type(),
+    /**
+     * Prefilled campaign parameters from order context + lookup.
+     * TTD-specific fields:
+     * - channel: DISPLAY | VIDEO | DOOH
+     * - funnelLocation: AWARENESS | CONSIDERATION
+     * - allocationType: MAXIMUM | MINIMUM
+     * - budgetInAdvertiserCurrency: total budget
+     * - dailyTargetInAdvertiserCurrency: daily pacing target
+     * - baseBidCPMInAdvertiserCurrency: base bid
+     * - maxBidCPMInAdvertiserCurrency: max bid
+     * - seedId: TTD seed ID for campaign creation
+     * - flightStart/flightEnd: ISO dates
+     * - targetingGeo/targetingAudience/targetingDevice: JSONB segments
+     */
+    prefillData: jsonb("prefill_data").$type(),
+    /** TTD campaign ID (set after activation) */
+    ttdCampaignId: text("ttd_campaign_id"),
+    /** TTD ad group ID (set after activation) */
+    ttdAdGroupId: text("ttd_ad_group_id"),
+    /** Correlation ID for audit trail across fn-legacy/fn-flux/fn-forge */
+    correlationId: text("correlation_id"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    fulfillmentTicketIdx: index("flux_prog_shells_ticket_idx").on(table.fulfillmentTicketId),
+    dealIdx: index("flux_prog_shells_deal_idx").on(table.dealId),
+    statusIdx: index("flux_prog_shells_status_idx").on(table.status),
+    ttdCampaignIdx: index("flux_prog_shells_ttd_campaign_idx").on(table.ttdCampaignId),
+}));
+/**
+ * flux_programmatic_shell_versions — Snapshot history for shell changes.
+ * Each edit creates a new version for auditability.
+ */
+export const fluxProgrammaticShellVersions = pgTable("flux_programmatic_shell_versions", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    shellId: varchar("shell_id")
+        .references(() => fluxProgrammaticShells.id, { onDelete: "cascade" })
+        .notNull(),
+    version: integer("version").notNull(),
+    snapshot: jsonb("snapshot").notNull().$type(),
+    changedBy: text("changed_by"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    shellIdx: index("flux_prog_shell_versions_shell_idx").on(table.shellId),
+    shellVersionUniq: uniqueIndex("flux_prog_shell_versions_shell_version_uniq").on(table.shellId, table.version),
+}));
+/**
+ * flux_programmatic_decisions — Audit trail of buyer decisions on shells.
+ * Tracks vendor selection, recommendation acceptance, and activation.
+ */
+export const fluxProgrammaticDecisions = pgTable("flux_programmatic_decisions", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    shellId: varchar("shell_id")
+        .references(() => fluxProgrammaticShells.id, { onDelete: "cascade" })
+        .notNull(),
+    decisionType: fluxProgrammaticDecisionTypeEnum("decision_type").notNull(),
+    decisionData: jsonb("decision_data").$type(),
+    decidedBy: text("decided_by"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    shellIdx: index("flux_prog_decisions_shell_idx").on(table.shellId),
+    typeIdx: index("flux_prog_decisions_type_idx").on(table.decisionType),
+}));
+/**
+ * flux_programmatic_recommendation_feedback — Buyer feedback on recommendations.
+ * Used for ranking calibration and recommendation quality improvement.
+ */
+export const fluxProgrammaticRecommendationFeedback = pgTable("flux_programmatic_recommendation_feedback", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    shellId: varchar("shell_id")
+        .references(() => fluxProgrammaticShells.id, { onDelete: "cascade" })
+        .notNull(),
+    recommendationId: text("recommendation_id").notNull(),
+    action: fluxProgrammaticFeedbackActionEnum("action").notNull(),
+    editedValues: jsonb("edited_values").$type(),
+    createdBy: text("created_by"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    shellIdx: index("flux_prog_rec_feedback_shell_idx").on(table.shellId),
+    recIdx: index("flux_prog_rec_feedback_rec_idx").on(table.recommendationId),
+}));
+// =============================================================================
+// PROJECT CONTACTS (HubSpot Contacts)
+// =============================================================================
+export const fluxProjectContacts = pgTable("flux_project_contacts", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => fluxProjects.id, { onDelete: "cascade" }),
+    hubspotContactId: text("hubspot_contact_id").notNull(),
+    firstName: text("first_name"),
+    lastName: text("last_name"),
+    email: text("email"),
+    phone: text("phone"),
+    jobTitle: text("job_title"),
+    isPrimary: boolean("is_primary").default(false),
+    lastActivityDate: timestamp("last_activity_date", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    projectIdx: index("flux_project_contacts_project_idx").on(table.projectId),
+    emailIdx: index("flux_project_contacts_email_idx").on(table.email),
+    uniqueContactPerProject: uniqueIndex("flux_project_contacts_unique_idx").on(table.projectId, table.hubspotContactId),
+}));
+// =============================================================================
+// HUBSPOT SYNC LOG (Operational Visibility)
+// =============================================================================
+export const fluxHubspotSyncLog = pgTable("flux_hubspot_sync_log", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    syncType: varchar("sync_type").notNull(),
+    objectType: varchar("object_type"),
+    status: varchar("status").notNull().default("success"),
+    recordsProcessed: integer("records_processed").default(0),
+    errorMessage: text("error_message"),
+    durationMs: integer("duration_ms"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    typeIdx: index("flux_hubspot_sync_log_type_idx").on(table.syncType),
+    createdIdx: index("flux_hubspot_sync_log_created_idx").on(table.createdAt),
+}));
+// =============================================================================
+// DEAL PIPELINE & FORECASTING
+// =============================================================================
+export const fluxConfidenceTierEnum = pgEnum("flux_confidence_tier", [
+    "commit",
+    "likely",
+    "upside",
+    "longshot",
+]);
+export const fluxCloseOutcomeEnum = pgEnum("flux_close_outcome", [
+    "won",
+    "lost",
+]);
+/**
+ * flux_deal_pipeline — One row per HubSpot deal in the open pipeline.
+ * Unified view merging HubSpot deal data with Compass order/margin data
+ * and behavioral confidence scoring.
+ */
+export const fluxDealPipeline = pgTable("flux_deal_pipeline", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    hubspotDealId: text("hubspot_deal_id").notNull().unique(),
+    dealName: text("deal_name").notNull(),
+    dealStage: text("deal_stage"),
+    dealStageProbability: real("deal_stage_probability"),
+    amount: numeric("amount"),
+    closeDate: date("close_date"),
+    hubspotOwnerId: text("hubspot_owner_id"),
+    ownerName: text("owner_name"),
+    ownerEmail: text("owner_email"),
+    hubspotCompanyId: text("hubspot_company_id"),
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "set null",
+    }),
+    /** Deal type from HubSpot (e.g., "newbusiness", "existingbusiness") */
+    dealType: text("deal_type"),
+    // Compass linkage
+    compassPlanId: text("compass_plan_id"),
+    compassOrderId: text("compass_order_id"),
+    compassOrderStatus: text("compass_order_status"),
+    totalInvestment: numeric("total_investment"),
+    marginPercent: real("margin_percent"),
+    productMix: jsonb("product_mix").$type(),
+    // Confidence scoring
+    confidenceScore: real("confidence_score"),
+    confidenceTier: fluxConfidenceTierEnum("confidence_tier"),
+    scoreFactors: jsonb("score_factors").$type(),
+    // Forecast windows
+    forecast30d: numeric("forecast_30d"),
+    forecast60d: numeric("forecast_60d"),
+    forecast90d: numeric("forecast_90d"),
+    marginForecast30d: numeric("margin_forecast_30d"),
+    marginForecast60d: numeric("margin_forecast_60d"),
+    marginForecast90d: numeric("margin_forecast_90d"),
+    predictedMarginPct: real("predicted_margin_pct"),
+    // Rep override
+    overrideScore: real("override_score"),
+    overrideReason: text("override_reason"),
+    overrideBy: text("override_by"),
+    overrideAt: timestamp("override_at", { withTimezone: true }),
+    overrideExpiresAt: timestamp("override_expires_at", {
+        withTimezone: true,
+    }),
+    // Stage velocity tracking
+    /** JSONB map of stage name → ISO timestamp when deal entered that stage */
+    stageEntryDates: jsonb("stage_entry_dates")
+        .default(sql `'{}'::jsonb`)
+        .$type(),
+    // -- HubSpot enrichment fields --
+    /** HubSpot AI deal score (hs_deal_score) */
+    hubspotDealScore: real("hubspot_deal_score"),
+    /** HubSpot stall detection (hs_is_stalled) */
+    isStalled: boolean("is_stalled").default(false),
+    /** Reason deal was won */
+    closedWonReason: text("closed_won_reason"),
+    /** Reason deal was lost */
+    closedLostReason: text("closed_lost_reason"),
+    /** Next step from HubSpot (hs_next_step) */
+    nextStep: text("next_step"),
+    /** Naviga campaign ID for billing reconciliation */
+    navigaCampaignId: text("naviga_campaign_id"),
+    /** Compass order URL (from fn_compass_order_url on deal) */
+    compassOrderUrl: text("compass_order_url"),
+    /** Compass order total value */
+    compassOrderTotal: numeric("compass_order_total", { precision: 12, scale: 2 }),
+    // Compass lifecycle timestamps
+    compassApprovedAt: timestamp("compass_approved_at", { withTimezone: true }),
+    compassSubmittedAt: timestamp("compass_submitted_at", { withTimezone: true }),
+    compassActivatedAt: timestamp("compass_activated_at", { withTimezone: true }),
+    compassCompletedAt: timestamp("compass_completed_at", { withTimezone: true }),
+    compassSentAt: timestamp("compass_sent_at", { withTimezone: true }),
+    // Compass financial
+    compassTotalMarginDollars: numeric("compass_total_margin_dollars", { precision: 12, scale: 2 }),
+    compassWeightedMarginPct: real("compass_weighted_margin_pct"),
+    compassTotalMediaBudget: numeric("compass_total_media_budget", { precision: 12, scale: 2 }),
+    // Compass amendment tracking
+    compassAmendmentCount: integer("compass_amendment_count").default(0),
+    compassOrderVersion: integer("compass_order_version").default(1),
+    compassLastAmendment: text("compass_last_amendment"),
+    compassLastAmendmentDate: timestamp("compass_last_amendment_date", { withTimezone: true }),
+    // Compass risk & context
+    compassPendingRateApprovals: integer("compass_pending_rate_approvals").default(0),
+    compassReturnReason: text("compass_return_reason"),
+    compassProductFamilies: text("compass_product_families"),
+    compassPlanMode: text("compass_plan_mode"),
+    compassFlightDates: text("compass_flight_dates"),
+    compassLocation: text("compass_location"),
+    compassOrderName: text("compass_order_name"),
+    // Activity tracking
+    lastActivityDate: timestamp("last_activity_date", { withTimezone: true }),
+    daysInCurrentStage: integer("days_in_current_stage"),
+    // Close tracking
+    isClosed: boolean("is_closed").default(false).notNull(),
+    closeOutcome: fluxCloseOutcomeEnum("close_outcome"),
+    closedAt: timestamp("closed_at", { withTimezone: true }),
+    // HubSpot metadata
+    hubspotCreatedAt: timestamp("hubspot_created_at", { withTimezone: true }),
+    hubspotUpdatedAt: timestamp("hubspot_updated_at", { withTimezone: true }),
+    // Timestamps
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    hubspotDealIdx: uniqueIndex("flux_deal_pipeline_hubspot_deal_idx").on(table.hubspotDealId),
+    companyIdx: index("flux_deal_pipeline_company_idx").on(table.hubspotCompanyId),
+    projectIdx: index("flux_deal_pipeline_project_idx").on(table.projectId),
+    stageIdx: index("flux_deal_pipeline_stage_idx").on(table.dealStage),
+    tierIdx: index("flux_deal_pipeline_tier_idx").on(table.confidenceTier),
+    closeDateIdx: index("flux_deal_pipeline_close_date_idx").on(table.closeDate),
+    ownerIdx: index("flux_deal_pipeline_owner_idx").on(table.hubspotOwnerId),
+    closedIdx: index("flux_deal_pipeline_closed_idx").on(table.isClosed),
+}));
+/**
+ * flux_forecast_snapshots — Weekly point-in-time pipeline snapshots for accuracy tracking.
+ * Unique per (deal_id, snapshot_date) to support idempotent weekly runs.
+ */
+export const fluxForecastSnapshots = pgTable("flux_forecast_snapshots", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    dealId: text("deal_id")
+        .references(() => fluxDealPipeline.id, { onDelete: "cascade" })
+        .notNull(),
+    hubspotDealId: text("hubspot_deal_id").notNull(),
+    snapshotDate: date("snapshot_date").notNull(),
+    dealName: text("deal_name"),
+    amount: numeric("amount"),
+    confidenceScore: real("confidence_score"),
+    confidenceTier: fluxConfidenceTierEnum("confidence_tier"),
+    forecast30d: numeric("forecast_30d"),
+    forecast60d: numeric("forecast_60d"),
+    forecast90d: numeric("forecast_90d"),
+    marginForecast30d: numeric("margin_forecast_30d"),
+    marginForecast60d: numeric("margin_forecast_60d"),
+    marginForecast90d: numeric("margin_forecast_90d"),
+    predictedMarginPct: real("predicted_margin_pct"),
+    dealStage: text("deal_stage"),
+    closeDate: date("close_date"),
+    ownerEmail: text("owner_email"),
+    overrideActive: boolean("override_active").default(false),
+    // Backfilled from Snowflake billing actuals
+    actualBilled: numeric("actual_billed"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    dealSnapshotIdx: uniqueIndex("flux_forecast_snapshots_deal_date_idx").on(table.dealId, table.snapshotDate),
+    snapshotDateIdx: index("flux_forecast_snapshots_date_idx").on(table.snapshotDate),
+    hubspotDealIdx: index("flux_forecast_snapshots_hs_deal_idx").on(table.hubspotDealId),
+}));
+/**
+ * flux_billing_actuals — Naviga billing data from Snowflake.
+ * Keyed by advertiser + billing period for forecast accuracy tracking.
+ */
+export const fluxBillingActuals = pgTable("flux_billing_actuals", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    advertiserName: text("advertiser_name").notNull(),
+    advertiserId: text("advertiser_id"),
+    hubspotCompanyId: text("hubspot_company_id"),
+    billingPeriod: date("billing_period").notNull(),
+    totalBilled: numeric("total_billed").notNull(),
+    totalRevenue: numeric("total_revenue"),
+    productBreakdown: jsonb("product_breakdown").$type(),
+    source: text("source").default("snowflake").notNull(),
+    syncedAt: timestamp("synced_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    advertiserPeriodIdx: uniqueIndex("flux_billing_actuals_advertiser_period_idx").on(table.advertiserName, table.billingPeriod),
+    hubspotCompanyIdx: index("flux_billing_actuals_company_idx").on(table.hubspotCompanyId),
+    periodIdx: index("flux_billing_actuals_period_idx").on(table.billingPeriod),
+}));
+/**
+ * flux_product_family_benchmarks — Benchmark margin % by product family.
+ * Used by deal scoring for margin prediction when Compass order margin is missing.
+ * Seed from fn-legacy strib_product_families.benchmark_margin_percent or manual entry.
+ */
+export const fluxProductFamilyBenchmarks = pgTable("flux_product_family_benchmarks", {
+    familyCode: varchar("family_code", { length: 64 }).primaryKey(),
+    benchmarkMarginPercent: real("benchmark_margin_percent").notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+// ─── AE Close Rates (materialized from closed deals) ─────────────────────
+export const fluxAeCloseRates = pgTable("flux_ae_close_rates", {
+    id: serial("id").primaryKey(),
+    hubspotOwnerId: text("hubspot_owner_id").notNull(),
+    ownerName: text("owner_name"),
+    ownerEmail: text("owner_email"),
+    sizeTier: text("size_tier").notNull(),
+    dealsWon: integer("deals_won").notNull().default(0),
+    dealsLost: integer("deals_lost").notNull().default(0),
+    dealsTotal: integer("deals_total").notNull().default(0),
+    closeRate: real("close_rate").notNull().default(0),
+    avgDealSize: numeric("avg_deal_size", { precision: 12, scale: 2 }),
+    avgDaysToClose: real("avg_days_to_close"),
+    windowStart: date("window_start").notNull(),
+    windowEnd: date("window_end").notNull(),
+    overrideCount: integer("override_count").notNull().default(0),
+    overrideAvgScore: real("override_avg_score"),
+    overrideActualWinRate: real("override_actual_win_rate"),
+    overrideAccuracyDelta: real("override_accuracy_delta"),
+    computedAt: timestamp("computed_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => [
+    uniqueIndex("flux_ae_close_rates_owner_tier_idx").on(table.hubspotOwnerId, table.sizeTier),
+    index("flux_ae_close_rates_owner_idx").on(table.hubspotOwnerId),
+]);
+// =============================================================================
+// ASSISTANT CONVERSATIONS
+// =============================================================================
+/**
+ * flux_assistant_conversations — Stores AI assistant conversation history.
+ * Each conversation belongs to a specific surface (e.g., "fulfillment") and user.
+ * Messages stored as JSONB array of { role, content, toolCalls? } objects.
+ */
+export const fluxAssistantConversations = pgTable("flux_assistant_conversations", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    clerkUserId: varchar("clerk_user_id").notNull(),
+    userEmail: varchar("user_email").notNull(),
+    surfaceId: varchar("surface_id").notNull(),
+    title: text("title").notNull().default("New conversation"),
+    messages: jsonb("messages").$type().notNull().default(sql `'[]'::jsonb`),
+    pageContext: jsonb("page_context"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    userSurfaceIdx: index("flux_assistant_conv_user_surface_idx").on(table.clerkUserId, table.surfaceId),
+}));
+// =============================================================================
+// CLIENT SENTINEL — Tier 1 Client Intelligence Monitoring
+// =============================================================================
+export const fluxClientSignalTypeEnum = pgEnum("flux_client_signal_type", [
+    "ma_activity",
+    "leadership_change",
+    "earnings",
+    "layoffs",
+    "expansion",
+    "legal",
+    "partnership",
+    "general",
+]);
+/**
+ * Client watches — per-client monitoring configuration.
+ * Created automatically from HubSpot Tier 1 sync or manually via Slack commands.
+ */
+export const fluxClientWatches = pgTable("flux_client_watches", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    projectId: text("project_id").references(() => fluxProjects.id, {
+        onDelete: "set null",
+    }),
+    hubspotCompanyId: text("hubspot_company_id"),
+    companyName: text("company_name").notNull(),
+    searchTerms: text("search_terms")
+        .array()
+        .notNull(),
+    slackChannelId: text("slack_channel_id"),
+    isActive: boolean("is_active").default(true).notNull(),
+    syncedFromHubspot: boolean("synced_from_hubspot").default(false).notNull(),
+    lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    companyNameIdx: index("flux_client_watches_company_name_idx").on(table.companyName),
+    hubspotCompanyIdx: index("flux_client_watches_hubspot_company_idx").on(table.hubspotCompanyId),
+    isActiveIdx: index("flux_client_watches_is_active_idx").on(table.isActive),
+    createdAtIdx: index("flux_client_watches_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Client signals — discovered business intelligence for watched clients.
+ */
+export const fluxClientSignals = pgTable("flux_client_signals", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    watchId: text("watch_id")
+        .references(() => fluxClientWatches.id, { onDelete: "cascade" })
+        .notNull(),
+    url: text("url").notNull().unique(),
+    title: text("title").notNull(),
+    author: text("author"),
+    publishedAt: timestamp("published_at", { withTimezone: true }),
+    sourceDomain: text("source_domain"),
+    snippet: text("snippet"),
+    sourceType: text("source_type").default("article").notNull(),
+    signalType: fluxClientSignalTypeEnum("signal_type")
+        .default("general")
+        .notNull(),
+    relevanceScore: real("relevance_score"),
+    analysisRationale: text("analysis_rationale"),
+    suggestedAction: text("suggested_action"),
+    sentiment: real("sentiment"),
+    impactAssessment: text("impact_assessment"),
+    slackMessageTs: text("slack_message_ts"),
+    notifiedAt: timestamp("notified_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    urlIdx: uniqueIndex("flux_client_signals_url_idx").on(table.url),
+    watchIdx: index("flux_client_signals_watch_idx").on(table.watchId),
+    signalTypeIdx: index("flux_client_signals_signal_type_idx").on(table.signalType),
+    createdAtIdx: index("flux_client_signals_created_at_idx").on(table.createdAt),
+}));
+/**
+ * Client scan run log — tracks each client pipeline cycle for observability.
+ */
+export const fluxClientScanRuns = pgTable("flux_client_scan_runs", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    runAt: timestamp("run_at", { withTimezone: true }).defaultNow().notNull(),
+    triggeredBy: text("triggered_by").notNull(),
+    watchesScanned: integer("watches_scanned").default(0).notNull(),
+    signalsFound: integer("signals_found").default(0).notNull(),
+    signalsNew: integer("signals_new").default(0).notNull(),
+    alertsSent: integer("alerts_sent").default(0).notNull(),
+    durationMs: integer("duration_ms"),
+    error: text("error"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+}, (table) => ({
+    runAtIdx: index("flux_client_scan_runs_run_at_idx").on(table.runAt),
+}));
+// Client Sentinel relations
+export const fluxClientWatchesRelations = relations(fluxClientWatches, ({ one, many }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxClientWatches.projectId],
+        references: [fluxProjects.id],
+    }),
+    signals: many(fluxClientSignals),
+}));
+export const fluxClientSignalsRelations = relations(fluxClientSignals, ({ one }) => ({
+    watch: one(fluxClientWatches, {
+        fields: [fluxClientSignals.watchId],
+        references: [fluxClientWatches.id],
+    }),
+}));
+// ─────────────────────────────────────────────────────────────────────────────
+// Bad Ad Reporter
+// ─────────────────────────────────────────────────────────────────────────────
+export const fluxBadadTypeEnum = pgEnum("flux_badad_type", [
+    "redirect",
+    "popup",
+    "inappropriate_content",
+    "slow_resource_heavy",
+    "auto_playing_media",
+    "phishing_malware",
+    "other",
+]);
+export const fluxBadadSeverityEnum = pgEnum("flux_badad_severity", [
+    "annoying",
+    "disruptive",
+    "dangerous",
+]);
+export const fluxBadadReportStatusEnum = pgEnum("flux_badad_report_status", [
+    "new",
+    "investigating",
+    "blocked",
+    "escalated",
+    "resolved",
+]);
+export const fluxBadadReports = pgTable("flux_badad_reports", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    adType: fluxBadadTypeEnum("ad_type").notNull(),
+    severity: fluxBadadSeverityEnum("severity").notNull().default("annoying"),
+    status: fluxBadadReportStatusEnum("status").notNull().default("new"),
+    pageUrl: text("page_url").notNull(),
+    description: text("description"),
+    browserDevice: text("browser_device"),
+    advertiserName: text("advertiser_name"),
+    clickThroughUrl: text("click_through_url"),
+    adPlacement: text("ad_placement"),
+    adDebugInfo: text("ad_debug_info"),
+    reporterSlackId: text("reporter_slack_id").notNull(),
+    reporterName: text("reporter_name"),
+    ownerSlackId: text("owner_slack_id"),
+    ownerName: text("owner_name"),
+    reportCount: integer("report_count").notNull().default(1),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTs: text("slack_message_ts"),
+    escalationNetwork: text("escalation_network"),
+    escalationNotes: text("escalation_notes"),
+    resolutionNotes: text("resolution_notes"),
+    resolvedAt: timestamp("resolved_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+export const fluxBadadActivity = pgTable("flux_badad_activity", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    reportId: text("report_id")
+        .notNull()
+        .references(() => fluxBadadReports.id, { onDelete: "cascade" }),
+    action: text("action").notNull(),
+    actorName: text("actor_name"),
+    actorSlackId: text("actor_slack_id"),
+    details: jsonb("details"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+});
+export const fluxBadadReportsRelations = relations(fluxBadadReports, ({ many }) => ({
+    activity: many(fluxBadadActivity),
+}));
+export const fluxBadadActivityRelations = relations(fluxBadadActivity, ({ one }) => ({
+    report: one(fluxBadadReports, {
+        fields: [fluxBadadActivity.reportId],
+        references: [fluxBadadReports.id],
+    }),
+}));
+// =============================================================================
+// PROJECT ONBOARDING QUEUE
+// =============================================================================
+export const fluxOnboardingReasonEnum = pgEnum("flux_onboarding_reason", [
+    "no_team",
+    "no_slack_channel",
+    "no_template",
+]);
+/**
+ * Tracks projects that need attention after import.
+ * Entries are created when a project is imported with missing team assignments,
+ * no Slack channel, or other incomplete setup. Auto-resolved when conditions are met.
+ */
+export const fluxProjectOnboardingQueue = pgTable("flux_project_onboarding_queue", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    projectId: varchar("project_id")
+        .notNull()
+        .references(() => fluxProjects.id),
+    reason: fluxOnboardingReasonEnum("reason").notNull(),
+    metadata: jsonb("metadata").default({}).$type(),
+    resolvedAt: timestamp("resolved_at"),
+    resolvedBy: varchar("resolved_by").references(() => fluxUsers.id),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+}, (table) => ({
+    projectIdx: index("flux_onboarding_queue_project_idx").on(table.projectId),
+    unresolvedIdx: index("flux_onboarding_queue_unresolved_idx")
+        .on(table.resolvedAt)
+        .where(sql `resolved_at IS NULL`),
+}));
+export const fluxProjectOnboardingQueueRelations = relations(fluxProjectOnboardingQueue, ({ one }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxProjectOnboardingQueue.projectId],
+        references: [fluxProjects.id],
+    }),
+    resolvedByUser: one(fluxUsers, {
+        fields: [fluxProjectOnboardingQueue.resolvedBy],
+        references: [fluxUsers.id],
+    }),
+}));
+// =============================================================================
+// SLA CONFIGURATION
+// =============================================================================
+/**
+ * Per-tier SLA thresholds (all values in business days).
+ * Tiers: Default (fallback), Tier 1, Tier 2, Tier 3.
+ * NUMERIC(4,1) allows half-day precision (e.g. 0.5 for the Ready stage).
+ */
+export const fluxSlaConfig = pgTable("flux_sla_config", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    tier: text("tier").notNull().unique(),
+    pendingFormDays: numeric("pending_form_days", { precision: 4, scale: 1 }),
+    submittedDays: numeric("submitted_days", { precision: 4, scale: 1 }),
+    pendingCreativeDays: numeric("pending_creative_days", { precision: 4, scale: 1 }),
+    pendingFulfillmentDays: numeric("pending_fulfillment_days", { precision: 4, scale: 1 }),
+    readyDays: numeric("ready_days", { precision: 4, scale: 1 }),
+    endToEndDays: numeric("end_to_end_days", { precision: 4, scale: 1 }),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedBy: text("updated_by"),
+});
+// ---------------------------------------------------------------------------
+// SLA Profiles (flexible JSONB thresholds, replaces fixed-column config)
+// ---------------------------------------------------------------------------
+/**
+ * SLA profiles with JSONB thresholds — supports named profiles for tiers,
+ * per-client overrides, and Compass SLA exceptions.
+ *
+ * Resolution chain: ticket override → project profile → default profile → hardcoded.
+ */
+export const fluxSlaProfiles = pgTable("flux_sla_profiles", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    name: text("name").notNull().unique(),
+    description: text("description"),
+    /** Exactly one profile should be marked default (enforced by partial unique index in migration) */
+    isDefault: boolean("is_default").notNull().default(false),
+    /**
+     * Stage thresholds in business days as JSONB:
+     * { pending_form: 1, submitted: 2, pending_creative: 2, pending_fulfillment: 1, ready: 0.5, end_to_end: 5 }
+     */
+    thresholds: jsonb("thresholds").notNull().default(sql `'{}'::jsonb`),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedBy: text("updated_by"),
+});
+/** Known SLA stage slugs for threshold validation */
+export const SLA_STAGE_SLUGS = [
+    "pending_form",
+    "submitted",
+    "pending_creative",
+    "pending_fulfillment",
+    "ready",
+    "end_to_end",
+];
+// ============================================================================
+// Agreement Tracking
+// ============================================================================
+/**
+ * Agreement tier: contract (annual commitment), io (per-order), approval (lightweight)
+ */
+export const fluxAgreementTierEnum = pgEnum("flux_agreement_tier", [
+    "contract",
+    "io",
+    "approval",
+]);
+/**
+ * Agreement lifecycle status
+ */
+export const fluxAgreementStatusEnum = pgEnum("flux_agreement_status", [
+    "draft",
+    "pending_internal",
+    "pending_client",
+    "pending_countersign",
+    "active",
+    "amended",
+    "expired",
+    "voided",
+]);
+/**
+ * Signer role in the signing workflow
+ */
+export const fluxSignerRoleEnum = pgEnum("flux_signer_role", [
+    "internal_approver",
+    "client_signer",
+    "counter_signer",
+]);
+/**
+ * Individual signer status
+ */
+export const fluxSignerStatusEnum = pgEnum("flux_signer_status", [
+    "pending",
+    "signed",
+    "declined",
+    "delegated",
+]);
+/**
+ * Agreements — tracks contracts, IOs, and approvals across their lifecycle.
+ * Links to projects, deals, fulfillment tickets, and Compass entities.
+ */
+export const fluxAgreements = pgTable("flux_agreements", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    tier: fluxAgreementTierEnum("tier").notNull(),
+    status: fluxAgreementStatusEnum("status").notNull().default("draft"),
+    projectId: text("project_id").references(() => fluxProjects.id),
+    dealId: text("deal_id").references(() => fluxDealPipeline.id),
+    hubspotDealId: text("hubspot_deal_id"),
+    fulfillmentTicketId: text("fulfillment_ticket_id").references(() => fluxFulfillmentTickets.id),
+    compassContractId: text("compass_contract_id"),
+    compassOrderId: text("compass_order_id"),
+    title: text("title").notNull(),
+    description: text("description"),
+    commitmentAmount: numeric("commitment_amount", { precision: 14, scale: 2 }),
+    tierCode: text("tier_code"),
+    currency: text("currency").default("USD"),
+    effectiveDate: date("effective_date"),
+    expirationDate: date("expiration_date"),
+    version: integer("version").notNull().default(1),
+    previousVersionId: text("previous_version_id").references(() => fluxAgreements.id),
+    amendmentReason: text("amendment_reason"),
+    documentUrl: text("document_url"),
+    documentFingerprint: text("document_fingerprint"),
+    documentFileName: text("document_file_name"),
+    esignProvider: text("esign_provider"),
+    esignEnvelopeId: text("esign_envelope_id"),
+    esignCallbackUrl: text("esign_callback_url"),
+    esignStatus: text("esign_status"),
+    hubspotPropertySyncedAt: timestamp("hubspot_property_synced_at", {
+        withTimezone: true,
+    }),
+    slackChannelId: text("slack_channel_id"),
+    slackMessageTs: text("slack_message_ts"),
+    healthScore: integer("health_score"),
+    complianceStatus: text("compliance_status"),
+    riskIndicators: jsonb("risk_indicators").default([]),
+    metadata: jsonb("metadata").default({}),
+    createdById: text("created_by_id").references(() => fluxUsers.id),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+export const fluxAgreementsRelations = relations(fluxAgreements, ({ one, many }) => ({
+    project: one(fluxProjects, {
+        fields: [fluxAgreements.projectId],
+        references: [fluxProjects.id],
+    }),
+    deal: one(fluxDealPipeline, {
+        fields: [fluxAgreements.dealId],
+        references: [fluxDealPipeline.id],
+    }),
+    fulfillmentTicket: one(fluxFulfillmentTickets, {
+        fields: [fluxAgreements.fulfillmentTicketId],
+        references: [fluxFulfillmentTickets.id],
+    }),
+    previousVersion: one(fluxAgreements, {
+        fields: [fluxAgreements.previousVersionId],
+        references: [fluxAgreements.id],
+    }),
+    createdBy: one(fluxUsers, {
+        fields: [fluxAgreements.createdById],
+        references: [fluxUsers.id],
+    }),
+    signers: many(fluxAgreementSigners),
+    activity: many(fluxAgreementActivity),
+}));
+/**
+ * Agreement signers — tracks each signer in the signing workflow.
+ * Supports delegation and e-signature provider integration.
+ */
+export const fluxAgreementSigners = pgTable("flux_agreement_signers", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    agreementId: text("agreement_id")
+        .notNull()
+        .references(() => fluxAgreements.id, { onDelete: "cascade" }),
+    role: fluxSignerRoleEnum("role").notNull(),
+    status: fluxSignerStatusEnum("status").notNull().default("pending"),
+    displayOrder: integer("display_order").notNull().default(0),
+    fluxUserId: text("flux_user_id").references(() => fluxUsers.id),
+    contactEmail: text("contact_email"),
+    contactName: text("contact_name"),
+    hubspotContactId: text("hubspot_contact_id"),
+    signedAt: timestamp("signed_at", { withTimezone: true }),
+    signedVia: text("signed_via"),
+    signedIpAddress: text("signed_ip_address"),
+    attestationNote: text("attestation_note"),
+    delegatedToId: text("delegated_to_id").references(() => fluxAgreementSigners.id),
+    delegatedReason: text("delegated_reason"),
+    esignRecipientId: text("esign_recipient_id"),
+    esignSignedAt: timestamp("esign_signed_at", { withTimezone: true }),
+    declinedAt: timestamp("declined_at", { withTimezone: true }),
+    declinedReason: text("declined_reason"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+export const fluxAgreementSignersRelations = relations(fluxAgreementSigners, ({ one }) => ({
+    agreement: one(fluxAgreements, {
+        fields: [fluxAgreementSigners.agreementId],
+        references: [fluxAgreements.id],
+    }),
+    fluxUser: one(fluxUsers, {
+        fields: [fluxAgreementSigners.fluxUserId],
+        references: [fluxUsers.id],
+    }),
+    delegatedTo: one(fluxAgreementSigners, {
+        fields: [fluxAgreementSigners.delegatedToId],
+        references: [fluxAgreementSigners.id],
+    }),
+}));
+/**
+ * Agreement activity — immutable audit log for agreement lifecycle events.
+ * No updatedAt column — entries are append-only.
+ */
+export const fluxAgreementActivity = pgTable("flux_agreement_activity", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    agreementId: text("agreement_id")
+        .notNull()
+        .references(() => fluxAgreements.id, { onDelete: "cascade" }),
+    action: text("action").notNull(),
+    actorId: text("actor_id").references(() => fluxUsers.id),
+    actorName: text("actor_name"),
+    actorEmail: text("actor_email"),
+    details: jsonb("details").default({}),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+export const fluxAgreementActivityRelations = relations(fluxAgreementActivity, ({ one }) => ({
+    agreement: one(fluxAgreements, {
+        fields: [fluxAgreementActivity.agreementId],
+        references: [fluxAgreements.id],
+    }),
+    actor: one(fluxUsers, {
+        fields: [fluxAgreementActivity.actorId],
+        references: [fluxUsers.id],
+    }),
+}));
+// ============================================================================
+// E-Sign Configuration
+// ============================================================================
+/**
+ * Per-tier e-sign configuration — controls which Firma template to use,
+ * default VP signers for auto-assignment, and signing mode (template vs embedded).
+ */
+export const fluxEsignConfig = pgTable("flux_esign_config", {
+    id: text("id").primaryKey().default(sql `gen_random_uuid()::text`),
+    tier: fluxAgreementTierEnum("tier").notNull().unique(),
+    firmaTemplateId: text("firma_template_id"),
+    defaultVpSignerIds: text("default_vp_signer_ids")
+        .array()
+        .notNull()
+        .default(sql `'{}'`),
+    autoSend: boolean("auto_send").notNull().default(true),
+    /** 'template' = full doc generation from Firma template; 'embedded' = lightweight iframe signing */
+    signingMode: text("signing_mode").notNull().default("template"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+// =============================================================================
+// TAPCLICKS ARCHIVE (historical data from legacy TapClicks system)
+// =============================================================================
+/**
+ * Historical orders from TapClicks Orders & Workflow.
+ * One-time import of ~27K orders (last 12 months).
+ * Indexed search columns + raw_json JSONB for full detail.
+ */
+export const fluxTapclicksOrders = pgTable("flux_tapclicks_orders", {
+    id: serial("id").primaryKey(),
+    tapId: integer("tap_id").notNull().unique(),
+    orderName: text("order_name"),
+    clientName: text("client_name"),
+    clientTapId: integer("client_tap_id"),
+    salesRep: text("sales_rep"),
+    status: text("status"),
+    workflowStep: text("workflow_step"),
+    orderType: text("order_type"),
+    totalBudget: numeric("total_budget"),
+    startDate: date("start_date"),
+    endDate: date("end_date"),
+    dfpOrderId: text("dfp_order_id"),
+    lineItemCount: integer("line_item_count"),
+    rawJson: jsonb("raw_json").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    tapCreatedAt: timestamp("tap_created_at", { withTimezone: true }),
+    tapUpdatedAt: timestamp("tap_updated_at", { withTimezone: true }),
+}, (table) => ({
+    tapIdIdx: uniqueIndex("flux_tapclicks_orders_tap_id_idx").on(table.tapId),
+    clientNameIdx: index("flux_tapclicks_orders_client_name_idx").on(table.clientName),
+    salesRepIdx: index("flux_tapclicks_orders_sales_rep_idx").on(table.salesRep),
+    statusIdx: index("flux_tapclicks_orders_status_idx").on(table.status),
+    startDateIdx: index("flux_tapclicks_orders_start_date_idx").on(table.startDate),
+    endDateIdx: index("flux_tapclicks_orders_end_date_idx").on(table.endDate),
+}));
+/**
+ * Historical line items from TapClicks.
+ * Each order contains ~5-10 line items with product, rate, targeting, and GAM details.
+ */
+export const fluxTapclicksLineItems = pgTable("flux_tapclicks_line_items", {
+    id: serial("id").primaryKey(),
+    tapId: integer("tap_id").notNull().unique(),
+    tapOrderId: integer("tap_order_id").notNull(),
+    campaignName: text("campaign_name"),
+    productName: text("product_name"),
+    subProductName: text("sub_product_name"),
+    status: text("status"),
+    workflowStep: text("workflow_step"),
+    startDate: date("start_date"),
+    endDate: date("end_date"),
+    rate: numeric("rate"),
+    floorRate: numeric("floor_rate"),
+    rateType: text("rate_type"),
+    impressions: integer("impressions"),
+    totalCost: numeric("total_cost"),
+    creativeOptions: text("creative_options"),
+    dfpLineItemId: text("dfp_line_item_id"),
+    namingConvention: text("naming_convention"),
+    rawJson: jsonb("raw_json").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    tapCreatedAt: timestamp("tap_created_at", { withTimezone: true }),
+    tapUpdatedAt: timestamp("tap_updated_at", { withTimezone: true }),
+}, (table) => ({
+    tapIdIdx: uniqueIndex("flux_tapclicks_line_items_tap_id_idx").on(table.tapId),
+    tapOrderIdIdx: index("flux_tapclicks_line_items_order_idx").on(table.tapOrderId),
+    productNameIdx: index("flux_tapclicks_line_items_product_idx").on(table.productName),
+    statusIdx: index("flux_tapclicks_line_items_status_idx").on(table.status),
+    startDateIdx: index("flux_tapclicks_line_items_start_date_idx").on(table.startDate),
+}));
+/**
+ * Historical clients/advertisers from TapClicks.
+ */
+export const fluxTapclicksClients = pgTable("flux_tapclicks_clients", {
+    id: serial("id").primaryKey(),
+    tapId: integer("tap_id").notNull().unique(),
+    companyName: text("company_name"),
+    crmId: text("crm_id"),
+    billingId: text("billing_id"),
+    iotoolStatus: text("iotool_status"),
+    city: text("city"),
+    state: text("state"),
+    rawJson: jsonb("raw_json").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    tapIdIdx: uniqueIndex("flux_tapclicks_clients_tap_id_idx").on(table.tapId),
+    companyNameIdx: index("flux_tapclicks_clients_company_name_idx").on(table.companyName),
+    iotoolStatusIdx: index("flux_tapclicks_clients_status_idx").on(table.iotoolStatus),
+}));
+// =============================================================================
+// TAPCLICKS → COMPASS PREFILL PIPELINE
+// =============================================================================
+/**
+ * Admin-managed mapping of TapClicks product names → Compass product codes.
+ * Used by the preparePrefillToken tool to translate line items.
+ */
+export const fluxTapclicksProductMap = pgTable("flux_tapclicks_product_map", {
+    id: serial("id").primaryKey(),
+    tapclicksProductName: text("tapclicks_product_name").notNull().unique(),
+    stribProductCode: text("strib_product_code").notNull(),
+    stribProductId: text("strib_product_id"),
+    stribProductName: text("strib_product_name").notNull(),
+    pricingModel: text("pricing_model").notNull(),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+});
+/**
+ * Short-lived prefill tokens for the TapClicks → Compass order bridge.
+ * UUID PK, 1-hour TTL. Compass reads the payload via CORS-enabled GET endpoint.
+ */
+export const fluxOrderPrefillTokens = pgTable("flux_order_prefill_tokens", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    createdByUserId: text("created_by_user_id").notNull(),
+    clientName: text("client_name").notNull(),
+    hubspotCompanyId: text("hubspot_company_id"),
+    flightStart: text("flight_start"),
+    flightEnd: text("flight_end"),
+    geo: text("geo"),
+    lineItems: jsonb("line_items").notNull(),
+    metadata: jsonb("metadata"),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    expiresAtIdx: index("flux_order_prefill_tokens_expires_at_idx").on(table.expiresAt),
+}));
+// =============================================================================
+// AI USAGE TRACKING
+// =============================================================================
+/**
+ * AI usage log — tracks AI provider API calls for cost visibility
+ * and sliding-window rate limiting.
+ *
+ * Streaming endpoints insert a placeholder row pre-stream (for rate limit counting),
+ * then update with final token counts in onFinish. Non-streaming endpoints do
+ * a single insert after the response is parsed.
+ */
+export const fluxAiUsage = pgTable("flux_ai_usage", {
+    id: text("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()::text`),
+    userId: text("user_id").notNull(),
+    endpoint: text("endpoint").notNull(),
+    model: text("model").notNull(),
+    inputTokens: integer("input_tokens"),
+    outputTokens: integer("output_tokens"),
+    totalTokens: integer("total_tokens"),
+    /** Cost in microdollars (millionths of USD) — avoids floating-point drift */
+    estimatedCostUsdMicro: integer("estimated_cost_usd_micro"),
+    durationMs: integer("duration_ms"),
+    metadata: jsonb("metadata"),
+    sourceApp: text("source_app").notNull().default("fn-flux"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    userCreatedAtIdx: index("flux_ai_usage_user_created_at_idx").on(table.userId, table.createdAt),
+    endpointCreatedAtIdx: index("flux_ai_usage_endpoint_created_at_idx").on(table.endpoint, table.createdAt),
+    sourceAppCreatedAtIdx: index("flux_ai_usage_source_app_idx").on(table.sourceApp, table.createdAt),
+}));
+// ---------------------------------------------------------------------------
+// TapClicks Services — registry of all connected data services
+// ---------------------------------------------------------------------------
+export const fluxTapclicksServices = pgTable("flux_tapclicks_services", {
+    id: serial("id").primaryKey(),
+    serviceId: text("service_id").notNull().unique(),
+    serviceName: text("service_name").notNull(),
+    platform: text("platform"),
+    category: text("category"),
+    impressionColumn: text("impression_column"),
+    clickColumn: text("click_column"),
+    spendColumn: text("spend_column"),
+    adUnitColumn: text("ad_unit_column"),
+    advertiserColumn: text("advertiser_column"),
+    campaignColumn: text("campaign_column"),
+    dateColumn: text("date_column"),
+    isActive: boolean("is_active").notNull().default(false),
+    syncFrequency: text("sync_frequency").default("daily").notNull(),
+    lastSyncAt: timestamp("last_sync_at", { withTimezone: true }),
+    lastSyncStatus: text("last_sync_status"),
+    lastSyncError: text("last_sync_error"),
+    lastSyncRowCount: integer("last_sync_row_count"),
+    columnMetadata: jsonb("column_metadata"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    serviceIdIdx: uniqueIndex("flux_tapclicks_services_service_id_idx").on(table.serviceId),
+    platformIdx: index("flux_tapclicks_services_platform_idx").on(table.platform),
+    categoryIdx: index("flux_tapclicks_services_category_idx").on(table.category),
+    isActiveIdx: index("flux_tapclicks_services_is_active_idx").on(table.isActive),
+}));
+// ---------------------------------------------------------------------------
+// TapClicks Delivery — daily delivery snapshots from all platforms
+// ---------------------------------------------------------------------------
+export const fluxTapclicksDelivery = pgTable("flux_tapclicks_delivery", {
+    id: serial("id").primaryKey(),
+    serviceId: text("service_id").notNull(),
+    serviceName: text("service_name"),
+    platform: text("platform"),
+    campaignId: text("campaign_id"),
+    campaignName: text("campaign_name"),
+    adUnit: text("ad_unit"),
+    advertiser: text("advertiser"),
+    date: date("date").notNull(),
+    impressions: integer("impressions").default(0),
+    clicks: integer("clicks"),
+    spend: numeric("spend", { precision: 12, scale: 2 }),
+    ctr: numeric("ctr", { precision: 8, scale: 6 }),
+    rawData: jsonb("raw_data"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    serviceIdIdx: index("flux_tapclicks_delivery_service_id_idx").on(table.serviceId),
+    campaignIdIdx: index("flux_tapclicks_delivery_campaign_id_idx").on(table.campaignId),
+    dateIdx: index("flux_tapclicks_delivery_date_idx").on(table.date),
+    advertiserIdx: index("flux_tapclicks_delivery_advertiser_idx").on(table.advertiser),
+    platformIdx: index("flux_tapclicks_delivery_platform_idx").on(table.platform),
+    serviceDateUniqueIdx: uniqueIndex("flux_tapclicks_delivery_unique_idx").on(table.serviceId, table.campaignId, table.adUnit, table.date),
+}));
+// ---------------------------------------------------------------------------
+// TapClicks Pacing — computed pacing status per active line item
+// ---------------------------------------------------------------------------
+export const fluxTapclicksPacing = pgTable("flux_tapclicks_pacing", {
+    id: serial("id").primaryKey(),
+    lineItemTapId: integer("line_item_tap_id"),
+    orderTapId: integer("order_tap_id"),
+    serviceId: text("service_id"),
+    clientName: text("client_name"),
+    campaignName: text("campaign_name"),
+    productName: text("product_name"),
+    advertiser: text("advertiser"),
+    startDate: date("start_date"),
+    endDate: date("end_date"),
+    impressionGoal: integer("impression_goal"),
+    deliveredImpressions: integer("delivered_impressions").notNull().default(0),
+    expectedImpressions: integer("expected_impressions"),
+    pacingPercent: numeric("pacing_percent", { precision: 8, scale: 2 }),
+    pacingStatus: text("pacing_status"),
+    dailyVelocity: numeric("daily_velocity", { precision: 12, scale: 2 }),
+    velocityTrend: text("velocity_trend"),
+    daysRemaining: integer("days_remaining"),
+    requiredDailyRate: integer("required_daily_rate"),
+    projectedEndImpressions: integer("projected_end_impressions"),
+    lastDeliveryDate: date("last_delivery_date"),
+    lastAlertAt: timestamp("last_alert_at", { withTimezone: true }),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    lineItemTapIdIdx: uniqueIndex("flux_tapclicks_pacing_line_item_idx").on(table.lineItemTapId),
+    orderTapIdIdx: index("flux_tapclicks_pacing_order_idx").on(table.orderTapId),
+    pacingStatusIdx: index("flux_tapclicks_pacing_status_idx").on(table.pacingStatus),
+    clientNameIdx: index("flux_tapclicks_pacing_client_idx").on(table.clientName),
+    endDateIdx: index("flux_tapclicks_pacing_end_date_idx").on(table.endDate),
+}));
+// =============================================================================
+// CREATIVE–DELIVERY CORRELATION (Initiative 5: True North Intelligence)
+// =============================================================================
+export const fluxCreativeDeliveryCorrelation = pgTable("flux_creative_delivery_correlation", {
+    id: serial("id").primaryKey(),
+    correlationType: text("correlation_type").notNull(),
+    segmentKey: text("segment_key").notNull(),
+    sampleSize: integer("sample_size").notNull(),
+    avgFillRate: numeric("avg_fill_rate", { precision: 8, scale: 4 }),
+    avgReadinessScore: numeric("avg_readiness_score", { precision: 6, scale: 2 }),
+    correlation: numeric("correlation", { precision: 6, scale: 4 }),
+    insight: text("insight"),
+    metadata: jsonb("metadata"),
+    computedAt: timestamp("computed_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    typeSegmentIdx: uniqueIndex("flux_creative_delivery_corr_type_segment_idx").on(table.correlationType, table.segmentKey),
+    typeIdx: index("flux_creative_delivery_corr_type_idx").on(table.correlationType),
+    computedAtIdx: index("flux_creative_delivery_corr_computed_idx").on(table.computedAt),
+}));
+// =============================================================================
+// GAM COMPLIANCE AUDIT — audience segment targeting compliance per line item
+// =============================================================================
+export const fluxComplianceAudit = pgTable("flux_compliance_audit", {
+    id: serial("id").primaryKey(),
+    lineItemId: text("line_item_id").notNull(),
+    lineItemName: text("line_item_name"),
+    orderId: text("order_id"),
+    orderName: text("order_name"),
+    lineItemStatus: text("line_item_status"),
+    audienceSegmentId: text("audience_segment_id").notNull(),
+    isCompliant: boolean("is_compliant").notNull(),
+    isExempt: boolean("is_exempt").notNull().default(false),
+    exemptReason: text("exempt_reason"),
+    auditedAt: timestamp("audited_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    lineItemAuditIdx: uniqueIndex("flux_compliance_audit_li_seg_idx").on(table.lineItemId, table.audienceSegmentId),
+    auditedAtIdx: index("flux_compliance_audit_date_idx").on(table.auditedAt),
+    complianceIdx: index("flux_compliance_audit_compliant_idx").on(table.isCompliant),
+}));
+// =============================================================================
+// WEBHOOK EVENT DEDUP — DB-backed idempotency for HubSpot (and other) webhooks
+// =============================================================================
+export const fluxWebhookEvents = pgTable("flux_webhook_events", {
+    eventId: varchar("event_id").primaryKey(),
+    source: varchar("source", { length: 32 }).notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    sourceProcessedIdx: index("flux_webhook_events_source_processed_idx").on(table.source, table.processedAt),
+}));
+// =============================================================================
+// ASSISTANT TELEMETRY — tracks docs/assistant interactions for learning loops
+// =============================================================================
+export const fluxAssistantTelemetry = pgTable("flux_assistant_telemetry", {
+    id: varchar("id")
+        .primaryKey()
+        .default(sql `gen_random_uuid()`),
+    clerkUserId: varchar("clerk_user_id").notNull(),
+    eventType: varchar("event_type", { length: 64 }).notNull(),
+    surfaceId: varchar("surface_id", { length: 64 }),
+    query: text("query"),
+    resultId: text("result_id"),
+    metadata: jsonb("metadata"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+}, (table) => ({
+    userEventIdx: index("flux_assistant_telemetry_user_event_idx").on(table.clerkUserId, table.eventType),
+    surfaceCreatedIdx: index("flux_assistant_telemetry_surface_created_idx").on(table.surfaceId, table.createdAt),
+}));
+// =============================================================================
+// COCKPIT: CRON RUN TRACKING
+// =============================================================================
+export const fluxCronRuns = pgTable("flux_cron_runs", {
+    id: varchar("id", { length: 36 })
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    cronPath: varchar("cron_path", { length: 255 }).notNull(),
+    app: varchar("app", { length: 50 }).notNull().default("fn-flux"),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    status: varchar("status", { length: 20 }).notNull().default("running"),
+    durationMs: integer("duration_ms"),
+    recordsProcessed: integer("records_processed"),
+    error: text("error"),
+    metadata: jsonb("metadata"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    pathStartedIdx: index("idx_flux_cron_runs_path_started").on(table.cronPath, table.startedAt),
+    statusIdx: index("idx_flux_cron_runs_status").on(table.status),
+}));
+// =============================================================================
+// TRIGGER.DEV: TASK RUN LOG
+// =============================================================================
+export const fluxTriggerRunLog = pgTable("flux_trigger_run_log", {
+    id: varchar("id", { length: 36 })
+        .primaryKey()
+        .$defaultFn(() => crypto.randomUUID()),
+    taskIdentifier: varchar("task_identifier", { length: 100 }).notNull(),
+    runId: varchar("run_id", { length: 100 }).notNull(),
+    status: varchar("status", { length: 30 }).notNull(),
+    startedAt: timestamp("started_at", { withTimezone: true }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    durationMs: integer("duration_ms"),
+    resultSummary: jsonb("result_summary"),
+    errorMessage: text("error_message"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({
+    taskStartedIdx: index("idx_flux_trigger_run_log_task_started").on(table.taskIdentifier, table.startedAt),
+    runIdIdx: index("idx_flux_trigger_run_log_run_id").on(table.runId),
+    statusIdx: index("idx_flux_trigger_run_log_status").on(table.status),
+}));
+//# sourceMappingURL=schema.js.map