Implementou guardrails do CRM

X-Lovable-Edit-ID: edt-64a10f98-8aa0-4bc2-aa0d-40663332a2ac
Co-authored-by: criptogus <128640021+criptogus@users.noreply.github.com>

Author: lovable-dev[bot]

src/components/crm/EffectivenessPanel.tsx

@@ -59,13 +59,14 @@ export function EffectivenessPanel() {
       toast.success(
         r.job === "score"
           ? `Scored ${r.checked} messages · ${r.converted} converted`
-          : `Tuner: ${r.paused} paused, ${r.drafted} drafted`,
+          : `Tuner: ${r.paused} paused, ${r.activated} published, ${r.blocked} blocked by guardrails`,
       );
       q.refetch();
     },
     onError: (e: any) => toast.error(e?.message ?? "Job failed"),
   });
 
+
   const data = q.data;
   const maxHour = Math.max(1, ...(data?.hours ?? []).map((h) => h.sent));
 
@@ -74,16 +75,19 @@ export function EffectivenessPanel() {
       <Card>
         <CardHeader className="flex flex-row flex-wrap items-center justify-between gap-3 pb-3">
           <div>
-            <CardTitle className="text-base">Learning loop</CardTitle>
+            <CardTitle className="text-base">Autonomous learning loop</CardTitle>
             <p className="mt-1 text-xs text-muted-foreground">
-              Picks the copy variant and the trigger with the best measured outcome, and only changes
-              anything after {data?.min_samples ?? 20} sends per variant. Cadence caps never change.
+              Runs without approvals: it picks the copy variant, the trigger and the send hour with the
+              best measured outcome, and publishes its own replacement copy once the guardrails below
+              pass. It only changes anything after {data?.min_samples ?? 20} sends per variant, and
+              cadence caps never change.
             </p>
           </div>
           <div className="flex flex-wrap gap-2">
             <Badge variant={data?.learning_enabled ? "default" : "secondary"}>
-              {data?.learning_enabled ? "Learning on" : "Learning paused"}
+              {data?.learning_enabled ? "Autonomous" : "Learning paused"}
             </Badge>
+
             <Button
               size="sm"
               variant="outline"
@@ -262,14 +266,39 @@ export function EffectivenessPanel() {
 
       <Card>
         <CardHeader className="pb-3">
-          <CardTitle className="text-base">Drafted variants waiting for approval</CardTitle>
+          <CardTitle className="text-base">Guardrails</CardTitle>
+          <p className="mt-1 text-xs text-muted-foreground">
+            The hard limits the CRM can never cross on its own. Anything that breaks one of these is
+            quarantined instead of being sent.
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ul className="grid gap-2 sm:grid-cols-2">
+            {(data?.guardrails ?? []).map((g, i) => (
+              <li key={i} className="flex items-start gap-2 rounded border p-2 text-sm">
+                <Badge variant={g.allowed ? "default" : "secondary"} className="mt-0.5 shrink-0">
+                  {g.allowed ? "Can" : "Cannot"}
+                </Badge>
+                <span className={g.allowed ? "" : "text-muted-foreground"}>{g.rule}</span>
+              </li>
+            ))}
+          </ul>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="text-base">Quarantined copy</CardTitle>
           <p className="mt-1 text-xs text-muted-foreground">
-            Written by AI when a framing loses. Nothing is sent before you approve it.
+            Self-written variants that failed a guardrail. They are never sent — publishing one is a
+            manual override.
           </p>
         </CardHeader>
         <CardContent>
           {(data?.pending ?? []).length === 0 ? (
-            <p className="text-sm text-muted-foreground">No drafts pending.</p>
+            <p className="text-sm text-muted-foreground">
+              Nothing quarantined — every self-written variant passed the guardrails.
+            </p>
           ) : (
             <ul className="space-y-3">
               {(data?.pending ?? []).map((p) => (
@@ -281,32 +310,35 @@ export function EffectivenessPanel() {
                     <div className="flex gap-2">
                       <Button
                         size="sm"
+                        variant="outline"
                         disabled={reviewMutation.isPending}
                         onClick={() => reviewMutation.mutate({ id: p.id, decision: "approve" })}
                       >
-                        Approve
+                        Publish anyway
                       </Button>
                       <Button
                         size="sm"
                         variant="outline"
                         disabled={reviewMutation.isPending}
                         onClick={() => reviewMutation.mutate({ id: p.id, decision: "reject" })}
                       >
-                        Reject
+                        Discard
                       </Button>
                     </div>
                   </div>
                   <div className="mt-2 space-y-1">
                     <div className="font-semibold">{p.subject}</div>
                     <div>{p.heading}</div>
                     <p className="text-muted-foreground">{p.intro}</p>
+                    {p.notes ? <p className="text-xs text-destructive">{p.notes}</p> : null}
                   </div>
                 </li>
               ))}
             </ul>
           )}
         </CardContent>
       </Card>
+
     </div>
   );
 }

src/lib/crm/crm.functions.ts

@@ -405,8 +405,10 @@ export type CrmEffectiveness = {
     subject: string | null;
     heading: string | null;
     intro: string | null;
+    notes: string | null;
     created_at: string;
   }>;
+  guardrails: Array<{ allowed: boolean; rule: string }>;
   changelog: Array<{
     action: string;
     trigger: string | null;
@@ -416,10 +418,13 @@ export type CrmEffectiveness = {
   }>;
 };
 
+
 export const getCrmEffectiveness = createServerFn({ method: "POST" })
   .middleware([requireAdmin])
   .handler(async (): Promise<CrmEffectiveness> => {
     const { loadLearningState } = await import("@/lib/crm/learning.server");
+    const { AUTONOMY_RULES } = await import("@/lib/crm/guardrails");
+
     const { OUTCOMES, VARIANTS, armKey, estimatedRate, EMPTY_ARM } = await import(
       "@/lib/crm/learning"
     );
@@ -491,11 +496,14 @@ export const getCrmEffectiveness = createServerFn({ method: "POST" })
 
     const { data: pending } = await admin
       .from("crm_copy_variants")
-      .select("id, trigger, variant, label, subject_override, heading_override, intro_override, created_at")
-      .eq("status", "pending")
+      .select(
+        "id, trigger, variant, label, subject_override, heading_override, intro_override, notes, created_at",
+      )
+      .in("status", ["pending", "quarantined"])
       .order("created_at", { ascending: false })
       .limit(20);
 
+
     const { data: changelog } = await admin
       .from("crm_tuning_log")
       .select("action, trigger, variant, reason, created_at")
@@ -518,8 +526,11 @@ export const getCrmEffectiveness = createServerFn({ method: "POST" })
         subject: p.subject_override,
         heading: p.heading_override,
         intro: p.intro_override,
+        notes: p.notes ?? null,
         created_at: p.created_at,
       })),
+      guardrails: AUTONOMY_RULES,
+
       changelog: ((changelog ?? []) as any[]).map((c) => ({
         action: c.action,
         trigger: c.trigger,
@@ -585,5 +596,13 @@ export const runCrmLearningNow = createServerFn({ method: "POST" })
       return { job: "score" as const, ...r };
     }
     const r = await runTuner({ dryRun: data.dryRun });
-    return { job: "tune" as const, paused: r.paused.length, drafted: r.drafted.length, leaders: r.leaders };
+    return {
+      job: "tune" as const,
+      paused: r.paused.length,
+      drafted: r.drafted.length,
+      activated: r.activated.length,
+      blocked: r.blocked.length,
+      leaders: r.leaders,
+    };
+
   });

src/lib/crm/guardrails.ts

@@ -0,0 +1,111 @@
+/**
+ * CRM autonomy guardrails.
+ *
+ * The CRM runs without human approval. These are the hard limits it may never
+ * cross, plus the deterministic checks every self-written copy variant has to
+ * pass before it can go live. Anything that fails is quarantined and logged
+ * instead of being sent.
+ */
+
+export const GUARDRAILS = {
+  /** Cadence limits — the learning loop can never widen these. */
+  maxEmailsPer7Days: 2,
+  minHoursBetweenEmails: 48,
+  /** Copy shape limits. */
+  maxSubjectChars: 70,
+  maxHeadingChars: 60,
+  maxIntroChars: 200,
+  /** How much the loop may change on its own in a single run. */
+  maxAutoPausesPerRun: 3,
+  maxAutoActivationsPerRun: 2,
+  /** A trigger always keeps at least one and at most this many live variants. */
+  minActiveVariantsPerTrigger: 1,
+  maxActiveVariantsPerTrigger: 4,
+  /** No self-written variant goes live for a trigger with too little evidence. */
+  minSentBeforeAutoActivation: 20,
+} as const;
+
+/** Plain-language list of what the CRM may and may not do on its own. */
+export const AUTONOMY_RULES: Array<{ allowed: boolean; rule: string }> = [
+  { allowed: true, rule: "Pick the copy variant and the send hour with the best measured outcome." },
+  { allowed: true, rule: "Pause a variant once it is statistically behind the leader." },
+  { allowed: true, rule: "Write a replacement variant and publish it when it passes every copy check." },
+  { allowed: true, rule: "Rank triggers by measured business value and back off for unengaged customers." },
+  { allowed: false, rule: "Send more than 2 emails per customer per 7 days, or closer than 48 hours apart." },
+  { allowed: false, rule: "Email a suppressed, unsubscribed or bounced address." },
+  { allowed: false, rule: "Publish copy with invented metrics, guarantees, urgency pressure or discounts." },
+  { allowed: false, rule: "Publish copy in a language other than English, or with emojis." },
+  { allowed: false, rule: "Leave a trigger without a working variant, or run more than 4 live variants." },
+  { allowed: false, rule: "Change cadence caps, suppression rules or the unsubscribe footer." },
+];
+
+/** Claims and pressure tactics the CRM is not allowed to make on its own. */
+const BANNED_PATTERNS: Array<{ re: RegExp; reason: string }> = [
+  { re: /\b(guarantee[ds]?|guaranteed results|risk[- ]free)\b/i, reason: "promises a guaranteed result" },
+  { re: /\b(\d{2,3}\s?%\s?(more|less|faster|cheaper|increase|boost))/i, reason: "invents a performance metric" },
+  { re: /\b(\d+x)\s+(faster|better|more|cheaper)\b/i, reason: "invents a multiplier claim" },
+  { re: /\b(act now|last chance|final warning|hurry|expires? (today|tonight)|only \d+ (spots|hours) left)\b/i, reason: "uses urgency pressure" },
+  { re: /\b(free money|no strings|cash back|\d+\s?% off|discount code|coupon)\b/i, reason: "offers pricing terms the CRM cannot authorise" },
+  { re: /\b(refund|chargeback|invoice|credit card|password|api key|token)\b/i, reason: "touches billing or credential topics" },
+  { re: /\b(you must|you have to|failure to (act|respond)|legal action)\b/i, reason: "uses coercive language" },
+  { re: /[\u{1F300}-\u{1FAFF}\u{2600}-\u{27BF}]/u, reason: "contains emojis" },
+  { re: /\b(garantia|clique aqui|voc[êe]|gr[áa]tis|obrigado|aqui est[áa])\b/i, reason: "is not written in English" },
+  { re: /\{\{|\}\}|\[insert|TODO|lorem ipsum/i, reason: "contains unfilled placeholders" },
+];
+
+export type CopyCandidate = {
+  label: string;
+  subject: string;
+  heading: string;
+  intro: string;
+};
+
+export type GuardrailVerdict = { ok: boolean; violations: string[] };
+
+/** Deterministic gate for self-written copy. No model in the loop. */
+export function checkCopy(candidate: CopyCandidate): GuardrailVerdict {
+  const violations: string[] = [];
+  const { label, subject, heading, intro } = candidate;
+
+  if (!label.trim() || !subject.trim() || !heading.trim() || !intro.trim())
+    violations.push("is missing a label, subject, heading or intro");
+  if (subject.length > GUARDRAILS.maxSubjectChars)
+    violations.push(`subject is longer than ${GUARDRAILS.maxSubjectChars} characters`);
+  if (heading.length > GUARDRAILS.maxHeadingChars)
+    violations.push(`heading is longer than ${GUARDRAILS.maxHeadingChars} characters`);
+  if (intro.length > GUARDRAILS.maxIntroChars)
+    violations.push(`intro is longer than ${GUARDRAILS.maxIntroChars} characters`);
+  if (subject === subject.toUpperCase() && subject.replace(/[^A-Z]/g, "").length > 6)
+    violations.push("subject shouts in all caps");
+  if ((subject.match(/!/g) ?? []).length > 0) violations.push("subject uses exclamation marks");
+
+  const blob = `${label}\n${subject}\n${heading}\n${intro}`;
+  for (const { re, reason } of BANNED_PATTERNS) if (re.test(blob)) violations.push(reason);
+
+  // Non-ASCII beyond normal punctuation is a strong signal of another language.
+  if (/[À-ÿ]/.test(blob)) violations.push("contains non-English characters");
+
+  return { ok: violations.length === 0, violations };
+}
+
+/** Can this trigger accept one more live variant right now? */
+export function canActivate(activeCount: number, leaderSent: number): GuardrailVerdict {
+  const violations: string[] = [];
+  if (activeCount >= GUARDRAILS.maxActiveVariantsPerTrigger)
+    violations.push(`trigger already runs ${GUARDRAILS.maxActiveVariantsPerTrigger} live variants`);
+  if (leaderSent < GUARDRAILS.minSentBeforeAutoActivation)
+    violations.push(
+      `only ${leaderSent} sends measured, ${GUARDRAILS.minSentBeforeAutoActivation} required before publishing new copy`,
+    );
+  return { ok: violations.length === 0, violations };
+}
+
+/** Can this variant be paused without leaving the trigger empty or over-churning? */
+export function canPause(activeCount: number, pausesThisRun: number): GuardrailVerdict {
+  const violations: string[] = [];
+  if (activeCount - 1 < GUARDRAILS.minActiveVariantsPerTrigger)
+    violations.push("pausing it would leave the trigger without a working variant");
+  if (pausesThisRun >= GUARDRAILS.maxAutoPausesPerRun)
+    violations.push(`already paused ${GUARDRAILS.maxAutoPausesPerRun} variants in this run`);
+  return { ok: violations.length === 0, violations };
+}