deepline 0.3.85 → 0.3.87

package/dist/bundling-sources/shared_libs/monitors/snitcher-ip2company.ts

@@ -0,0 +1,332 @@
+import { createHmac, randomUUID } from 'node:crypto';
+import { isIP } from 'node:net';
+import { internal } from '@convex/_generated/api';
+import { hasSnitcherSessionIdentity } from '@deepline/ingestion-v2/snitcher-session-identity';
+import { getRequiredInternalConvexClient } from '@/lib/convex/internal-client';
+
+export { hasSnitcherSessionIdentity };
+
+const SNITCHER_IP2COMPANY_URL = 'https://api.snitcher.com/company/find';
+const IP2COMPANY_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+export type SnitcherIp2CompanyResult = {
+  status:
+    | 'identified'
+    | 'no_company'
+    | 'queued'
+    | 'quota_exceeded'
+    | 'rate_limited'
+    | 'failed'
+    | 'skipped_no_ip'
+    | 'skipped_non_public_ip';
+  ip: string | null;
+  networkType?: string | null;
+  company?: Record<string, unknown> | null;
+  geoIp?: Record<string, unknown> | null;
+  error?: string | null;
+};
+
+type FetchImplementation = typeof fetch;
+
+type CachedSnitcherIp2CompanyResult = Omit<SnitcherIp2CompanyResult, 'ip'>;
+
+export class SnitcherIp2CompanyResolutionPendingError extends Error {
+  constructor() {
+    super(
+      'A Deepline Analytics IP2Company lookup for this visitor is already in progress. Retry the callback without issuing another provider lookup.',
+    );
+    this.name = 'SnitcherIp2CompanyResolutionPendingError';
+    Object.assign(this, { code: 'snitcher_ip2company_retryable' });
+  }
+}
+
+export class SnitcherIp2CompanyResolutionUnresolvedError extends Error {
+  constructor(status: SnitcherIp2CompanyResult['status']) {
+    super(
+      `Snitcher IP2Company resolution is ${status}; retry this inbound delivery before deciding whether to materialize the session.`,
+    );
+    this.name = 'SnitcherIp2CompanyResolutionUnresolvedError';
+    Object.assign(this, {
+      code:
+        status === 'quota_exceeded'
+          ? 'snitcher_ip2company_quota_exceeded'
+          : 'snitcher_ip2company_retryable',
+    });
+  }
+}
+
+function readRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function readString(value: unknown) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function isPublicIpv4(ip: string) {
+  const [first, second] = ip.split('.').map(Number);
+  return !(
+    first === 0 ||
+    first === 10 ||
+    first === 127 ||
+    (first === 100 && second >= 64 && second <= 127) ||
+    (first === 169 && second === 254) ||
+    (first === 172 && second >= 16 && second <= 31) ||
+    (first === 192 && second === 168) ||
+    (first === 192 && second === 0) ||
+    (first === 192 && second === 2) ||
+    (first === 198 && (second === 18 || second === 19 || second === 51)) ||
+    (first === 203 && second === 0) ||
+    first >= 224
+  );
+}
+
+function isPublicIp(value: string) {
+  const family = isIP(value);
+  if (family === 4) return isPublicIpv4(value);
+  if (family !== 6) return false;
+  const normalized = value.toLowerCase();
+  return !(
+    normalized === '::1' ||
+    normalized.startsWith('fc') ||
+    normalized.startsWith('fd') ||
+    normalized.startsWith('fe80:')
+  );
+}
+
+/** Radar supplies the visitor IP on each event's browser geo context. */
+export function snitcherSessionIp(payload: unknown): string | null {
+  const root = readRecord(payload);
+  const events = Array.isArray(root?.events) ? root.events : [];
+  for (const event of events) {
+    const context = readRecord(readRecord(event)?.context);
+    const geo = readRecord(context?.geo);
+    const ip = readString(geo?.ip);
+    if (ip) return ip;
+  }
+  return null;
+}
+
+/**
+ * A Radar session is useful to the customer only after Radar identifies a
+ * visitor by email or IP2Company identifies a company. Anonymous activity
+ * remains available in the authenticated raw-delivery ledger, but must not
+ * create a customer-facing session row or trigger a play.
+ */
+/**
+ * These are definitive outcomes: no later retry can turn this delivery into a
+ * person or company record without a different source payload. Provider
+ * outages and queued lookups are deliberately excluded so they remain replay
+ * candidates in the raw inbound ledger.
+ */
+export function isSnitcherSessionTerminallyUnidentified(payload: unknown) {
+  if (hasSnitcherSessionIdentity(payload)) return false;
+  const root = readRecord(payload);
+  const enrichment = readRecord(root?._deepline_ip2company);
+  return (
+    readString(enrichment?.status) === 'no_company' ||
+    readString(enrichment?.status) === 'skipped_no_ip' ||
+    readString(enrichment?.status) === 'skipped_non_public_ip'
+  );
+}
+
+export function snitcherSessionIp2CompanyStatus(
+  payload: unknown,
+): SnitcherIp2CompanyResult['status'] | null {
+  const root = readRecord(payload);
+  const enrichment = readRecord(root?._deepline_ip2company);
+  const status = readString(enrichment?.status);
+  return status === 'identified' ||
+    status === 'no_company' ||
+    status === 'queued' ||
+    status === 'quota_exceeded' ||
+    status === 'rate_limited' ||
+    status === 'failed' ||
+    status === 'skipped_no_ip' ||
+    status === 'skipped_non_public_ip'
+    ? status
+    : null;
+}
+
+export function isSnitcherIp2CompanyConfigured() {
+  return Boolean(process.env.SNITCHER_IP2C_API_KEY?.trim());
+}
+
+function apiKey() {
+  const value = process.env.SNITCHER_IP2C_API_KEY?.trim();
+  if (!value) {
+    throw new Error(
+      'SNITCHER_IP2C_API_KEY must be configured before Deepline Analytics can enrich visitor companies.',
+    );
+  }
+  return value;
+}
+
+function ipCacheHash(input: { orgId: string; ip: string }) {
+  // The cache is per workspace. Sharing a resolved visitor IP across tenants
+  // would cross a customer-data boundary even though it would lower provider
+  // spend. Keep the raw IP out of Convex control-plane state.
+  return createHmac('sha256', apiKey())
+    .update(`${input.orgId}\u0000${input.ip}`)
+    .digest('hex');
+}
+
+function cacheableResult(
+  result: SnitcherIp2CompanyResult,
+): CachedSnitcherIp2CompanyResult | null {
+  if (result.status !== 'identified' && result.status !== 'no_company') {
+    return null;
+  }
+  const { ip: _ip, ...cached } = result;
+  return cached;
+}
+
+function resultFromCache(
+  value: unknown,
+  ip: string,
+): SnitcherIp2CompanyResult | null {
+  const cached = readRecord(value);
+  const status = readString(cached?.status);
+  if (status !== 'identified' && status !== 'no_company') return null;
+  return {
+    status,
+    ip,
+    networkType: readString(cached?.networkType),
+    company: readRecord(cached?.company),
+    geoIp: readRecord(cached?.geoIp),
+    error: readString(cached?.error),
+  };
+}
+
+/**
+ * Resolves one public IP through Snitcher IP2Company. This is intentionally
+ * internal-only: Analytics owns the platform credential and callers never
+ * supply or see it.
+ */
+export async function findSnitcherIp2Company(
+  ip: string | null | undefined,
+  fetchImplementation: FetchImplementation = fetch,
+): Promise<SnitcherIp2CompanyResult> {
+  const candidate = readString(ip);
+  if (!candidate) return { status: 'skipped_no_ip', ip: null };
+  if (!isPublicIp(candidate)) {
+    return { status: 'skipped_non_public_ip', ip: candidate };
+  }
+
+  let response: Response;
+  try {
+    response = await fetchImplementation(
+      `${SNITCHER_IP2COMPANY_URL}?${new URLSearchParams({ ip: candidate })}`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey()}`,
+          Accept: 'application/json',
+        },
+      },
+    );
+  } catch (error) {
+    return {
+      status: 'failed',
+      ip: candidate,
+      error: error instanceof Error ? error.message : 'Network request failed.',
+    };
+  }
+
+  const body = await response.json().catch(() => null);
+  const record = readRecord(body);
+  if (response.status === 202) return { status: 'queued', ip: candidate };
+  if (response.status === 403)
+    return { status: 'quota_exceeded', ip: candidate };
+  if (response.status === 429) return { status: 'rate_limited', ip: candidate };
+  if (!response.ok) {
+    return {
+      status: 'failed',
+      ip: candidate,
+      error: readString(record?.message) ?? `HTTP ${response.status}`,
+    };
+  }
+
+  const company = readRecord(record?.company);
+  return {
+    status: company ? 'identified' : 'no_company',
+    ip: candidate,
+    networkType: readString(record?.type),
+    company,
+    geoIp: readRecord(record?.geoIP),
+  };
+}
+
+/** Adds a non-secret enrichment envelope consumed by the typed session writer. */
+export async function enrichSnitcherSessionWithIp2Company(input: {
+  orgId: string;
+  payload: Record<string, unknown>;
+}): Promise<Record<string, unknown>> {
+  const root = readRecord(input.payload);
+  if (!root) return input.payload;
+  const ip = snitcherSessionIp(root);
+  if (!ip || !isPublicIp(ip)) {
+    const enrichment = await findSnitcherIp2Company(ip);
+    return { ...root, _deepline_ip2company: enrichment };
+  }
+
+  const cacheKey = ipCacheHash({ orgId: input.orgId, ip });
+  const leaseId = randomUUID();
+  const client = getRequiredInternalConvexClient();
+  const claim = await client.mutation(internal.analyticsIp2cCache.claim, {
+    orgId: input.orgId,
+    ipHash: cacheKey,
+    leaseId,
+    now: Date.now(),
+  });
+  if (claim.kind === 'hit') {
+    const enrichment = resultFromCache(claim.result, ip);
+    if (!enrichment) {
+      throw new Error(
+        'Deepline Analytics IP2Company cache returned an invalid resolved value.',
+      );
+    }
+    return { ...root, _deepline_ip2company: enrichment };
+  }
+  if (claim.kind === 'pending') {
+    throw new SnitcherIp2CompanyResolutionPendingError();
+  }
+
+  let enrichment: SnitcherIp2CompanyResult;
+  try {
+    enrichment = await findSnitcherIp2Company(ip);
+  } catch (error) {
+    await client.mutation(internal.analyticsIp2cCache.release, {
+      orgId: input.orgId,
+      ipHash: cacheKey,
+      leaseId,
+    });
+    throw error;
+  }
+
+  const cached = cacheableResult(enrichment);
+  if (cached) {
+    const settled = await client.mutation(internal.analyticsIp2cCache.resolve, {
+      orgId: input.orgId,
+      ipHash: cacheKey,
+      leaseId,
+      result: cached,
+      now: Date.now(),
+      expiresAt: Date.now() + IP2COMPANY_CACHE_TTL_MS,
+    });
+    if (!settled.stored) {
+      throw new Error(
+        'Deepline Analytics IP2Company cache lease was lost before its result could be stored.',
+      );
+    }
+  } else {
+    await client.mutation(internal.analyticsIp2cCache.release, {
+      orgId: input.orgId,
+      ipHash: cacheKey,
+      leaseId,
+    });
+  }
+  return { ...root, _deepline_ip2company: enrichment };
+}

package/dist/bundling-sources/shared_libs/monitors/snitcher-radar.ts

@@ -0,0 +1,221 @@
+import { buildProviderWebhookCallbackUrl } from '@deepline/monitors/provider-webhook-monitor-runtime';
+import { DEEPLINE_ANALYTICS_BROWSER_OBJECT } from '@/lib/analytics/public';
+
+const SNITCHER_RADAR_API_URL = 'https://api.snitcher.com/radar/operator/v1';
+const SNITCHER_INTERNAL_IDENTIFIER_PREFIX = 'dlr1_';
+
+export type SnitcherTrackingControls = {
+  formTracking: boolean;
+  clickTracking: boolean;
+  customEvents: boolean;
+  waitForConsent: boolean;
+};
+
+export const DEFAULT_SNITCHER_TRACKING_CONTROLS: SnitcherTrackingControls = {
+  formTracking: false,
+  clickTracking: false,
+  customEvents: true,
+  waitForConsent: true,
+};
+
+function requireSecret(
+  name: 'SNITCHER_RADAR_API_KEY' | 'SNITCHER_RADAR_WEBHOOK_SECRET',
+) {
+  const value = process.env[name]?.trim();
+  if (!value)
+    throw new Error(
+      `${name} must be configured before Snitcher Radar can be used.`,
+    );
+  return value;
+}
+
+export function getSnitcherRadarWebhookSecret() {
+  return requireSecret('SNITCHER_RADAR_WEBHOOK_SECRET');
+}
+
+export function buildSnitcherInternalIdentifier(input: {
+  orgId: string;
+  callbackToken: string;
+}) {
+  return `${SNITCHER_INTERNAL_IDENTIFIER_PREFIX}${Buffer.from(
+    JSON.stringify({ orgId: input.orgId, token: input.callbackToken }),
+  ).toString('base64url')}`;
+}
+
+export function parseSnitcherInternalIdentifier(value: unknown) {
+  if (
+    typeof value !== 'string' ||
+    !value.startsWith(SNITCHER_INTERNAL_IDENTIFIER_PREFIX)
+  ) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(
+        value.slice(SNITCHER_INTERNAL_IDENTIFIER_PREFIX.length),
+        'base64url',
+      ).toString('utf8'),
+    ) as { orgId?: unknown; token?: unknown };
+    if (
+      typeof parsed.orgId !== 'string' ||
+      !parsed.orgId.trim() ||
+      typeof parsed.token !== 'string' ||
+      !parsed.token.trim()
+    ) {
+      return null;
+    }
+    return { orgId: parsed.orgId, token: parsed.token };
+  } catch {
+    return null;
+  }
+}
+
+export function snitcherRadarWebhookEndpoint(callbackBaseUrl?: string | null) {
+  return buildProviderWebhookCallbackUrl({
+    provider: 'snitcher',
+    orgId: 'registry-derived',
+    token: 'registry-derived',
+    callbackBaseUrl,
+  });
+}
+
+export function buildSnitcherRadarLoader(input: {
+  trackingScriptId: string;
+  controls: SnitcherTrackingControls;
+}) {
+  const settings = {
+    cdn: 'cdn.snitcher.com',
+    apiEndpoint: 'radar.snitcher.com',
+    profileId: input.trackingScriptId,
+    namespace: DEEPLINE_ANALYTICS_BROWSER_OBJECT,
+    waitForConsent: input.controls.waitForConsent,
+    features: {
+      formTracking: input.controls.formTracking,
+      clickTracking: input.controls.clickTracking,
+    },
+  };
+  return `<script>\n!function(e){"use strict";var a=e&&e.namespace;if(a&&e.profileId&&e.cdn){var r=window[a];if(r&&Array.isArray(r)||(r=window[a]=[]),!r.initialized&&!r._loaded)if(r._loaded)console&&console.warn("[Radar] Duplicate initialization attempted");else{r._loaded=!0;["track","page","identify","group","alias","ready","debug","on","off","once","trackClick","trackSubmit","trackLink","trackForm","pageview","screen","reset","register","setAnonymousId","addSourceMiddleware","addIntegrationMiddleware","addDestinationMiddleware","giveCookieConsent"].forEach((function(e){var i;r[e]=(i=e,function(){var e=window[a];if(e.initialized)return e[i].apply(e,arguments);var r=[].slice.call(arguments);return r.unshift(i),e.push(r),e})})),r.bootstrap=function(){var a=document.createElement("script");a.async=!0,a.type="text/javascript",a.id="__radar__",a.dataset.settings=JSON.stringify(e),a.src="https://"+e.cdn+"/releases/latest/radar.min.js";var r=document.scripts[0];r.parentNode.insertBefore(a,r)},r.bootstrap()}}else"undefined"!=typeof console&&console.error("[Radar] Configuration incomplete")}(${JSON.stringify(settings)});\n</script>`;
+}
+
+type SnitcherApiResponse<T> = {
+  success?: unknown;
+  data?: T;
+  message?: unknown;
+};
+
+type SnitcherTrackingScript = {
+  tracking_script_id?: unknown;
+  trackingScriptId?: unknown;
+  internal_identifier?: unknown;
+  active?: unknown;
+  domains?: unknown;
+};
+
+function trackingScriptsFromResponse(value: unknown): SnitcherTrackingScript[] {
+  if (Array.isArray(value)) return value as SnitcherTrackingScript[];
+  if (!value || typeof value !== 'object') return [];
+  const record = value as Record<string, unknown>;
+  for (const nested of [
+    record.data,
+    record.tracking_script,
+    record.trackingScript,
+  ]) {
+    if (nested !== undefined) {
+      return trackingScriptsFromResponse(nested);
+    }
+  }
+  return [record as SnitcherTrackingScript];
+}
+
+function readTrackingScriptId(script: SnitcherTrackingScript | null) {
+  if (!script) return null;
+  const value = script.tracking_script_id ?? script.trackingScriptId;
+  if (typeof value === 'string' && value.trim()) return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  return null;
+}
+
+async function snitcherRequest<T>(path: string, init: RequestInit) {
+  const response = await fetch(`${SNITCHER_RADAR_API_URL}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${requireSecret('SNITCHER_RADAR_API_KEY')}`,
+      'Content-Type': 'application/json',
+      ...(init.headers ?? {}),
+    },
+  });
+  const body = (await response
+    .json()
+    .catch(() => null)) as SnitcherApiResponse<T> | null;
+  if (!response.ok || !body?.success) {
+    throw new Error(
+      `Snitcher Radar API ${init.method ?? 'GET'} ${path} failed (${response.status}): ${
+        typeof body?.message === 'string' ? body.message : 'unexpected response'
+      }`,
+    );
+  }
+  return body.data;
+}
+
+export async function createSnitcherTrackingScript(input: {
+  internalIdentifier: string;
+  description: string;
+  domains: string[];
+}) {
+  const data = await snitcherRequest<SnitcherTrackingScript[]>(
+    '/tracking-scripts',
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        internal_identifier: input.internalIdentifier,
+        description: input.description,
+        domains: input.domains,
+      }),
+    },
+  );
+  const script = trackingScriptsFromResponse(data)[0] ?? null;
+  const trackingScriptId = readTrackingScriptId(script);
+  if (!trackingScriptId) {
+    throw new Error('Snitcher Radar did not return a tracking_script_id.');
+  }
+  return { trackingScriptId };
+}
+
+/**
+ * Radar's tracking-script creation is externally durable, while our metadata
+ * write is local. A timeout or a later setup failure can leave an upstream
+ * script without its local ID. Recover it by the opaque, per-monitor
+ * identifier instead of attempting another creation.
+ */
+export async function findSnitcherTrackingScriptByInternalIdentifier(
+  internalIdentifier: string,
+) {
+  const query = new URLSearchParams({
+    internal_identifier: internalIdentifier,
+    size: '1',
+  });
+  const data = await snitcherRequest<SnitcherTrackingScript[]>(
+    `/tracking-scripts?${query.toString()}`,
+    { method: 'GET' },
+  );
+  const script = trackingScriptsFromResponse(data).find(
+    (candidate) => candidate.internal_identifier === internalIdentifier,
+  );
+  const trackingScriptId = readTrackingScriptId(script ?? null);
+  return trackingScriptId ? { trackingScriptId } : null;
+}
+
+export async function configureSnitcherRadarWebhook(
+  callbackBaseUrl?: string | null,
+) {
+  return snitcherRequest('/webhooks', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      delivery: {
+        webhook_url: snitcherRadarWebhookEndpoint(callbackBaseUrl),
+        webhook_secret: getSnitcherRadarWebhookSecret(),
+      },
+      event_aggregation: 'per_session',
+    }),
+  });
+}

package/dist/bundling-sources/shared_libs/monitors/starter-templates.ts

@@ -0,0 +1,105 @@
+export type MonitorStarterTemplate = {
+  id: string;
+  title: string;
+  description: string;
+  prompt: string;
+};
+
+export const MONITOR_STARTER_TEMPLATES: MonitorStarterTemplate[] = [
+  {
+    id: 'job-post-keywords',
+    title: 'Job post keyword monitor',
+    description:
+      'Watch target accounts for hiring signals that imply new budget, new projects, or urgency.',
+    prompt: `Create a Deepline definePlay() workflow for a job post keyword monitor.
+
+Input: a list of target accounts, job title or description keywords, optional regions, and optional owner routing.
+Behavior: check each account for recent open roles that match the keywords, dedupe against prior matches, enrich each match with company context and job URL, and rank the signal by relevance.
+Output: one concise rep-ready message per owner with account name, matched role, why it matters, job URL, and recommended next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'champion-job-change',
+    title: 'Champion job change monitor',
+    description:
+      'Find when a known buyer, user, or champion joins a new account and route a warm-path action.',
+    prompt: `Create a Deepline definePlay() workflow for a champion job change monitor.
+
+Input: known champions or contacts from CRM, their prior companies, owner routing rules, and optional target-account filters.
+Behavior: detect likely role or company changes, validate the new company and title, suppress weak matches, and connect the signal back to the owning rep or CSM.
+Output: one routed message per owner with champion name, old company, new company, new title, relationship context, source URL, and suggested outreach angle. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'website-page-change',
+    title: 'Website page change monitor',
+    description:
+      'Track pricing, docs, security, integrations, or product pages for GTM-relevant changes.',
+    prompt: `Create a Deepline definePlay() workflow for a website page change monitor.
+
+Input: a list of account URLs, page categories to watch, a minimum change threshold, and owner routing rules.
+Behavior: fetch current page content, compare it with the prior snapshot, classify meaningful GTM changes, ignore noisy cosmetic edits, and store the new snapshot only after a successful run.
+Output: one routed message per owner with account name, changed URL, before/after summary, why the change matters, confidence, and suggested next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'website-visitor-intent',
+    title: 'Website visitor intent monitor',
+    description:
+      'Turn repeat high-value website visits into account-specific follow-up for the right owner.',
+    prompt: `Create a Deepline definePlay() workflow for a website visitor intent monitor.
+
+Input: visitor or account intent events, high-intent page definitions, account matching rules, suppression rules, and owner routing.
+Behavior: group events by account, score intent from page depth and recency, suppress existing active opportunities when configured, and explain why the account is worth actioning.
+Output: one routed message per owner with account name, intent score, pages visited, timing, CRM context, and recommended next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'tech-stack-change',
+    title: 'Tech stack change monitor',
+    description:
+      'Detect install, removal, or competitor stack changes that create a concrete sales motion.',
+    prompt: `Create a Deepline definePlay() workflow for a tech stack change monitor.
+
+Input: target accounts, technologies to watch, competitor or complementary-product tags, owner routing, and optional exclusion rules.
+Behavior: detect meaningful install or removal events, confirm with available evidence, classify the motion as displacement, expansion, integration, or renewal risk, and dedupe prior alerts.
+Output: one routed message per owner with account name, detected technology change, evidence, GTM interpretation, and suggested next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'social-community-mention',
+    title: 'Social and community mention monitor',
+    description:
+      'Catch relevant public mentions, buying questions, complaints, or competitor comparisons.',
+    prompt: `Create a Deepline definePlay() workflow for a social and community mention monitor.
+
+Input: keywords, target accounts or personas, source allowlist, sentiment or category filters, and owner routing rules.
+Behavior: find recent relevant mentions, classify each mention as buying intent, competitor comparison, complaint, hiring, integration request, or general awareness, and suppress duplicates or low-quality chatter.
+Output: one routed message per owner with mention summary, source link, account/person context, signal category, confidence, and suggested next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'competitor-churn',
+    title: 'Competitor complaint monitor',
+    description:
+      'Surface competitor dissatisfaction or sunset risk while the account is likely open to change.',
+    prompt: `Create a Deepline definePlay() workflow for a competitor complaint monitor.
+
+Input: competitor names, complaint or migration keywords, source allowlist, target-account matching rules, and owner routing.
+Behavior: find recent competitor dissatisfaction or sunset-risk mentions, match them to companies where possible, classify the pain, and suppress vague or stale mentions.
+Output: one routed message per owner with account or person, competitor, pain summary, source URL, suggested displacement angle, and confidence. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+  {
+    id: 'customer-usage-renewal',
+    title: 'Customer usage and renewal monitor',
+    description:
+      'Route expansion, risk, and renewal signals from product behavior to the account team.',
+    prompt: `Create a Deepline definePlay() workflow for a customer usage and renewal monitor.
+
+Input: product usage events, entitlement limits, renewal dates, account health fields, and owner routing.
+Behavior: detect expansion signals, underuse risk, overage pressure, renewal timing, or feature adoption changes; explain the evidence; and suppress noisy repeat alerts.
+Output: one routed message per owner with account name, signal type, usage evidence, renewal context, business impact, and suggested next step. Include Slack Block Kit formatting and an email fallback.
+Verification: add a small dry-run input, run deepline plays check, run one sample execution against a scratch output destination, and report exactly what changed and what was not published.`,
+  },
+];