@velaro/cli 1.2.0 → 1.4.8

package/lib/kb-screenshot.js

@@ -0,0 +1,320 @@
+/**
+ * kb-screenshot.js — capture a live staging screenshot and drop it into a KB article.
+ *
+ * Reuses:
+ *   - the login-form-fill steps from e2e/tests/auth.setup.ts (adapted to run standalone,
+ *     outside the Playwright test-runner lifecycle)
+ *   - scripts/polish-screenshot.py for rounded corners / shadow / annotations
+ *   - cli/lib/commands/article.js's adminRequest() for auth + KB article get/update
+ *   - server/Velaro.Admin/Controllers/KB/KBArticlesController.cs's upload-image endpoint
+ *
+ * playwright is an OPTIONAL dependency of @velaro/cli (it pulls down a full Chromium
+ * binary) — it's dynamically imported here so a plain `velaro` install never pays that
+ * cost unless this command is actually used.
+ */
+
+import { readFileSync, unlinkSync, existsSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, extname, basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { getCredentials } from './api.js';
+import { adminRequest } from './commands/article.js';
+
+const execFileAsync = promisify(execFile);
+
+// Resolve relative to this file's location (cli/lib/), not process.cwd() — the CLI
+// is invoked from wherever the caller happens to be (cli/, repo root, or a global
+// install), and process.cwd()-based resolution silently 404s outside the repo root.
+// Repo layout: <repoRoot>/scripts/polish-screenshot.py, this file at <repoRoot>/cli/lib/.
+const REPO_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+const APP_URLS = {
+  admin:     process.env.ADMIN_UI_URL || 'https://admin-staging.velaro.com',
+  messaging: process.env.MSG_UI_URL   || 'https://messaging-staging.velaro.com',
+};
+
+// Key Vault fallback for credentials — used only when neither E2E_USER_* nor TEST_USER_*
+// env vars are set. Configurable via env so this isn't hardcoded to one account forever.
+const KV_NAME          = process.env.KB_SCREENSHOT_KV_NAME          || 'velaro-eastus-stg-kv';
+const KV_EMAIL_SECRET  = process.env.KB_SCREENSHOT_KV_EMAIL_SECRET  || 'claude-test-agent-staging1032-email';
+const KV_PASSWORD_SECRET = process.env.KB_SCREENSHOT_KV_PASSWORD_SECRET || 'claude-test-agent-staging1032-password';
+
+/**
+ * Pulls the email/password pair from Azure Key Vault via DefaultAzureCredential.
+ * Locally this picks up the operator's own `az login` session automatically — no
+ * extra config needed. In CI (non-interactive), DefaultAzureCredential would need
+ * AZURE_CLIENT_ID/AZURE_TENANT_ID/AZURE_CLIENT_SECRET env vars (or a federated
+ * identity) to authenticate — out of scope here since this CLI command is
+ * operator-run today, not a CI step.
+ */
+async function loadCredentialsFromKeyVault() {
+  const { SecretClient } = await import('@azure/keyvault-secrets');
+  const { DefaultAzureCredential } = await import('@azure/identity');
+
+  const vaultUrl = `https://${KV_NAME}.vault.azure.net`;
+  const client = new SecretClient(vaultUrl, new DefaultAzureCredential());
+
+  const [emailSecret, passwordSecret] = await Promise.all([
+    client.getSecret(KV_EMAIL_SECRET),
+    client.getSecret(KV_PASSWORD_SECRET),
+  ]);
+
+  return { email: emailSecret.value, password: passwordSecret.value };
+}
+
+async function loadPlaywright() {
+  try {
+    return await import('playwright');
+  } catch (err) {
+    throw new Error(
+      'playwright is not installed. Run "npm install playwright" (or "npm install -g @velaro/cli" ' +
+      'again after it is added) before using "velaro kb article screenshot". ' +
+      `(${err.message})`
+    );
+  }
+}
+
+/**
+ * Logs into the given app on staging using the same form-fill steps as
+ * e2e/tests/auth.setup.ts, navigates to `route`, and screenshots to `outputPath`.
+ */
+export async function loginAndScreenshot(app, route, outputPath) {
+  let email    = process.env.E2E_USER_EMAIL    || process.env.TEST_USER_EMAIL;
+  let password = process.env.E2E_USER_PASSWORD || process.env.TEST_USER_PASSWORD;
+
+  if (!email || !password) {
+    try {
+      const kvCreds = await loadCredentialsFromKeyVault();
+      email = kvCreds.email;
+      password = kvCreds.password;
+    } catch (err) {
+      throw new Error(
+        'E2E_USER_EMAIL/E2E_USER_PASSWORD (or TEST_USER_EMAIL/TEST_USER_PASSWORD) must be set ' +
+        'to capture a live screenshot — these are the same env vars used by e2e/tests/auth.setup.ts. ' +
+        `Key Vault fallback also failed: ${err.message}`
+      );
+    }
+  }
+
+  if (!email || !password) {
+    throw new Error(
+      'E2E_USER_EMAIL/E2E_USER_PASSWORD (or TEST_USER_EMAIL/TEST_USER_PASSWORD) must be set, ' +
+      `and Key Vault (${KV_NAME}) did not return usable values for secrets ` +
+      `"${KV_EMAIL_SECRET}"/"${KV_PASSWORD_SECRET}".`
+    );
+  }
+
+  const baseUrl = APP_URLS[app];
+  if (!baseUrl) throw new Error(`Unknown app "${app}" — expected "admin" or "messaging".`);
+
+  const { chromium } = await loadPlaywright();
+  const browser = await chromium.launch();
+
+  try {
+    const context = await browser.newContext();
+    const page = await context.newPage();
+
+    // ── Login (adapted from e2e/tests/auth.setup.ts) ──────────────────────────
+    // Role/label based selectors, not type-attribute selectors — the CIAM login page's
+    // markup does not reliably render the email field as a literal input[type="email"]
+    // or the submit controls as input[type="submit"] (found 2026-08-01 in auth.setup.ts,
+    // confirmed again 2026-08-13 against live admin-staging while verifying the Key
+    // Vault credential fallback below: the email step is input[name="username"]
+    // type="text", and both submit controls are <button type="submit">). Role/label
+    // selectors track the accessible page contract instead of an implementation detail
+    // that can change under us.
+    await page.goto(baseUrl);
+    await page.waitForURL(/login\.velaro\.com/, { timeout: 30_000 });
+
+    await page.getByRole('textbox', { name: /email/i }).fill(email);
+    await page.getByRole('button', { name: /next|sign in/i }).click();
+
+    await page.getByLabel(/password/i).fill(password);
+    await page.getByRole('button', { name: /sign in|next/i }).click();
+
+    // Handle "Stay signed in?" prompt — not always shown.
+    try {
+      await page.getByRole('button', { name: /yes|no|stay signed in/i }).first().click({ timeout: 5_000 });
+    } catch { /* prompt not shown — proceed */ }
+
+    await page.waitForURL(/velaro\.com/, { timeout: 30_000 });
+
+    // ── Navigate + capture ──────────────────────────────────────────────────
+    const target = new URL(route, baseUrl).toString();
+    await page.goto(target);
+    await page.waitForLoadState('networkidle', { timeout: 30_000 }).catch(() => {
+      // Some pages keep a long-lived connection (SignalR) open — don't fail the
+      // capture just because the network never goes fully idle.
+    });
+
+    await page.screenshot({ path: outputPath, fullPage: true });
+  } finally {
+    await browser.close();
+  }
+}
+
+/**
+ * Shells out to scripts/polish-screenshot.py. Flags match that script's argparse
+ * definitions exactly: `--annotate "x,y,label"`, repeatable.
+ */
+export async function polishScreenshot(inputPath, annotations, polishOpts) {
+  const hasAnnotations = annotations && annotations.length > 0;
+  if (!hasAnnotations && !polishOpts) return inputPath;
+
+  const outputPath = inputPath.replace(/\.(png|jpg|jpeg)$/i, '.polished.png');
+  const scriptPath = join(REPO_ROOT, 'scripts', 'polish-screenshot.py');
+
+  const args = [scriptPath, inputPath, outputPath];
+  for (const a of (annotations || [])) {
+    if (a.x == null || a.y == null || Number.isNaN(a.x) || Number.isNaN(a.y)) {
+      throw new Error(`Invalid annotation: ${JSON.stringify(a)} — expected {x, y, label}`);
+    }
+    args.push('--annotate', `${a.x},${a.y},${a.label ?? ''}`);
+  }
+  // Standard KB style-guide defaults (see ~/.claude/skills/polish-screenshot/SKILL.md) — always
+  // route product/KB screenshots through this rather than embedding raw captures.
+  if (polishOpts) {
+    args.push('--bg', polishOpts.bg || 'F4F5F7');
+    args.push('--pad', String(polishOpts.pad ?? 40));
+    args.push('--radius', String(polishOpts.radius ?? 10));
+    args.push('--shadow-size', String(polishOpts.shadowSize ?? 24));
+    if (polishOpts.border !== false) args.push('--border');
+  }
+
+  try {
+    await execFileAsync('python', args);
+  } catch (err) {
+    throw new Error(`scripts/polish-screenshot.py failed: ${err.message}`);
+  }
+
+  return outputPath;
+}
+
+function mimeTypeFor(path) {
+  const ext = extname(path).toLowerCase();
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg';
+  if (ext === '.gif') return 'image/gif';
+  if (ext === '.webp') return 'image/webp';
+  return 'image/png';
+}
+
+/** Uploads via the existing KBArticlesController upload-image endpoint. Returns the image URL. */
+export async function uploadImage(imagePath, creds) {
+  const apiBase = creds.adminApiBase || 'https://help.velaro.com';
+
+  const buffer = readFileSync(imagePath);
+  const form = new FormData();
+  form.append('file', new Blob([buffer], { type: mimeTypeFor(imagePath) }), basename(imagePath));
+
+  const res = await fetch(`${apiBase}/api/kb/articles/upload-image`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${creds.velaroToken}` },
+    body: form,
+  });
+
+  if (!res.ok) {
+    let msg = `upload-image -> ${res.status}`;
+    try { const t = await res.text(); if (t) msg += `: ${t.slice(0, 300)}`; } catch { /* status already captured */ }
+    throw new Error(msg);
+  }
+
+  const data = await res.json();
+  if (!data?.url) throw new Error('upload-image response did not include a url');
+  return data.url;
+}
+
+/**
+ * Case-insensitive substring match against <h2>/<h3> text content. Inserts immediately
+ * after the matched heading's closing tag; appends to the end if no heading (or no
+ * match) was given.
+ */
+export function insertImageAfterHeading(html, heading, imgTag) {
+  const body = html ?? '';
+
+  if (!heading) {
+    return { html: `${body}\n${imgTag}`, insertedAfterHeading: false };
+  }
+
+  const headingRegex = /<h([23])[^>]*>([\s\S]*?)<\/h\1>/gi;
+  let match;
+  while ((match = headingRegex.exec(body)) !== null) {
+    const text = match[2].replace(/<[^>]+>/g, '').trim();
+    if (text.toLowerCase().includes(heading.toLowerCase())) {
+      const insertAt = match.index + match[0].length;
+      return {
+        html: `${body.slice(0, insertAt)}\n${imgTag}\n${body.slice(insertAt)}`,
+        insertedAfterHeading: true,
+      };
+    }
+  }
+
+  return { html: `${body}\n${imgTag}`, insertedAfterHeading: false };
+}
+
+export function escapeAttr(s) {
+  return String(s).replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+
+/**
+ * @param {object} opts
+ * @param {"admin"|"messaging"} opts.app
+ * @param {string} opts.route
+ * @param {number} opts.articleId
+ * @param {string} [opts.heading]
+ * @param {{x:number,y:number,label?:string}[]} [opts.annotations]
+ * @param {{token:string, apiBase:string}} [opts.auth] Explicit auth override for callers
+ *   that don't use the CLI's stored login config (e.g. mcp/server.js, which authenticates
+ *   via VELARO_MCP_KEY/VELARO_JWT env vars). CLI usage omits this and falls back to
+ *   getCredentials() (the normal `velaro login` flow).
+ * @returns {Promise<{articleId:number, imageUrl:string, insertedAfterHeading:boolean}>}
+ */
+export async function captureKbScreenshot({ app, route, articleId, heading, annotations, auth }) {
+  if (!app || !APP_URLS[app]) throw new Error('app must be "admin" or "messaging"');
+  if (!route) throw new Error('route is required');
+  if (!articleId) throw new Error('articleId is required');
+
+  const rawPath = join(tmpdir(), `kb-screenshot-${articleId}-${Date.now()}.png`);
+  let polishedPath = rawPath;
+
+  try {
+    const creds = auth
+      ? { velaroToken: auth.token, adminApiBase: auth.apiBase }
+      : await getCredentials();
+
+    await loginAndScreenshot(app, route, rawPath);
+    polishedPath = await polishScreenshot(rawPath, annotations);
+    const imageUrl = await uploadImage(polishedPath, creds);
+
+    const article = await adminRequest('GET', `/api/kb/articles?id=${articleId}`, undefined, creds);
+    if (!article) throw new Error(`Article ${articleId} not found`);
+
+    const imgTag = `<img src="${imageUrl}" alt="${heading ? escapeAttr(heading) : 'Screenshot'}" />`;
+    const { html: newContent, insertedAfterHeading } = insertImageAfterHeading(article.content, heading, imgTag);
+
+    await adminRequest('PUT', `/api/kb/articles?id=${articleId}`, {
+      title:             article.title,
+      slug:              article.slug,
+      topicId:           article.topicId,
+      description:       article.description,
+      content:           newContent,
+      visibility:        article.visibility,
+      searchTags:        article.searchTags,
+      isPublished:       article.isPublished,
+      displayPriority:   article.displayPriority,
+      enableBotResponse: article.enableBotResponse,
+      botSummary:        article.botSummary,
+      isFeatured:        article.isFeatured,
+    }, creds);
+
+    return { articleId, imageUrl, insertedAfterHeading };
+  } catch (err) {
+    throw new Error(`kb screenshot capture failed: ${err.message}`);
+  } finally {
+    // Best-effort cleanup — never let a temp-file error mask the real result/error.
+    for (const p of new Set([rawPath, polishedPath])) {
+      try { if (existsSync(p)) unlinkSync(p); } catch { /* ignore cleanup failure */ }
+    }
+  }
+}

package/lib/migrations/amscro.json

@@ -0,0 +1,72 @@
+{
+  "name": "Amscro / Oxygen Concentrator",
+  "slug": "amscro",
+  "description": "Healthcare DME: new/existing patient intake routing, widget hidden on insurance pages, ServiceNow post-chat.",
+  "patterns": ["healthcare", "prechat-intake", "url-routing", "widget-hide", "post-chat-crm"],
+  "notes": [
+    "HIPAA-adjacent — no PHI in chat. Conversations are sensitive.",
+    "Widget hidden on /insurance/* — those patients use the phone",
+    "Pre-chat form asks 'New patient or existing patient?' — feeds routing conditions",
+    "ServiceNow integration required for post-chat ticket creation (CSAT 1-2 stars)"
+  ],
+  "resolve": {
+    "ai_configs": {
+      "INTAKE_BOT": "New Patient Intake Bot"
+    },
+    "teams": {
+      "INTAKE_TEAM": "Intake",
+      "PATIENT_SUPPORT_TEAM": "Patient Support",
+      "SERVICE_TEAM": "Equipment Service",
+      "GENERAL_TEAM": "General Support"
+    }
+  },
+  "routing_rules": [
+    {
+      "name": "New Patient — Intake Bot",
+      "trigger": "use-ai",
+      "priority": 100,
+      "expression": [[{"type": "surveyAnswer", "data": "{\"answer\":\"new\",\"comparator\":\"equals\"}"}]],
+      "value": {"aiConfig": "@INTAKE_BOT"},
+      "notes": "Condition fires when pre-chat survey answer = 'new'. Adjust surveyAnswer key to match your actual pre-chat survey field."
+    },
+    {
+      "name": "Existing Patient Support",
+      "trigger": "route-to-team",
+      "priority": 200,
+      "expression": [[{"type": "surveyAnswer", "data": "{\"answer\":\"existing\",\"comparator\":\"equals\"}"}]],
+      "value": {"teamId": "@PATIENT_SUPPORT_TEAM"},
+      "notes": "Condition fires when pre-chat survey answer = 'existing'."
+    },
+    {
+      "name": "Equipment Service",
+      "trigger": "route-to-team",
+      "priority": 300,
+      "expression": [[{"type": "url", "data": "{\"url\":\"/equipment\",\"comparator\":\"contains\"}"}]],
+      "value": {"teamId": "@SERVICE_TEAM"}
+    },
+    {
+      "name": "Default — General Support",
+      "trigger": "route-to-team",
+      "priority": 9999,
+      "expression": [],
+      "value": {"teamId": "@GENERAL_TEAM"}
+    }
+  ],
+  "workflows": [
+    {
+      "name": "Missed Chat Alert — Unresponsive Visitor (5 min)",
+      "trigger": "unresponsive_visitor",
+      "notes": "Configure email-to-supervisor action after creation. Set timeout to 5 minutes."
+    },
+    {
+      "name": "CSAT Recovery — ServiceNow Ticket",
+      "trigger": "csat_submitted",
+      "notes": "Filter to 1-2 star ratings. Create ServiceNow incident. Wire ServiceNow integration credentials first."
+    },
+    {
+      "name": "Widget — Hide on Insurance Portal",
+      "trigger": "widget_loaded",
+      "notes": "Add URL condition (/insurance/*) and Hide Widget action. This is the widget_loaded workflow that suppresses chat on insurance pages."
+    }
+  ]
+}

package/lib/migrations/azenta.json

@@ -0,0 +1,68 @@
+{
+  "name": "Azenta Life Sciences",
+  "slug": "azenta",
+  "description": "Multi-department life sciences: Genewiz, Sample Management, Storage. URL-based routing, SLA alerts, LIMS post-chat push.",
+  "patterns": ["multi-department", "url-routing", "sla-alert", "post-chat-crm"],
+  "notes": [
+    "Victoria is the technical contact — she handles the API side (LIMS config)",
+    "Lisa Hague owns analytics and sentiment reporting",
+    "LIMS: clims4.genewiz.com — no public REST, needs IT credentials for integration",
+    "Phase 1: read-only LIMS lookup and how-to flows, web chat only",
+    "AI config names in this profile are suggestions — match to your actual bot names"
+  ],
+  "resolve": {
+    "ai_configs": {
+      "GENEWIZ_BOT": "Genewiz Sales Bot",
+      "SAMPLE_BOT": "Sample Support Bot",
+      "TRIAGE_BOT": "AI Triage Bot"
+    },
+    "teams": {
+      "GENEWIZ_TEAM": "Genewiz Sales",
+      "SAMPLE_TEAM": "Sample Management",
+      "STORAGE_TEAM": "Storage",
+      "SKILLS_TEAM": "Skills"
+    }
+  },
+  "routing_rules": [
+    {
+      "name": "Genewiz Orders — AI Bot",
+      "trigger": "use-ai",
+      "priority": 100,
+      "expression": [[{"type": "url", "data": "{\"url\":\"/genewiz/\",\"comparator\":\"contains\"}"}]],
+      "value": {"aiConfig": "@GENEWIZ_BOT"}
+    },
+    {
+      "name": "Sample Management — AI Bot",
+      "trigger": "use-ai",
+      "priority": 200,
+      "expression": [[{"type": "url", "data": "{\"url\":\"/samples/\",\"comparator\":\"contains\"}"}]],
+      "value": {"aiConfig": "@SAMPLE_BOT"}
+    },
+    {
+      "name": "Storage — Direct Team",
+      "trigger": "route-to-team",
+      "priority": 300,
+      "expression": [[{"type": "url", "data": "{\"url\":\"/storage/\",\"comparator\":\"contains\"}"}]],
+      "value": {"teamId": "@STORAGE_TEAM"}
+    },
+    {
+      "name": "Default — AI Triage",
+      "trigger": "use-ai",
+      "priority": 9999,
+      "expression": [],
+      "value": {"aiConfig": "@TRIAGE_BOT"}
+    }
+  ],
+  "workflows": [
+    {
+      "name": "SLA Breach Alert — Genewiz (10 min)",
+      "trigger": "sla_breach",
+      "notes": "Configure webhook to #life-sciences-alerts Slack channel after creation"
+    },
+    {
+      "name": "CSAT Recovery — LIMS Push",
+      "trigger": "conversation_resolved",
+      "notes": "Post-chat CSAT + push summary to LIMS. Wire LIMS credentials in integration settings after creation."
+    }
+  ]
+}

package/lib/migrations/bluefire.json

@@ -0,0 +1,49 @@
+{
+  "name": "Bluefire Industrial Services",
+  "slug": "bluefire",
+  "description": "Front-door AI disambiguates department (Sales/Parts/Service/Billing) then routes. Single priority-100 bot handles all routing internally. Post-chat label workflow creates Salesforce tickets.",
+  "patterns": ["front-door-ai", "department-routing", "post-chat-crm"],
+  "notes": [
+    "Key difference from Azenta/Donaldson: ONE workflow at priority #100 does all routing via AI branching",
+    "The AI bot classifies intent (Sales/Parts/Service/Billing) and transfers to the right team",
+    "No URL conditions needed — front-door AI handles everything",
+    "Fallback at #9999 catches anything the AI doesn't classify",
+    "Salesforce integration required for the 'urgent' label workflow"
+  ],
+  "resolve": {
+    "ai_configs": {
+      "FRONT_DOOR_BOT": "Bluefire Front Door Bot"
+    },
+    "teams": {
+      "SALES_TEAM": "Sales",
+      "PARTS_TEAM": "Parts",
+      "SERVICE_TEAM": "Service",
+      "BILLING_TEAM": "Billing",
+      "DEFAULT_TEAM": "General Support"
+    }
+  },
+  "routing_rules": [
+    {
+      "name": "Front Door AI — All Routing",
+      "trigger": "use-ai",
+      "priority": 100,
+      "expression": [],
+      "value": {"aiConfig": "@FRONT_DOOR_BOT"},
+      "notes": "This single rule handles all routing. Configure the AI bot with transfer actions for Sales/Parts/Service/Billing intents."
+    },
+    {
+      "name": "Default Fallback",
+      "trigger": "route-to-team",
+      "priority": 9999,
+      "expression": [],
+      "value": {"teamId": "@DEFAULT_TEAM"}
+    }
+  ],
+  "workflows": [
+    {
+      "name": "Urgent Label — Salesforce Ticket",
+      "trigger": "label_applied",
+      "notes": "Filter to 'urgent' label. Create Salesforce case. Wire Salesforce integration first."
+    }
+  ]
+}

package/lib/migrations/donaldson.json

@@ -0,0 +1,75 @@
+{
+  "name": "Donaldson — 100+ Location Routing",
+  "slug": "donaldson",
+  "description": "Industrial filtration: 80-120 priority-ordered routing rules by URL + language. This profile creates a representative sample of the pattern — add remaining rules manually or via --file with a custom bulk export.",
+  "patterns": ["multi-location", "url-routing", "language-routing", "post-chat-crm"],
+  "notes": [
+    "This profile creates a SAMPLE of the Donaldson pattern (10 representative rules)",
+    "Full migration requires a custom JSON export from their Livefluence config",
+    "Use --file donaldson-full-export.json for a complete migration",
+    "Priority gaps (100, 110, 200...) are intentional — leave room to insert rules between regions",
+    "Salesforce integration required for post-chat case sync",
+    "Bot handoff uses confidence threshold — configure in the AI config settings"
+  ],
+  "resolve": {
+    "ai_configs": {
+      "BOT_EN": "Donaldson English Bot",
+      "BOT_DE": "Donaldson German Bot",
+      "BOT_FR": "Donaldson French Bot",
+      "BOT_JP": "Donaldson Japan Bot",
+      "BOT_DEFAULT": "Donaldson Default Bot"
+    },
+    "teams": {
+      "EMEA_DE_TEAM": "EMEA German",
+      "EMEA_FR_TEAM": "EMEA French",
+      "APAC_JP_TEAM": "APAC Japan",
+      "HE_TEAM": "Heavy Equipment Sales",
+      "GLOBAL_TEAM": "Global Support"
+    }
+  },
+  "routing_rules": [
+    {
+      "name": "EMEA — German Visitors",
+      "trigger": "use-ai",
+      "priority": 100,
+      "expression": [[{"type": "language", "data": "{\"language\":\"de\",\"comparator\":\"equals\"}"}]],
+      "value": {"aiConfig": "@BOT_DE"},
+      "notes": "Language condition. Adjust condition type/data to match your expression format."
+    },
+    {
+      "name": "EMEA — French Visitors",
+      "trigger": "use-ai",
+      "priority": 110,
+      "expression": [[{"type": "language", "data": "{\"language\":\"fr\",\"comparator\":\"equals\"}"}]],
+      "value": {"aiConfig": "@BOT_FR"}
+    },
+    {
+      "name": "APAC — Japanese Visitors",
+      "trigger": "use-ai",
+      "priority": 200,
+      "expression": [[{"type": "language", "data": "{\"language\":\"ja\",\"comparator\":\"equals\"}"}]],
+      "value": {"aiConfig": "@BOT_JP"}
+    },
+    {
+      "name": "US — Heavy Equipment",
+      "trigger": "use-ai",
+      "priority": 300,
+      "expression": [[{"type": "url", "data": "{\"url\":\"/heavy-equipment/\",\"comparator\":\"contains\"}"}]],
+      "value": {"aiConfig": "@BOT_EN"}
+    },
+    {
+      "name": "Default — Global Support",
+      "trigger": "use-ai",
+      "priority": 9999,
+      "expression": [],
+      "value": {"aiConfig": "@BOT_DEFAULT"}
+    }
+  ],
+  "workflows": [
+    {
+      "name": "Post-Chat — Salesforce Case Sync",
+      "trigger": "conversation_resolved",
+      "notes": "Push resolved conversation to Salesforce case. Wire Salesforce integration first."
+    }
+  ]
+}