@infuro/cms-core 1.0.31 → 1.0.33

package/dist/api.js

@@ -1157,6 +1157,65 @@ function resolveVendorIdForContactCheck(scope, bodyOrRow) {
   return Number.isFinite(n) ? n : null;
 }
 
+// src/api/crud.ts
+import crypto2 from "crypto";
+
+// src/plugins/llm/llm-agent-scope.ts
+var LLM_AGENT_SCOPE_CHATBOT = "chatbot";
+var LLM_AGENT_SCOPE_BLOG_CREATION = "blog_creation";
+var LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST = "social_media_post";
+var LLM_AGENT_SCOPE_EMAIL_INTENT_CHATBOT = "email_intent_chatbot";
+var LLM_AGENT_SCOPE_BLOG_METADATA = "blog_metadata";
+var LLM_AGENT_SCOPES = [
+  LLM_AGENT_SCOPE_CHATBOT,
+  LLM_AGENT_SCOPE_BLOG_CREATION,
+  LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST,
+  LLM_AGENT_SCOPE_EMAIL_INTENT_CHATBOT,
+  LLM_AGENT_SCOPE_BLOG_METADATA
+];
+var LLM_AGENT_DEFAULT_SLUG_BY_SCOPE = {
+  [LLM_AGENT_SCOPE_CHATBOT]: "site-chat-assistant",
+  [LLM_AGENT_SCOPE_BLOG_CREATION]: "blog-generator",
+  [LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST]: "blog-generator-social",
+  [LLM_AGENT_SCOPE_EMAIL_INTENT_CHATBOT]: "email-intent-chatbot",
+  [LLM_AGENT_SCOPE_BLOG_METADATA]: "blog-generator-metadata"
+};
+var LLM_AGENT_DEFAULT_NAME_BY_SCOPE = {
+  [LLM_AGENT_SCOPE_CHATBOT]: "Site Chat Assistant",
+  [LLM_AGENT_SCOPE_BLOG_CREATION]: "Blog Generator",
+  [LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST]: "Blog Generator (Social)",
+  [LLM_AGENT_SCOPE_EMAIL_INTENT_CHATBOT]: "Chat Lead Intent Classifier",
+  [LLM_AGENT_SCOPE_BLOG_METADATA]: "Blog Generator (Metadata)"
+};
+var SITE_CHAT_ASSISTANT_SLUG = LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_CHATBOT];
+var SITE_CHAT_ASSISTANT_NAME = LLM_AGENT_DEFAULT_NAME_BY_SCOPE[LLM_AGENT_SCOPE_CHATBOT];
+function isLlmAgentScope(value) {
+  if (!value?.trim()) return false;
+  return LLM_AGENT_SCOPES.includes(value.trim());
+}
+var BLOG_LLM_AGENT_SLUGS = [
+  LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_BLOG_CREATION],
+  LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_BLOG_METADATA],
+  LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST]
+];
+
+// src/plugins/llm/llm-agent-scope-crud.ts
+async function validateLlmAgentScopeForWrite(dataSource, entityMap, scope, excludeId) {
+  if (scope == null || scope === "") return null;
+  if (typeof scope !== "string" || !isLlmAgentScope(scope)) {
+    return `Invalid agent scope. Allowed: chatbot, blog_creation, social_media_post, email_intent_chatbot, blog_metadata.`;
+  }
+  const entity = entityMap.llm_agents;
+  if (!entity) return null;
+  const repo = dataSource.getRepository(entity);
+  const existing = await repo.findOne({
+    where: { scope, deleted: false }
+  });
+  if (!existing) return null;
+  if (excludeId != null && existing.id === excludeId) return null;
+  return `An active agent already uses scope "${scope}".`;
+}
+
 // src/api/crud.ts
 var CRUD_LOG = "[cms-crud]";
 function logCrudClientError(op, detail) {
@@ -1373,6 +1432,7 @@ function buildListFilterAndFromSearchParams(repo, searchParams) {
     if (name === "deleted" || name === "deletedAt" || name === "deletedBy") continue;
     if (!isListStringColumn(col)) continue;
     if (Object.prototype.hasOwnProperty.call(and, name)) continue;
+    if (name === "scope") continue;
     const raw = searchParams.get(name)?.trim();
     if (!raw) continue;
     and[name] = ILike(`%${raw}%`);
@@ -1402,6 +1462,10 @@ function buildExactListParamWhere(repo, searchParams) {
       extraWhere[name] = raw === "true";
     }
   }
+  const scopeParam = searchParams.get("scope")?.trim();
+  if (scopeParam && columnNames.has("scope")) {
+    extraWhere.scope = scopeParam;
+  }
   return extraWhere;
 }
 function mergeDeletedFalseWhere(repo, where) {
@@ -1613,6 +1677,12 @@ function discountEvaluateRule(rule, cartLines, cartTotal) {
     case "minAmount":
       return discountCompare(cartTotal, rule.comparisonOperator, ruleValue);
     case "quantity": {
+      if (rule.subType === "productId" && rule.value?.productId) {
+        const targetProductId = Number(rule.value.productId);
+        const requiredQty = Number(rule.value.v);
+        const productQty = cartLines.filter((l) => l.productId === targetProductId).reduce((s, l) => s + l.quantity, 0);
+        return discountCompare(productQty, rule.comparisonOperator, requiredQty);
+      }
       const totalQty = cartLines.reduce((s, l) => s + l.quantity, 0);
       return discountCompare(totalQty, rule.comparisonOperator, ruleValue);
     }
@@ -1676,6 +1746,10 @@ function discountExtractBuyProductId(nodes) {
       const n = Number(v);
       if (Number.isFinite(n) && n > 0) return n;
     }
+    if (node.conditionType === "rule" && node.type === "quantity" && node.subType === "productId") {
+      const n = Number(node.value?.productId);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
     if (node.children?.length) {
       const found = discountExtractBuyProductId(node.children);
       if (found !== null) return found;
@@ -2386,6 +2460,25 @@ function createCrudHandler(dataSource, entityMap, options) {
     if (pe) return pe;
     return null;
   }
+  async function tryAssignSingleVendorOnAdminCreate(resource, scope, persistBody) {
+    if (!resourceUsesVendorScope(resource) || scope.type !== "all") return;
+    const currentVendorId = Number(persistBody.vendorId);
+    if (Number.isFinite(currentVendorId) && currentVendorId > 0) return;
+    if (!entityMap.vendors) return;
+    const vendorRepo = dataSource.getRepository(entityMap.vendors);
+    const where = mergeDeletedFalseWhere(vendorRepo, {});
+    const rows = await vendorRepo.find({
+      where,
+      order: { id: "ASC" },
+      take: 2
+    });
+    if (rows.length === 1) {
+      const onlyVendorId = Number(rows[0].id);
+      if (Number.isFinite(onlyVendorId) && onlyVendorId > 0) {
+        persistBody.vendorId = onlyVendorId;
+      }
+    }
+  }
   return {
     async GET(req, resource) {
       const authError = await authz(req, resource, "read");
@@ -2901,6 +2994,7 @@ function createCrudHandler(dataSource, entityMap, options) {
         const couponCode = String(body.couponCode).trim().toUpperCase();
         const persistBody2 = pickColumnUpdates(repo2, { ...body, couponCode });
         const scopeDiscount = await resolveScope();
+        await tryAssignSingleVendorOnAdminCreate(resource, scopeDiscount, persistBody2);
         const vendorIdCheck2 = requireVendorIdForScopedCreate(
           resource,
           persistBody2,
@@ -2978,6 +3072,10 @@ function createCrudHandler(dataSource, entityMap, options) {
         });
         return json({ error: "Invalid request payload" }, { status: 400 });
       }
+      if (resource === "llm_agents" && "scope" in persistBody) {
+        const scopeErr = await validateLlmAgentScopeForWrite(dataSource, entityMap, persistBody.scope);
+        if (scopeErr) return json({ error: scopeErr }, { status: 400 });
+      }
       if (resource === "products") {
         if ("sku" in persistBody) {
           const skuNorm = normalizeProductSku(persistBody.sku);
@@ -3093,6 +3191,7 @@ function createCrudHandler(dataSource, entityMap, options) {
         );
       }
       const scopeCreate = await resolveScope();
+      await tryAssignSingleVendorOnAdminCreate(resource, scopeCreate, persistBody);
       const vendorIdCheck = requireVendorIdForScopedCreate(resource, persistBody, scopeCreate, repo, body);
       if (!vendorIdCheck.ok) {
         return json({ error: vendorIdCheck.error }, { status: vendorIdCheck.status });
@@ -3135,6 +3234,7 @@ function createCrudHandler(dataSource, entityMap, options) {
           const randomPart = Math.floor(1e4 + Math.random() * 9e4);
           persistBody.contactId = contact.id;
           persistBody.orderNumber = `ORD00${randomPart}`;
+          persistBody.qrToken = crypto2.randomBytes(16).toString("hex");
         }
         created = await repo.save(repo.create(persistBody));
         if (resource === "orders") {
@@ -3903,6 +4003,15 @@ function createCrudByIdHandler(dataSource, entityMap, options) {
         const t = updatePayload.type;
         if (t === "" || t === "none" || t == null) updatePayload.type = null;
       }
+      if (resource === "llm_agents" && "scope" in updatePayload) {
+        const scopeErr = await validateLlmAgentScopeForWrite(
+          dataSource,
+          entityMap,
+          updatePayload.scope,
+          numericId
+        );
+        if (scopeErr) return json({ error: scopeErr }, { status: 400 });
+      }
       if ((resource === "orders" || resource === "payments") && "contactId" in updatePayload && updatePayload.contactId != null && entityMap.vendor_customers) {
         const existingRow = await repo.findOne({
           where: { id: numericId }
@@ -4112,8 +4221,8 @@ function createForgotPasswordHandler(config) {
       const user = await userRepo.findOne({ where: { email }, select: ["email"] });
       const msg = "If an account exists with this email, you will receive a reset link shortly.";
       if (!user) return json({ message: msg }, { status: 200 });
-      const crypto2 = await import("crypto");
-      const token = crypto2.randomBytes(32).toString("hex");
+      const crypto3 = await import("crypto");
+      const token = crypto3.randomBytes(32).toString("hex");
       const expiresAt = new Date(Date.now() + resetExpiryHours * 60 * 60 * 1e3);
       const tokenRepo = dataSource.getRepository(entityMap.password_reset_tokens);
       await tokenRepo.save(tokenRepo.create({ email: user.email, token, expiresAt }));
@@ -4266,6 +4375,7 @@ var LlmAgent = class {
   id;
   name;
   slug;
+  scope;
   systemInstruction;
   model;
   temperature;
@@ -4289,6 +4399,9 @@ __decorateClass([
 __decorateClass([
   Column("varchar")
 ], LlmAgent.prototype, "slug", 2);
+__decorateClass([
+  Column("varchar", { nullable: true })
+], LlmAgent.prototype, "scope", 2);
 __decorateClass([
   Column("text", { name: "system_instruction", default: "" })
 ], LlmAgent.prototype, "systemInstruction", 2);
@@ -4340,6 +4453,515 @@ function llmAgentToChatAgentOptions(agent) {
   };
 }
 
+// src/plugins/llm/chat-email-intent.ts
+var NONE_INTENT = "NONE";
+var CHAT_EMAIL_LOG = "[chat-email-tool]";
+function logChatEmail(step, data) {
+  if (data && Object.keys(data).length > 0) {
+    console.info(CHAT_EMAIL_LOG, step, data);
+  } else {
+    console.info(CHAT_EMAIL_LOG, step);
+  }
+}
+function normalizeIntentKey(raw) {
+  return raw.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function parseIntentsJson(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return null;
+    const out = [];
+    for (const row of parsed) {
+      if (!row || typeof row !== "object") continue;
+      const o = row;
+      const intent = normalizeIntentKey(String(o.intent ?? o.id ?? ""));
+      const description = String(o.description ?? "").trim();
+      const emailTo = String(o.emailTo ?? o.email ?? "").trim();
+      if (!intent || !description || !emailTo) continue;
+      out.push({ intent, description, emailTo });
+    }
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function dedupeIntents(intents) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of intents) {
+    const key = normalizeIntentKey(row.intent);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      intent: key,
+      description: row.description.trim(),
+      emailTo: row.emailTo.trim()
+    });
+  }
+  return out;
+}
+function parseChatEmailToolSettings(map) {
+  const fromJson = parseIntentsJson(map.emailIntents);
+  const intents = dedupeIntents(fromJson ?? []);
+  const legacyPositive = map.emailIntentPrompt?.trim() ?? "";
+  const legacyNegative = map.emailNegativeIntentPrompt?.trim() ?? "";
+  let classifierInstructions = map.emailClassifierInstructions?.trim() ?? "";
+  if (!classifierInstructions && (legacyPositive || legacyNegative)) {
+    const parts = [];
+    if (legacyPositive) parts.push(`Legacy positive signals:
+${legacyPositive}`);
+    if (legacyNegative) parts.push(`Do NOT assign an intent when:
+${legacyNegative}`);
+    classifierInstructions = parts.join("\n\n");
+  }
+  return {
+    enabled: map.emailToolEnabled === "true",
+    intents,
+    classifierInstructions,
+    toolPrompt: map.emailToolPrompt ?? ""
+  };
+}
+var EMAIL_TOOL_VALIDATION_KEY = "emailTool";
+function parseEmailToolObject(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const o = raw;
+  const intentsRaw = o.intents;
+  let intents;
+  if (Array.isArray(intentsRaw)) {
+    const parsed = parseIntentsJson(JSON.stringify(intentsRaw));
+    if (parsed?.length) intents = parsed;
+  }
+  return {
+    enabled: o.enabled === true,
+    classifierInstructions: typeof o.classifierInstructions === "string" ? o.classifierInstructions.trim() : void 0,
+    toolPrompt: typeof o.toolPrompt === "string" ? o.toolPrompt.trim() : void 0,
+    intents
+  };
+}
+function parseEmailToolFromAgentValidationRules(validationRulesText) {
+  const raw = validationRulesText?.trim();
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const emailTool = parsed[EMAIL_TOOL_VALIDATION_KEY];
+    return parseEmailToolObject(emailTool);
+  } catch {
+    return null;
+  }
+}
+function resolveChatEmailToolSettings(configMap, sources) {
+  const fromConfig = parseChatEmailToolSettings(configMap);
+  const resolved = typeof sources === "string" || sources == null ? { chatbotValidationRules: typeof sources === "string" ? sources : null } : sources;
+  const fromChatbot = parseEmailToolFromAgentValidationRules(resolved.chatbotValidationRules);
+  const fromNotify = resolved.notifyAgent ? parseEmailToolFromAgentValidationRules(resolved.notifyAgent.validationRules) : null;
+  const notifySystem = resolved.notifyAgent?.systemInstruction?.trim() ?? "";
+  const intents = fromNotify?.intents?.length ? fromNotify.intents : fromChatbot?.intents?.length ? fromChatbot.intents : fromConfig.intents;
+  const classifierParts = [
+    notifySystem,
+    fromNotify?.classifierInstructions?.trim(),
+    fromChatbot?.classifierInstructions?.trim(),
+    fromConfig.classifierInstructions.trim()
+  ].filter(Boolean);
+  const toolPrompt = fromNotify?.toolPrompt?.trim() || fromChatbot?.toolPrompt?.trim() || fromConfig.toolPrompt?.trim() || "";
+  return {
+    enabled: fromConfig.enabled,
+    intents,
+    classifierInstructions: classifierParts.join("\n\n"),
+    toolPrompt
+  };
+}
+function intentByKey(intents, key) {
+  if (!key) return null;
+  const norm2 = normalizeIntentKey(key);
+  return intents.find((i) => i.intent === norm2) ?? null;
+}
+function buildIntentTableForPrompt(intents) {
+  return intents.map((i) => `- ${i.intent}: ${i.description} \u2192 notify ${i.emailTo}`).join("\n");
+}
+function buildIntentClassifierSystem(config, agentClassifierInstructions) {
+  const table = buildIntentTableForPrompt(config.intents);
+  const extra = [agentClassifierInstructions?.trim(), config.classifierInstructions.trim()].filter(Boolean).join("\n\n");
+  const intentKeys = config.intents.map((i) => i.intent).join(", ");
+  return `You classify a chat visitor into exactly one lead intent for email routing.
+
+Available intents (pick the best match):
+${table}
+
+If the visitor is not ready for a lead email (general FAQ, greetings only, spam, off-topic, no clear business need), use intent "${NONE_INTENT}".
+
+Allowed intent values: ${intentKeys}, or ${NONE_INTENT}.
+
+${extra ? `Additional instructions:
+${extra}
+` : ""}
+Reply with ONLY valid JSON, no markdown:
+{"intent":"INTENT_KEY","reason":"short explanation"}
+Use "${NONE_INTENT}" when no intent applies.`;
+}
+function buildChatEmailAgentContext(settings) {
+  if (!settings.enabled) return "";
+  const classifier = settings.classifierInstructions.trim();
+  const extra = settings.toolPrompt?.trim() ?? "";
+  const parts = [];
+  if (settings.intents.length > 0) {
+    parts.push(
+      "## Lead email routing",
+      "When a visitor message clearly matches an intent below, the system sends one team notification email (per conversation). Continue the conversation normally in all cases."
+    );
+    if (classifier) parts.push(`### Routing rules
+${classifier}`);
+    parts.push(`### Intent catalog
+${buildIntentTableForPrompt(settings.intents)}`);
+  } else if (classifier) {
+    parts.push(`## Lead email routing
+${classifier}`);
+  }
+  if (extra) parts.push(`### Assistant behavior
+${extra}`);
+  return parts.join("\n\n");
+}
+function buildChatbotSystemPromptWithEmailTool(baseSystemInstruction, guardrailsForPrompt, emailSettings) {
+  let prompt = (baseSystemInstruction ?? "").trim();
+  const guard = guardrailsForPrompt?.trim();
+  if (guard) prompt = [prompt, guard].filter(Boolean).join("\n\n");
+  if (emailSettings.enabled) {
+    const emailCtx = buildChatEmailAgentContext(emailSettings);
+    if (emailCtx) prompt = [prompt, emailCtx].filter(Boolean).join("\n\n");
+  }
+  return prompt;
+}
+function formatTranscript(history, latestMessage, maxChars = 4e3) {
+  const lines = [];
+  for (const m of history) {
+    const role = m.role === "assistant" ? "Assistant" : m.role === "user" ? "Visitor" : "System";
+    lines.push(`${role}: ${m.content}`);
+  }
+  const last = history[history.length - 1];
+  if (!last || last.role !== "user" || last.content !== latestMessage) {
+    lines.push(`Visitor: ${latestMessage}`);
+  }
+  let text = lines.join("\n");
+  if (text.length > maxChars) text = text.slice(-maxChars);
+  return text;
+}
+function parseIntentJson(raw, intents) {
+  const trimmed = raw.trim();
+  const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = (fence?.[1] ?? trimmed).trim();
+  const tryParse = (s) => {
+    const o = JSON.parse(s);
+    let intentRaw = null;
+    if (typeof o.intent === "string") intentRaw = o.intent;
+    else if (o.interested === false) intentRaw = NONE_INTENT;
+    else if (o.interested === true && intents[0]) intentRaw = intents[0].intent;
+    if (intentRaw == null) return null;
+    const reason = typeof o.reason === "string" && o.reason.trim() ? o.reason.trim() : "Classified from conversation";
+    return { intent: normalizeIntentKey(intentRaw), reason };
+  };
+  try {
+    return tryParse(candidate);
+  } catch {
+    const m = candidate.match(/\{[\s\S]*\}/);
+    if (!m) return null;
+    try {
+      return tryParse(m[0]);
+    } catch {
+      return null;
+    }
+  }
+}
+async function detectChatLeadIntent(llm, params) {
+  if (!params.settings.intents.length) {
+    logChatEmail("classify skipped", { reason: "no_intents_configured" });
+    return {
+      intent: null,
+      intentLabel: "NONE",
+      reason: "No lead intents configured",
+      emailTo: null
+    };
+  }
+  logChatEmail("classify start", {
+    intentCount: params.settings.intents.length,
+    intentKeys: params.settings.intents.map((i) => i.intent),
+    model: params.model?.trim() || "(gateway default)",
+    messageChars: params.message.length,
+    historyTurns: params.history.length,
+    hasClassifierInstructions: Boolean(
+      params.agentClassifierInstructions?.trim() || params.settings.classifierInstructions.trim()
+    )
+  });
+  const transcript = formatTranscript(params.history, params.message);
+  const contactLines = [
+    params.contact.name?.trim() ? `Name: ${params.contact.name.trim()}` : null,
+    params.contact.email?.trim() ? `Email: ${params.contact.email.trim()}` : null,
+    params.contact.phone?.trim() ? `Phone: ${params.contact.phone.trim()}` : null
+  ].filter(Boolean).join("\n");
+  const userPrompt = `Customer:
+${contactLines || "(unknown)"}
+
+Conversation:
+${transcript}
+
+Pick the single best intent for the visitor's latest message.`;
+  const res = await llm.chatAgent({
+    systemPrompt: buildIntentClassifierSystem(params.settings, params.agentClassifierInstructions),
+    userPrompt,
+    temperature: 0.1,
+    max_tokens: 256,
+    ...params.model?.trim() ? { model: params.model.trim() } : {}
+  });
+  const rawContent = res.content ?? "";
+  logChatEmail("classify llm response", {
+    responseChars: rawContent.length,
+    responsePreview: rawContent.slice(0, 280) + (rawContent.length > 280 ? "\u2026" : "")
+  });
+  const parsed = parseIntentJson(rawContent, params.settings.intents);
+  if (!parsed) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: "parse_failed",
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: "Unclassified",
+      reason: "Could not parse intent classifier response",
+      emailTo: null
+    };
+  }
+  if (parsed.intent === NONE_INTENT) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: NONE_INTENT,
+      reason: parsed.reason,
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: NONE_INTENT,
+      reason: parsed.reason,
+      emailTo: null
+    };
+  }
+  const matched = intentByKey(params.settings.intents, parsed.intent);
+  if (!matched) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: "unknown_intent",
+      parsedIntent: parsed.intent,
+      reason: parsed.reason,
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: parsed.intent,
+      reason: `Unknown intent "${parsed.intent}": ${parsed.reason}`,
+      emailTo: null
+    };
+  }
+  logChatEmail("classify result", {
+    matched: true,
+    outcome: "intent_found",
+    intent: matched.intent,
+    emailTo: matched.emailTo,
+    reason: parsed.reason,
+    emailWillSend: true
+  });
+  return {
+    intent: matched.intent,
+    intentLabel: `${matched.intent} \u2014 ${matched.description}`,
+    reason: parsed.reason,
+    emailTo: matched.emailTo
+  };
+}
+function buildTranscriptForLeadEmail(history, latestMessage) {
+  return formatTranscript(history, latestMessage);
+}
+function parseIntentRecipientEmails(emailTo) {
+  return emailTo.split(/[,;]+/).map((s) => s.trim()).filter((s) => s.length > 0 && s.includes("@"));
+}
+
+// src/plugins/llm/find-llm-agent-by-scope.ts
+async function findLlmAgentByScope(dataSource, entityMap, scope, options = {}) {
+  const { enabledOnly = true } = options;
+  const entity = entityMap.llm_agents;
+  if (!entity) return null;
+  const repo = dataSource.getRepository(entity);
+  const where = { scope, deleted: false };
+  if (enabledOnly) where.enabled = true;
+  return repo.findOne({ where });
+}
+
+// src/plugins/email/templates/types.ts
+function normalizeSocialLinkItem(o) {
+  const url = String(o.url ?? "").trim();
+  if (!url) return null;
+  let iconUrl = String(o.iconUrl ?? o.icon_image ?? "").trim();
+  let icon = String(o.icon ?? "").trim();
+  if (!iconUrl && /^https?:\/\//i.test(icon)) {
+    iconUrl = icon;
+    icon = "";
+  }
+  const item = { url };
+  if (iconUrl) item.iconUrl = iconUrl;
+  if (icon) item.icon = icon;
+  return item;
+}
+function parseSocialLinksJson(raw) {
+  if (raw == null || raw.trim() === "") return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return void 0;
+    const out = [];
+    for (const item of parsed) {
+      if (item && typeof item === "object" && "url" in item) {
+        const n = normalizeSocialLinkItem(item);
+        if (n) out.push(n);
+      }
+    }
+    return out.length ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function mergeEmailLayoutCompanyDetails(branding, emailSettings) {
+  const fromBranding = getCompanyDetailsFromSettings(branding);
+  const pick = (emailVal, fallback) => {
+    const t = emailVal?.trim();
+    return t || fallback?.trim() || void 0;
+  };
+  const logoUrl = pick(emailSettings.logoUrl ?? emailSettings.emailLogoUrl, fromBranding.logoUrl);
+  const companyName = pick(emailSettings.companyName ?? emailSettings.emailCompanyName, fromBranding.companyName);
+  const supportEmail = pick(emailSettings.supportEmail ?? emailSettings.emailSupportEmail, fromBranding.supportEmail);
+  const supportPhone = pick(emailSettings.supportPhone, void 0);
+  const footerDisclaimer = pick(emailSettings.footerDisclaimer, void 0);
+  const followUsTitle = pick(emailSettings.followUsTitle, "Follow Us") || "Follow Us";
+  const socialFromEmail = parseSocialLinksJson(emailSettings.socialLinks);
+  const socialLinks = socialFromEmail?.length ? socialFromEmail : fromBranding.socialLinks;
+  return {
+    logoUrl,
+    companyName,
+    supportEmail,
+    supportPhone,
+    socialLinks,
+    footerDisclaimer,
+    followUsTitle
+  };
+}
+function getCompanyDetailsFromSettings(settingsGroup) {
+  const logoUrl = settingsGroup.logo ?? settingsGroup.logoUrl ?? "";
+  const companyName = settingsGroup.companyName ?? settingsGroup.company_name ?? "";
+  const supportEmail = settingsGroup.supportEmail ?? settingsGroup.support_email ?? "";
+  let socialLinks = [];
+  const raw = settingsGroup.socialLinks ?? settingsGroup.social_links;
+  if (typeof raw === "string") {
+    try {
+      const arr = JSON.parse(raw);
+      if (Array.isArray(arr)) {
+        for (const item of arr) {
+          if (item && typeof item === "object") {
+            const n = normalizeSocialLinkItem(item);
+            if (n) socialLinks.push(n);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return { logoUrl: logoUrl || void 0, companyName: companyName || void 0, supportEmail: supportEmail || void 0, socialLinks: socialLinks.length ? socialLinks : void 0 };
+}
+
+// src/plugins/email/chat-lead-email.ts
+init_email_queue();
+
+// src/lib/email-recipients.ts
+function parseEmailRecipientsFromConfig(raw) {
+  if (raw == null || raw === "") return [];
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed.map((e) => String(e).trim()).filter(Boolean);
+      }
+    } catch {
+    }
+  }
+  return trimmed.split(/[,;]+/).map((s) => s.trim()).filter(Boolean);
+}
+
+// src/plugins/email/chat-lead-email.ts
+function resolveLeadRecipients(emailPlugin, emailSettings) {
+  const fromCrm = parseEmailRecipientsFromConfig(
+    emailSettings.crmEmails ?? emailSettings.crmEmail ?? ""
+  );
+  if (fromCrm.length > 0) return fromCrm;
+  const fallback = emailPlugin.getDefaultTo?.() ?? "";
+  if (fallback.trim()) return [fallback.trim()];
+  return [];
+}
+async function sendChatLeadEmail(cms, emailSettings, brandingSettings, input) {
+  console.info(CHAT_EMAIL_LOG, "send start", {
+    conversationId: input.conversationId,
+    intentCode: input.intentCode ?? null,
+    contactEmail: input.contactEmail,
+    contactName: input.contactName,
+    explicitRecipients: input.recipients?.length ?? 0
+  });
+  const email = cms.getPlugin("email");
+  if (!email?.send || !email.renderTemplate) {
+    console.warn(CHAT_EMAIL_LOG, "send failed", {
+      conversationId: input.conversationId,
+      reason: "email_plugin_disabled"
+    });
+    return { sent: false, recipients: [], error: "Email plugin is not enabled" };
+  }
+  const recipients = input.recipients?.filter((r) => r.trim().includes("@")).map((r) => r.trim()) ?? resolveLeadRecipients(email, emailSettings);
+  if (recipients.length === 0) {
+    console.warn(CHAT_EMAIL_LOG, "send failed", {
+      conversationId: input.conversationId,
+      reason: "no_recipients"
+    });
+    return {
+      sent: false,
+      recipients: [],
+      error: "No lead email recipients (configure intent Email To, CRM emails, or SMTP default To)"
+    };
+  }
+  console.info(CHAT_EMAIL_LOG, "send recipients resolved", {
+    conversationId: input.conversationId,
+    recipients,
+    source: input.recipients?.length ? "intent_email_to" : "crm_or_smtp_fallback"
+  });
+  const companyDetails = mergeEmailLayoutCompanyDetails(brandingSettings, emailSettings);
+  const ctx = {
+    ...input,
+    companyDetails: input.companyDetails ?? companyDetails
+  };
+  let anySent = false;
+  for (const to of recipients) {
+    await queueEmail(cms, {
+      to,
+      templateName: "chatLead",
+      ctx
+    });
+    console.info(CHAT_EMAIL_LOG, "send queued", {
+      conversationId: input.conversationId,
+      to,
+      template: "chatLead"
+    });
+    anySent = true;
+  }
+  console.info(CHAT_EMAIL_LOG, "send complete", {
+    conversationId: input.conversationId,
+    sent: anySent,
+    recipientCount: recipients.length
+  });
+  return { sent: anySent, recipients };
+}
+
 // src/lib/media-folder-path.ts
 function sanitizeMediaFolderPath(input) {
   if (input == null) return "";
@@ -5819,16 +6441,19 @@ function normalizeChatModeSetting(raw) {
   if (raw === "external" || raw === "llm") return raw;
   return "whatsapp";
 }
-async function loadLlmSettingsMap(dataSource, entityMap) {
+async function loadSettingsGroupMap(dataSource, entityMap, group) {
   if (!entityMap.configs) return {};
   const repo = dataSource.getRepository(entityMap.configs);
-  const rows = await repo.find({ where: { settings: "llm", deleted: false } });
+  const rows = await repo.find({ where: { settings: group, deleted: false } });
   const out = {};
   for (const row of rows) {
     out[row.key] = row.value;
   }
   return out;
 }
+async function loadLlmSettingsMap(dataSource, entityMap) {
+  return loadSettingsGroupMap(dataSource, entityMap, "llm");
+}
 function createChatHandlers(config) {
   const { dataSource, entityMap, json, getCms } = config;
   const contactRepo = () => dataSource.getRepository(entityMap.contacts);
@@ -5840,10 +6465,13 @@ function createChatHandlers(config) {
       try {
         const map = await loadLlmSettingsMap(dataSource, entityMap);
         const mode = normalizeChatModeSetting(map.chatMode);
+        const chatbotAgent = mode === "llm" && entityMap.llm_agents ? await findLlmAgentByScope(dataSource, entityMap, LLM_AGENT_SCOPE_CHATBOT, {
+          enabledOnly: false
+        }) : null;
         const body = {
           enabled: map.enabled !== "false",
           chatMode: mode,
-          agentSlug: mode === "llm" ? (map.attachedAgentSlug ?? "").trim() : "",
+          agentSlug: mode === "llm" ? chatbotAgent?.slug?.trim() || LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_CHATBOT] : "",
           botName: map.botName ?? "",
           icon: map.icon ?? "",
           iconImageUrl: map.iconImageUrl ?? "",
@@ -5929,24 +6557,26 @@ function createChatHandlers(config) {
         if (!llm?.chat) return json({ error: "LLM not configured" }, { status: 503 });
         const llmSettings = await loadLlmSettingsMap(dataSource, entityMap);
         const supportMode = normalizeChatModeSetting(llmSettings.chatMode);
-        let effectiveSlug = (body?.agentSlug ?? "").trim();
-        if (!effectiveSlug && supportMode === "llm" && entityMap.llm_agents) {
-          effectiveSlug = (llmSettings.attachedAgentSlug ?? "").trim();
-        }
+        const bodyAgentSlug = (body?.agentSlug ?? "").trim();
         let agentRow = null;
-        if (effectiveSlug) {
-          if (!entityMap.llm_agents) {
-            return json({ error: "LLM agents are not configured on this deployment" }, { status: 400 });
-          }
-          const agentRepo = dataSource.getRepository(
-            entityMap.llm_agents
-          );
-          agentRow = await agentRepo.findOne({
-            where: { slug: effectiveSlug, deleted: false, enabled: true }
-          });
-          if (!agentRow && (body?.agentSlug ?? "").trim()) {
-            return json({ error: "Agent not found or disabled", agentSlug: effectiveSlug }, { status: 404 });
+        let effectiveSlug = bodyAgentSlug;
+        if (entityMap.llm_agents) {
+          if (bodyAgentSlug) {
+            const agentRepo = dataSource.getRepository(
+              entityMap.llm_agents
+            );
+            agentRow = await agentRepo.findOne({
+              where: { slug: bodyAgentSlug, deleted: false, enabled: true }
+            });
+            if (!agentRow) {
+              return json({ error: "Agent not found or disabled", agentSlug: bodyAgentSlug }, { status: 404 });
+            }
+          } else if (supportMode === "llm") {
+            agentRow = await findLlmAgentByScope(dataSource, entityMap, LLM_AGENT_SCOPE_CHATBOT);
+            effectiveSlug = agentRow?.slug?.trim() || LLM_AGENT_DEFAULT_SLUG_BY_SCOPE[LLM_AGENT_SCOPE_CHATBOT];
           }
+        } else if (bodyAgentSlug) {
+          return json({ error: "LLM agents are not configured on this deployment" }, { status: 400 });
         }
         console.info(RAG_LOG, "step 1 | resolve agent", {
           agentSlug: effectiveSlug || "(none)",
@@ -6044,6 +6674,139 @@ function createChatHandlers(config) {
         }
         const historyRaw = (conv.messages ?? []).sort((a, b) => new Date(a.createdAt ?? 0).getTime() - new Date(b.createdAt ?? 0).getTime()).map((m) => ({ role: m.role, content: m.content }));
         const history = historyBeforeCurrentUser(historyRaw, message);
+        const notifyEmailAgent = await findLlmAgentByScope(
+          dataSource,
+          entityMap,
+          LLM_AGENT_SCOPE_EMAIL_INTENT_CHATBOT,
+          { enabledOnly: false }
+        );
+        const emailTool = resolveChatEmailToolSettings(llmSettings, {
+          chatbotValidationRules: agentRow?.validationRules ?? null,
+          notifyAgent: notifyEmailAgent ? {
+            systemInstruction: notifyEmailAgent.systemInstruction,
+            validationRules: notifyEmailAgent.validationRules
+          } : null
+        });
+        const emailPlugin = cms.getPlugin("email");
+        const convLeadSent = conv.leadEmailSentAt;
+        const chatAgentFn = llm.chatAgent?.bind(llm);
+        console.info(CHAT_EMAIL_LOG, "pipeline check", {
+          conversationId,
+          enabled: emailTool.enabled,
+          intentCount: emailTool.intents.length,
+          chatbotAgentId: agentRow?.id ?? null,
+          chatbotAgentSlug: agentRow?.slug ?? null,
+          notifyEmailAgentId: notifyEmailAgent?.id ?? null,
+          notifyEmailAgentSlug: notifyEmailAgent?.slug ?? null,
+          emailPluginPresent: Boolean(emailPlugin),
+          chatAgentFnPresent: Boolean(chatAgentFn),
+          leadEmailAlreadySent: Boolean(convLeadSent),
+          mergedPromptIncludesNotify: Boolean(notifyEmailAgent?.systemInstruction?.trim())
+        });
+        if (!emailTool.enabled) {
+          console.info(CHAT_EMAIL_LOG, "pipeline skipped", {
+            conversationId,
+            reason: "email_tool_disabled"
+          });
+        } else if (emailTool.intents.length === 0) {
+          console.info(CHAT_EMAIL_LOG, "pipeline skipped", {
+            conversationId,
+            reason: "no_intents_configured"
+          });
+        } else if (!emailPlugin) {
+          console.info(CHAT_EMAIL_LOG, "pipeline skipped", {
+            conversationId,
+            reason: "email_plugin_missing"
+          });
+        } else if (!chatAgentFn) {
+          console.info(CHAT_EMAIL_LOG, "pipeline skipped", {
+            conversationId,
+            reason: "llm_chat_agent_unavailable"
+          });
+        } else if (convLeadSent) {
+          console.info(CHAT_EMAIL_LOG, "pipeline skipped", {
+            conversationId,
+            reason: "lead_email_already_sent",
+            leadEmailSentAt: convLeadSent
+          });
+        } else {
+          const contactId = conv.contactId;
+          const contactRow = await contactRepo().findOne({
+            where: { id: contactId }
+          });
+          if (!contactRow) {
+            console.warn(CHAT_EMAIL_LOG, "pipeline skipped", {
+              conversationId,
+              reason: "contact_not_found",
+              contactId
+            });
+          } else {
+            const c = contactRow;
+            try {
+              const intent = await detectChatLeadIntent({ chatAgent: chatAgentFn }, {
+                settings: emailTool,
+                message,
+                history,
+                contact: { name: c.name, email: c.email, phone: c.phone },
+                model: agentRow?.model?.trim() || notifyEmailAgent?.model?.trim() || void 0
+              });
+              if (!intent.intent || !intent.emailTo) {
+                console.info(CHAT_EMAIL_LOG, "no email sent", {
+                  conversationId,
+                  reason: intent.intent ? "missing_email_to" : "no_intent_match",
+                  intentLabel: intent.intentLabel,
+                  classifierReason: intent.reason
+                });
+              } else {
+                const intentRecipients = parseIntentRecipientEmails(intent.emailTo);
+                console.info(CHAT_EMAIL_LOG, "intent matched \u2014 sending", {
+                  conversationId,
+                  intent: intent.intent,
+                  emailTo: intent.emailTo,
+                  parsedRecipientCount: intentRecipients.length,
+                  recipients: intentRecipients
+                });
+                const emailSettings = await loadSettingsGroupMap(dataSource, entityMap, "email");
+                const brandingSettings = await loadSettingsGroupMap(dataSource, entityMap, "branding");
+                const companyDetails = mergeEmailLayoutCompanyDetails(brandingSettings, emailSettings);
+                const leadResult = await sendChatLeadEmail(cms, emailSettings, brandingSettings, {
+                  contactName: String(c.name ?? "").trim() || "Visitor",
+                  contactEmail: String(c.email ?? "").trim(),
+                  contactPhone: c.phone ?? null,
+                  conversationId,
+                  latestMessage: message,
+                  intentCode: intent.intent,
+                  intentReason: intent.intentLabel || intent.reason,
+                  transcript: buildTranscriptForLeadEmail(history, message),
+                  companyDetails,
+                  recipients: intentRecipients.length > 0 ? intentRecipients : void 0
+                });
+                if (leadResult.sent) {
+                  await convRepo().update(conversationId, {
+                    leadEmailSentAt: /* @__PURE__ */ new Date()
+                  });
+                  console.info(CHAT_EMAIL_LOG, "lead email recorded", {
+                    conversationId,
+                    sent: true,
+                    recipients: leadResult.recipients
+                  });
+                } else {
+                  console.warn(CHAT_EMAIL_LOG, "lead email not sent", {
+                    conversationId,
+                    sent: false,
+                    error: leadResult.error ?? "unknown",
+                    recipients: leadResult.recipients
+                  });
+                }
+              }
+            } catch (intentErr) {
+              console.warn(CHAT_EMAIL_LOG, "pipeline error", {
+                conversationId,
+                error: intentErr instanceof Error ? intentErr.message : String(intentErr)
+              });
+            }
+          }
+        }
         let content;
         const ragContext = contextParts.length > 0 ? contextParts.join("\n\n") : void 0;
         console.info(RAG_LOG, "step 7 | final context", {
@@ -6054,9 +6817,10 @@ function createChatHandlers(config) {
         });
         if (agentRow && llm.chatAgent) {
           const fromAgent = llmAgentToChatAgentOptions(agentRow);
-          const systemPrompt = mergeGuardrailsIntoSystemPrompt(
+          const systemPrompt = buildChatbotSystemPromptWithEmailTool(
             fromAgent.systemPrompt,
-            parsedValidation.guardrailsForPrompt
+            parsedValidation.guardrailsForPrompt,
+            emailTool
           );
           const res = await llm.chatAgent({
             ...fromAgent,
@@ -6074,11 +6838,12 @@ ${contextParts.join("\n\n")}` : "";
           const defaultSystem = "You are a helpful assistant for the company. If you do not have specific information, say so.";
           let systemContent;
           if (agentRow) {
-            const base = agentRow.systemInstruction?.trim() || "";
-            systemContent = mergeGuardrailsIntoSystemPrompt(
-              [base, ragSystem].filter(Boolean).join("\n\n") || defaultSystem,
-              parsedValidation.guardrailsForPrompt
-            );
+            const mergedBase = [agentRow.systemInstruction?.trim(), ragSystem].filter(Boolean).join("\n\n");
+            systemContent = buildChatbotSystemPromptWithEmailTool(
+              mergedBase || defaultSystem,
+              parsedValidation.guardrailsForPrompt,
+              emailTool
+            ) || defaultSystem;
           } else {
             systemContent = ragSystem || defaultSystem;
           }
@@ -8603,6 +9368,7 @@ var Order = class {
   id;
   vendorId;
   orderNumber;
+  qrToken;
   orderKind;
   parentOrderId;
   contactId;
@@ -8640,6 +9406,9 @@ __decorateClass([
 __decorateClass([
   Column18("varchar")
 ], Order.prototype, "orderNumber", 2);
+__decorateClass([
+  Column18("varchar", { unique: true, nullable: true })
+], Order.prototype, "qrToken", 2);
 __decorateClass([
   Column18("varchar", { default: "sale" })
 ], Order.prototype, "orderKind", 2);
@@ -8868,6 +9637,7 @@ var ChatConversation = class {
   contactId;
   createdAt;
   updatedAt;
+  leadEmailSentAt;
   contact;
   messages;
 };
@@ -8883,6 +9653,9 @@ __decorateClass([
 __decorateClass([
   Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], ChatConversation.prototype, "updatedAt", 2);
+__decorateClass([
+  Column21({ type: "timestamp", nullable: true })
+], ChatConversation.prototype, "leadEmailSentAt", 2);
 __decorateClass([
   ManyToOne12(() => Contact, (c) => c.chatConversations, { onDelete: "CASCADE" }),
   JoinColumn12({ name: "contactId" })
@@ -11123,7 +11896,6 @@ var CMS_ENTITY_MAP = {
 import Parser from "rss-parser";
 
 // src/plugins/blog-generator/blog-generator-agent-defaults.ts
-var BLOG_GENERATOR_LLM_AGENT_SLUG = "blog-generator";
 var BLOG_GENERATOR_MARKDOWN_ARTICLE_SEPARATOR = "---BLOG_GENERATOR_NEXT---";
 var BLOG_GENERATOR_DEFAULT_SYSTEM_INSTRUCTION = `You are a professional financial and business content writer.
 
@@ -11203,7 +11975,6 @@ var BLOG_GENERATOR_DEFAULT_VALIDATION_RULES = JSON.stringify(
 );
 
 // src/plugins/blog-generator/blog-generator-metadata-defaults.ts
-var BLOG_METADATA_ENRICHER_LLM_AGENT_SLUG = "blog-generator-metadata";
 var BLOG_METADATA_ENRICHER_DEFAULT_VALIDATION_RULES = JSON.stringify(
   {
     maxUserChars: 5e5,
@@ -11214,7 +11985,6 @@ var BLOG_METADATA_ENRICHER_DEFAULT_VALIDATION_RULES = JSON.stringify(
 );
 
 // src/plugins/blog-generator/blog-generator-social-defaults.ts
-var BLOG_SOCIAL_ENRICHER_LLM_AGENT_SLUG = "blog-generator-social";
 var BLOG_SOCIAL_ENRICHER_DEFAULT_VALIDATION_RULES = JSON.stringify(
   {
     maxUserChars: 5e5,
@@ -13341,28 +14111,24 @@ function createCmsApiHandler(config) {
         let socialLlmAgentResolution = null;
         let metadataRow = null;
         let socialRow = null;
+        let blogCreationRow = null;
         if (entityMap.llm_agents) {
-          const agentRepo = dataSource.getRepository(entityMap.llm_agents);
-          const agentRow = await agentRepo.findOne({
-            where: { slug: BLOG_GENERATOR_LLM_AGENT_SLUG, deleted: false, enabled: true }
-          });
-          if (agentRow) {
-            const o = llmAgentToChatAgentOptions(agentRow);
+          blogCreationRow = await findLlmAgentByScope(dataSource, entityMap, LLM_AGENT_SCOPE_BLOG_CREATION);
+          if (blogCreationRow) {
+            const o = llmAgentToChatAgentOptions(blogCreationRow);
             llmAgentChatOptions = {
               model: o.model,
               temperature: o.temperature,
               max_tokens: o.max_tokens
             };
             llmAgentResolution = {
-              slug: BLOG_GENERATOR_LLM_AGENT_SLUG,
-              model: agentRow.model?.trim() || null,
-              temperature: agentRow.temperature ?? null,
-              maxTokens: agentRow.maxTokens ?? null
+              slug: blogCreationRow.slug,
+              model: blogCreationRow.model?.trim() || null,
+              temperature: blogCreationRow.temperature ?? null,
+              maxTokens: blogCreationRow.maxTokens ?? null
             };
           }
-          metadataRow = await agentRepo.findOne({
-            where: { slug: BLOG_METADATA_ENRICHER_LLM_AGENT_SLUG, deleted: false, enabled: true }
-          });
+          metadataRow = await findLlmAgentByScope(dataSource, entityMap, LLM_AGENT_SCOPE_BLOG_METADATA);
           if (metadataRow) {
             const mo = llmAgentToChatAgentOptions(metadataRow);
             metadataLlmAgentChatOptions = {
@@ -13371,15 +14137,13 @@ function createCmsApiHandler(config) {
               max_tokens: mo.max_tokens
             };
             metadataLlmAgentResolution = {
-              slug: BLOG_METADATA_ENRICHER_LLM_AGENT_SLUG,
+              slug: metadataRow.slug,
               model: metadataRow.model?.trim() || null,
               temperature: metadataRow.temperature ?? null,
               maxTokens: metadataRow.maxTokens ?? null
             };
           }
-          socialRow = await agentRepo.findOne({
-            where: { slug: BLOG_SOCIAL_ENRICHER_LLM_AGENT_SLUG, deleted: false, enabled: true }
-          });
+          socialRow = await findLlmAgentByScope(dataSource, entityMap, LLM_AGENT_SCOPE_SOCIAL_MEDIA_POST);
           if (socialRow) {
             const so = llmAgentToChatAgentOptions(socialRow);
             socialLlmAgentChatOptions = {
@@ -13388,7 +14152,7 @@ function createCmsApiHandler(config) {
               max_tokens: so.max_tokens
             };
             socialLlmAgentResolution = {
-              slug: BLOG_SOCIAL_ENRICHER_LLM_AGENT_SLUG,
+              slug: socialRow.slug,
               model: socialRow.model?.trim() || null,
               temperature: socialRow.temperature ?? null,
               maxTokens: socialRow.maxTokens ?? null
@@ -13412,8 +14176,8 @@ function createCmsApiHandler(config) {
           const out = await svc.generateBlogMarkdownFromRss({
             llm,
             rssUrls,
-            systemInstruction,
-            validationRules,
+            systemInstruction: systemInstruction ?? blogCreationRow?.systemInstruction?.trim() ?? void 0,
+            validationRules: validationRules ?? blogCreationRow?.validationRules?.trim() ?? void 0,
             categoryNamesHint: categoryRows.map((c) => c.name),
             tagNamesHint: tagNames,
             llmAgentChatOptions,
@@ -13898,6 +14662,22 @@ function createCmsApiHandler(config) {
           return config.json({ error: message }, { status: 500 });
         }
       }
+      if (path2[0] === "track" && path2.length === 2 && m === "GET") {
+        const token = path2[1];
+        if (!token) return config.json({ error: "Token required" }, { status: 400 });
+        try {
+          const orderRepo = dataSource.getRepository(entityMap.orders);
+          const order = await orderRepo.findOne({
+            where: { qrToken: token, deleted: false },
+            relations: ["contact", "items", "items.product"]
+          });
+          if (!order) return config.json({ error: "Order not found" }, { status: 404 });
+          return config.json(order);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return config.json({ error: message }, { status: 500 });
+        }
+      }
       if (path2.length === 0) return config.json({ error: "Not found" }, { status: 404 });
       const resource = resolveResource(path2[0]);
       if (!crudResources.includes(resource)) {
@@ -15099,8 +15879,8 @@ function createStorefrontApiHandler(config) {
           let emailVerificationSent = false;
           if (requireEmailVerification && getCms) {
             try {
-              const crypto2 = await import("crypto");
-              const rawToken = crypto2.randomBytes(32).toString("hex");
+              const crypto3 = await import("crypto");
+              const rawToken = crypto3.randomBytes(32).toString("hex");
               const expiresAt = new Date(Date.now() + SIGNUP_VERIFY_EXPIRY_HOURS * 60 * 60 * 1e3);
               await tokenRepo().save(
                 tokenRepo().create({ email, token: rawToken, expiresAt })