thinkwork-cli 0.12.12 → 0.12.15

package/dist/drizzle/0106_space_threads_participants.sql

@@ -0,0 +1,197 @@
+-- Purpose: attach threads to Spaces and add human/agent thread participants.
+-- Plan: docs/plans/2026-05-19-003-feat-spaces-customer-onboarding-v1-plan.md (U3)
+-- Apply manually: psql "$DATABASE_URL" -v ON_ERROR_STOP=1 -f packages/database-pg/drizzle/0106_space_threads_participants.sql
+-- creates-column: public.threads.space_id
+-- creates: public.idx_threads_tenant_space_updated
+-- creates: public.thread_participants
+-- creates: public.uq_thread_participants_user
+-- creates: public.uq_thread_participants_agent
+-- creates: public.idx_thread_participants_thread
+-- creates: public.idx_thread_participants_space
+-- creates-function: public.enforce_thread_participant_tenant
+-- creates-function: public.enforce_thread_space_tenant
+-- creates-trigger: public.thread_participants.thread_participants_tenant_guard
+-- creates-trigger: public.threads.threads_space_tenant_guard
+-- creates-constraint: public.threads.threads_space_id_spaces_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_tenant_id_tenants_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_thread_id_threads_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_space_id_spaces_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_user_id_users_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_agent_id_agents_id_fk
+-- creates-constraint: public.thread_participants.thread_participants_type_allowed
+-- creates-constraint: public.thread_participants.thread_participants_target_matches_type
+-- creates-constraint: public.thread_participants.thread_participants_notification_preference_allowed
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+ALTER TABLE public.threads
+  ADD COLUMN IF NOT EXISTS space_id uuid;
+
+DO $$
+BEGIN
+  ALTER TABLE public.threads
+    ADD CONSTRAINT threads_space_id_spaces_id_fk
+    FOREIGN KEY (space_id)
+    REFERENCES public.spaces(id)
+    ON DELETE SET NULL;
+EXCEPTION
+  WHEN duplicate_object THEN NULL;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_threads_tenant_space_updated
+  ON public.threads (tenant_id, space_id, updated_at DESC)
+  WHERE space_id IS NOT NULL;
+
+CREATE OR REPLACE FUNCTION public.enforce_thread_space_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  target_tenant_id uuid;
+BEGIN
+  IF NEW.space_id IS NULL THEN
+    RETURN NEW;
+  END IF;
+
+  SELECT tenant_id INTO target_tenant_id
+  FROM public.spaces
+  WHERE id = NEW.space_id;
+
+  IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'thread space tenant mismatch for space %', NEW.space_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS threads_space_tenant_guard
+  ON public.threads;
+
+CREATE TRIGGER threads_space_tenant_guard
+  BEFORE INSERT OR UPDATE OF tenant_id, space_id
+  ON public.threads
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_thread_space_tenant();
+
+CREATE TABLE IF NOT EXISTS public.thread_participants (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL,
+  thread_id uuid NOT NULL,
+  space_id uuid,
+  participant_type text NOT NULL,
+  user_id uuid,
+  agent_id uuid,
+  role text NOT NULL DEFAULT 'member',
+  source text NOT NULL DEFAULT 'manual',
+  notification_preference text NOT NULL DEFAULT 'subscribed',
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT thread_participants_tenant_id_tenants_id_fk
+    FOREIGN KEY (tenant_id)
+    REFERENCES public.tenants(id)
+    ON DELETE CASCADE,
+  CONSTRAINT thread_participants_thread_id_threads_id_fk
+    FOREIGN KEY (thread_id)
+    REFERENCES public.threads(id)
+    ON DELETE CASCADE,
+  CONSTRAINT thread_participants_space_id_spaces_id_fk
+    FOREIGN KEY (space_id)
+    REFERENCES public.spaces(id)
+    ON DELETE SET NULL,
+  CONSTRAINT thread_participants_user_id_users_id_fk
+    FOREIGN KEY (user_id)
+    REFERENCES public.users(id)
+    ON DELETE CASCADE,
+  CONSTRAINT thread_participants_agent_id_agents_id_fk
+    FOREIGN KEY (agent_id)
+    REFERENCES public.agents(id)
+    ON DELETE CASCADE,
+  CONSTRAINT thread_participants_type_allowed
+    CHECK (participant_type IN ('user', 'agent')),
+  CONSTRAINT thread_participants_target_matches_type
+    CHECK (
+      (participant_type = 'user' AND user_id IS NOT NULL AND agent_id IS NULL)
+      OR
+      (participant_type = 'agent' AND agent_id IS NOT NULL AND user_id IS NULL)
+    ),
+  CONSTRAINT thread_participants_notification_preference_allowed
+    CHECK (notification_preference IN ('subscribed', 'mentions', 'muted'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_thread_participants_user
+  ON public.thread_participants (tenant_id, thread_id, user_id)
+  WHERE user_id IS NOT NULL;
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_thread_participants_agent
+  ON public.thread_participants (tenant_id, thread_id, agent_id)
+  WHERE agent_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_thread_participants_thread
+  ON public.thread_participants (thread_id);
+
+CREATE INDEX IF NOT EXISTS idx_thread_participants_space
+  ON public.thread_participants (tenant_id, space_id);
+
+CREATE OR REPLACE FUNCTION public.enforce_thread_participant_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  target_tenant_id uuid;
+  target_space_id uuid;
+BEGIN
+  SELECT tenant_id, space_id INTO target_tenant_id, target_space_id
+  FROM public.threads
+  WHERE id = NEW.thread_id;
+
+  IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'thread participant tenant mismatch for thread %', NEW.thread_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  IF NEW.space_id IS DISTINCT FROM target_space_id THEN
+    RAISE EXCEPTION 'thread participant space mismatch for thread %', NEW.thread_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  IF NEW.participant_type = 'user' THEN
+    SELECT tenant_id INTO target_tenant_id
+    FROM public.users
+    WHERE id = NEW.user_id;
+
+    IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+      RAISE EXCEPTION 'thread participant tenant mismatch for user %', NEW.user_id
+        USING ERRCODE = '23514';
+    END IF;
+  ELSIF NEW.participant_type = 'agent' THEN
+    SELECT tenant_id INTO target_tenant_id
+    FROM public.agents
+    WHERE id = NEW.agent_id;
+
+    IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+      RAISE EXCEPTION 'thread participant tenant mismatch for agent %', NEW.agent_id
+        USING ERRCODE = '23514';
+    END IF;
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS thread_participants_tenant_guard
+  ON public.thread_participants;
+
+CREATE TRIGGER thread_participants_tenant_guard
+  BEFORE INSERT OR UPDATE
+  ON public.thread_participants
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_thread_participant_tenant();
+
+COMMIT;

package/dist/drizzle/0107_linked_task_mirror.sql

@@ -0,0 +1,245 @@
+-- Purpose: add ThinkWork-side linked task mirror tables for Space Threads.
+-- Plan: docs/plans/2026-05-19-003-feat-spaces-customer-onboarding-v1-plan.md (U4)
+-- Apply manually: psql "$DATABASE_URL" -v ON_ERROR_STOP=1 -f packages/database-pg/drizzle/0107_linked_task_mirror.sql
+-- creates: public.linked_tasks
+-- creates: public.linked_task_events
+-- creates: public.uq_linked_tasks_external
+-- creates: public.uq_linked_tasks_checklist_item
+-- creates: public.idx_linked_tasks_thread
+-- creates: public.idx_linked_tasks_space
+-- creates: public.uq_linked_task_events_external
+-- creates: public.idx_linked_task_events_task
+-- creates: public.idx_linked_task_events_thread
+-- creates-function: public.enforce_linked_task_tenant
+-- creates-function: public.enforce_linked_task_event_tenant
+-- creates-trigger: public.linked_tasks.linked_tasks_tenant_guard
+-- creates-trigger: public.linked_task_events.linked_task_events_tenant_guard
+-- creates-constraint: public.linked_tasks.linked_tasks_tenant_id_tenants_id_fk
+-- creates-constraint: public.linked_tasks.linked_tasks_space_id_spaces_id_fk
+-- creates-constraint: public.linked_tasks.linked_tasks_thread_id_threads_id_fk
+-- creates-constraint: public.linked_tasks.linked_tasks_checklist_item_id_space_checklist_items_id_fk
+-- creates-constraint: public.linked_tasks.linked_tasks_provider_allowed
+-- creates-constraint: public.linked_tasks.linked_tasks_status_allowed
+-- creates-constraint: public.linked_tasks.linked_tasks_sync_status_allowed
+-- creates-constraint: public.linked_task_events.linked_task_events_tenant_id_tenants_id_fk
+-- creates-constraint: public.linked_task_events.linked_task_events_linked_task_id_linked_tasks_id_fk
+-- creates-constraint: public.linked_task_events.linked_task_events_space_id_spaces_id_fk
+-- creates-constraint: public.linked_task_events.linked_task_events_thread_id_threads_id_fk
+-- creates-constraint: public.linked_task_events.linked_task_events_provider_allowed
+-- creates-constraint: public.linked_task_events.linked_task_events_type_allowed
+-- creates-constraint: public.linked_task_events.linked_task_events_previous_status_allowed
+-- creates-constraint: public.linked_task_events.linked_task_events_new_status_allowed
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+CREATE TABLE IF NOT EXISTS public.linked_tasks (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL,
+  space_id uuid NOT NULL,
+  thread_id uuid NOT NULL,
+  checklist_item_id uuid,
+  provider text NOT NULL DEFAULT 'lastmile',
+  external_task_id text NOT NULL,
+  external_task_url text,
+  title text NOT NULL,
+  required boolean NOT NULL DEFAULT true,
+  role_key text,
+  assignee_display text,
+  assignee_external_id text,
+  status text NOT NULL DEFAULT 'unknown',
+  blocked boolean NOT NULL DEFAULT false,
+  sync_status text NOT NULL DEFAULT 'pending',
+  last_synced_at timestamptz,
+  metadata jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT linked_tasks_tenant_id_tenants_id_fk
+    FOREIGN KEY (tenant_id)
+    REFERENCES public.tenants(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_tasks_space_id_spaces_id_fk
+    FOREIGN KEY (space_id)
+    REFERENCES public.spaces(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_tasks_thread_id_threads_id_fk
+    FOREIGN KEY (thread_id)
+    REFERENCES public.threads(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_tasks_checklist_item_id_space_checklist_items_id_fk
+    FOREIGN KEY (checklist_item_id)
+    REFERENCES public.space_checklist_items(id)
+    ON DELETE SET NULL,
+  CONSTRAINT linked_tasks_provider_allowed
+    CHECK (provider IN ('lastmile')),
+  CONSTRAINT linked_tasks_status_allowed
+    CHECK (status IN ('unknown', 'todo', 'in_progress', 'completed', 'blocked', 'cancelled')),
+  CONSTRAINT linked_tasks_sync_status_allowed
+    CHECK (sync_status IN ('pending', 'synced', 'warning', 'error'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_linked_tasks_external
+  ON public.linked_tasks (tenant_id, provider, external_task_id);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_linked_tasks_checklist_item
+  ON public.linked_tasks (tenant_id, thread_id, checklist_item_id)
+  WHERE checklist_item_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_linked_tasks_thread
+  ON public.linked_tasks (tenant_id, thread_id);
+
+CREATE INDEX IF NOT EXISTS idx_linked_tasks_space
+  ON public.linked_tasks (tenant_id, space_id);
+
+CREATE TABLE IF NOT EXISTS public.linked_task_events (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL,
+  linked_task_id uuid NOT NULL,
+  space_id uuid NOT NULL,
+  thread_id uuid NOT NULL,
+  provider text NOT NULL DEFAULT 'lastmile',
+  event_type text NOT NULL,
+  external_event_id text,
+  previous_status text,
+  new_status text,
+  message text,
+  metadata jsonb,
+  occurred_at timestamptz NOT NULL DEFAULT now(),
+  created_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT linked_task_events_tenant_id_tenants_id_fk
+    FOREIGN KEY (tenant_id)
+    REFERENCES public.tenants(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_task_events_linked_task_id_linked_tasks_id_fk
+    FOREIGN KEY (linked_task_id)
+    REFERENCES public.linked_tasks(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_task_events_space_id_spaces_id_fk
+    FOREIGN KEY (space_id)
+    REFERENCES public.spaces(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_task_events_thread_id_threads_id_fk
+    FOREIGN KEY (thread_id)
+    REFERENCES public.threads(id)
+    ON DELETE CASCADE,
+  CONSTRAINT linked_task_events_provider_allowed
+    CHECK (provider IN ('lastmile')),
+  CONSTRAINT linked_task_events_type_allowed
+    CHECK (event_type IN ('created', 'completed', 'blocked', 'reassigned', 'due_date_changed', 'sync_failed', 'writeback_posted')),
+  CONSTRAINT linked_task_events_previous_status_allowed
+    CHECK (previous_status IS NULL OR previous_status IN ('unknown', 'todo', 'in_progress', 'completed', 'blocked', 'cancelled')),
+  CONSTRAINT linked_task_events_new_status_allowed
+    CHECK (new_status IS NULL OR new_status IN ('unknown', 'todo', 'in_progress', 'completed', 'blocked', 'cancelled'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_linked_task_events_external
+  ON public.linked_task_events (tenant_id, provider, external_event_id)
+  WHERE external_event_id IS NOT NULL;
+
+CREATE INDEX IF NOT EXISTS idx_linked_task_events_task
+  ON public.linked_task_events (linked_task_id);
+
+CREATE INDEX IF NOT EXISTS idx_linked_task_events_thread
+  ON public.linked_task_events (tenant_id, thread_id);
+
+CREATE OR REPLACE FUNCTION public.enforce_linked_task_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  target_tenant_id uuid;
+  target_space_id uuid;
+BEGIN
+  SELECT tenant_id, space_id INTO target_tenant_id, target_space_id
+  FROM public.threads
+  WHERE id = NEW.thread_id;
+
+  IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'linked task tenant mismatch for thread %', NEW.thread_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  IF target_space_id IS NULL OR target_space_id <> NEW.space_id THEN
+    RAISE EXCEPTION 'linked task space mismatch for thread %', NEW.thread_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  SELECT tenant_id INTO target_tenant_id
+  FROM public.spaces
+  WHERE id = NEW.space_id;
+
+  IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'linked task tenant mismatch for space %', NEW.space_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  IF NEW.checklist_item_id IS NOT NULL THEN
+    SELECT tenant_id, space_id INTO target_tenant_id, target_space_id
+    FROM public.space_checklist_items
+    WHERE id = NEW.checklist_item_id;
+
+    IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+      RAISE EXCEPTION 'linked task tenant mismatch for checklist item %', NEW.checklist_item_id
+        USING ERRCODE = '23514';
+    END IF;
+
+    IF target_space_id <> NEW.space_id THEN
+      RAISE EXCEPTION 'linked task space mismatch for checklist item %', NEW.checklist_item_id
+        USING ERRCODE = '23514';
+    END IF;
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS linked_tasks_tenant_guard
+  ON public.linked_tasks;
+
+CREATE TRIGGER linked_tasks_tenant_guard
+  BEFORE INSERT OR UPDATE
+  ON public.linked_tasks
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_linked_task_tenant();
+
+CREATE OR REPLACE FUNCTION public.enforce_linked_task_event_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  target_tenant_id uuid;
+  target_space_id uuid;
+  target_thread_id uuid;
+BEGIN
+  SELECT tenant_id, space_id, thread_id INTO target_tenant_id, target_space_id, target_thread_id
+  FROM public.linked_tasks
+  WHERE id = NEW.linked_task_id;
+
+  IF target_tenant_id IS NULL OR target_tenant_id <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'linked task event tenant mismatch for linked task %', NEW.linked_task_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  IF target_space_id <> NEW.space_id OR target_thread_id <> NEW.thread_id THEN
+    RAISE EXCEPTION 'linked task event parent mismatch for linked task %', NEW.linked_task_id
+      USING ERRCODE = '23514';
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS linked_task_events_tenant_guard
+  ON public.linked_task_events;
+
+CREATE TRIGGER linked_task_events_tenant_guard
+  BEFORE INSERT OR UPDATE
+  ON public.linked_task_events
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_linked_task_event_tenant();
+
+COMMIT;

package/dist/drizzle/0108_message_mentions.sql

@@ -0,0 +1,95 @@
+-- Purpose: add structured message mentions for collaborative Space Threads.
+-- Plan: docs/plans/2026-05-19-003-feat-spaces-customer-onboarding-v1-plan.md (U10)
+-- Apply manually: psql "$DATABASE_URL" -v ON_ERROR_STOP=1 -f packages/database-pg/drizzle/0108_message_mentions.sql
+-- creates: public.message_mentions
+-- creates: public.uq_message_mentions_target
+-- creates: public.idx_message_mentions_thread
+-- creates: public.idx_message_mentions_target
+-- creates-function: public.enforce_message_mention_tenant
+-- creates-trigger: public.message_mentions.message_mentions_tenant_guard
+-- creates-constraint: public.message_mentions.message_mentions_tenant_id_tenants_id_fk
+-- creates-constraint: public.message_mentions.message_mentions_thread_id_threads_id_fk
+-- creates-constraint: public.message_mentions.message_mentions_message_id_messages_id_fk
+-- creates-constraint: public.message_mentions.message_mentions_target_type_allowed
+
+\set ON_ERROR_STOP on
+
+BEGIN;
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '120s';
+
+CREATE TABLE IF NOT EXISTS public.message_mentions (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  tenant_id uuid NOT NULL,
+  thread_id uuid NOT NULL,
+  message_id uuid NOT NULL,
+  target_type text NOT NULL,
+  target_id uuid NOT NULL,
+  display_name text NOT NULL,
+  raw_text text,
+  start_offset integer,
+  end_offset integer,
+  metadata jsonb,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT message_mentions_tenant_id_tenants_id_fk
+    FOREIGN KEY (tenant_id)
+    REFERENCES public.tenants(id)
+    ON DELETE CASCADE,
+  CONSTRAINT message_mentions_thread_id_threads_id_fk
+    FOREIGN KEY (thread_id)
+    REFERENCES public.threads(id)
+    ON DELETE CASCADE,
+  CONSTRAINT message_mentions_message_id_messages_id_fk
+    FOREIGN KEY (message_id)
+    REFERENCES public.messages(id)
+    ON DELETE CASCADE,
+  CONSTRAINT message_mentions_target_type_allowed
+    CHECK (target_type IN ('user', 'agent', 'agent_profile'))
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS uq_message_mentions_target
+  ON public.message_mentions (message_id, target_type, target_id);
+
+CREATE INDEX IF NOT EXISTS idx_message_mentions_thread
+  ON public.message_mentions (tenant_id, thread_id);
+
+CREATE INDEX IF NOT EXISTS idx_message_mentions_target
+  ON public.message_mentions (tenant_id, target_type, target_id);
+
+CREATE OR REPLACE FUNCTION public.enforce_message_mention_tenant()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+  message_tenant uuid;
+  message_thread uuid;
+BEGIN
+  SELECT tenant_id, thread_id
+  INTO message_tenant, message_thread
+  FROM public.messages
+  WHERE id = NEW.message_id;
+
+  IF message_tenant IS NULL THEN
+    RAISE EXCEPTION 'message_mentions.message_id % does not reference an existing message', NEW.message_id;
+  END IF;
+
+  IF message_tenant <> NEW.tenant_id THEN
+    RAISE EXCEPTION 'message_mentions tenant mismatch: mention %, message %', NEW.tenant_id, message_tenant;
+  END IF;
+
+  IF message_thread <> NEW.thread_id THEN
+    RAISE EXCEPTION 'message_mentions thread mismatch: mention %, message %', NEW.thread_id, message_thread;
+  END IF;
+
+  RETURN NEW;
+END;
+$$;
+
+DROP TRIGGER IF EXISTS message_mentions_tenant_guard ON public.message_mentions;
+CREATE TRIGGER message_mentions_tenant_guard
+  BEFORE INSERT OR UPDATE ON public.message_mentions
+  FOR EACH ROW
+  EXECUTE FUNCTION public.enforce_message_mention_tenant();
+
+COMMIT;