diff --git a/.gitignore b/.gitignore
index 2a22ae6..f2ab9d2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,4 @@ yarn-error.log*
 *.tsbuildinfo
 next-env.d.ts
 supabase/.temp
+.env*
diff --git a/app/(dashboard)/dashboard/inbox/inbox-view.tsx b/app/(dashboard)/dashboard/inbox/inbox-view.tsx
index fca93af..5bc9c4f 100644
--- a/app/(dashboard)/dashboard/inbox/inbox-view.tsx
+++ b/app/(dashboard)/dashboard/inbox/inbox-view.tsx
@@ -6,7 +6,6 @@ import { MessageSquare, RefreshCw, User } from "lucide-react";
 import { ConversationList } from "@/components/inbox/conversation-list";
 import { MessageThread } from "@/components/inbox/message-thread";
 import { ContactPanel } from "@/components/inbox/contact-panel";
-import { createClient } from "@/lib/supabase/client";
 import { cn } from "@/lib/utils";
 import type { Database } from "@/lib/types/database";
 
@@ -82,13 +81,15 @@ export function InboxView({
         setLoadingMessages(false);
       }
 
-      // Mark as read
+      // Mark as read via API (not client-side Supabase)
       if (selected!.unread_count > 0) {
-        const supabase = createClient();
-        await supabase
-          .from("conversations")
-          .update({ unread_count: 0 })
-          .eq("id", selected!.id);
+        try {
+          await fetch(`/api/v1/conversations/${selected!.id}/read`, {
+            method: "POST",
+          });
+        } catch (err) {
+          console.error("Failed to mark conversation as read:", err);
+        }
       }
     }
 
diff --git a/app/api/v1/conversations/[conversationId]/read/route.ts b/app/api/v1/conversations/[conversationId]/read/route.ts
new file mode 100644
index 0000000..4d46809
--- /dev/null
+++ b/app/api/v1/conversations/[conversationId]/read/route.ts
@@ -0,0 +1,46 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createClient } from "@/lib/supabase/server";
+
+/**
+ * POST /api/v1/conversations/[conversationId]/read
+ *
+ * Marks a conversation as read (sets unread_count to 0).
+ * Replaces the old client-side Supabase call that exposed the service
+ * role client to the browser.
+ */
+export async function POST(
+  _request: NextRequest,
+  { params }: { params: Promise<{ conversationId: string }> }
+) {
+  const supabase = await createClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  const { conversationId } = await params;
+  if (!conversationId) {
+    return NextResponse.json(
+      { error: "conversationId required" },
+      { status: 400 }
+    );
+  }
+
+  const { error } = await supabase
+    .from("conversations")
+    .update({ unread_count: 0 })
+    .eq("id", conversationId);
+
+  if (error) {
+    console.error("Failed to mark conversation as read:", error);
+    return NextResponse.json(
+      { error: "Failed to mark as read" },
+      { status: 500 }
+    );
+  }
+
+  return NextResponse.json({ success: true });
+}
diff --git a/app/api/v1/messages/route.ts b/app/api/v1/messages/route.ts
index 2f98e27..c6c9029 100644
--- a/app/api/v1/messages/route.ts
+++ b/app/api/v1/messages/route.ts
@@ -60,11 +60,13 @@ export async function GET(request: NextRequest) {
       (res.data as { data?: unknown[] })?.data ??
       [];
 
-    // Map Zernio messages to the shape the inbox UI expects
-    const messages = zernioMessages.map((m: any) => ({
+    // Map Zernio messages to the shape the inbox UI expects.
+    // Accept both "outgoing" (Zernio's actual enum value) and "outbound"
+    // (legacy spelling) so our own replies are correctly shown on our side.
+    const zernioMapped = zernioMessages.map((m: any) => ({
       id: m.id,
       conversation_id: conversationId,
-      direction: m.direction === "outbound" ? "outbound" : "inbound",
+      direction: m.direction === "outgoing" || m.direction === "outbound" ? "outbound" : "inbound",
       text: m.text ?? m.message ?? null,
       attachments: m.attachments?.length ? m.attachments : null,
       quick_reply_payload: null,
@@ -78,7 +80,79 @@ export async function GET(request: NextRequest) {
       created_at: m.sentAt ?? m.createdAt ?? new Date().toISOString(),
     }));
 
-    return NextResponse.json(messages);
+    // Merge with locally stored messages. Zernio is the source of truth but
+    // its API can lag or miss messages (especially outbound sends). The local
+    // table has messages the webhook stored (inbound) and flow engine stored
+    // (outbound). Dedup on platform_message_id so messages that appear in both
+    // don't render twice.
+    //
+    // IMPORTANT: The flow engine stores outbound DMs WITHOUT platform_message_id
+    // (it's NULL), while Zernio returns the same message with its own ID. So
+    // deduping on ID alone would show every DM twice. We additionally dedup on
+    // (direction, normalized_text, ±60s time window) to catch these.
+    const { data: localMessages } = await supabase
+      .from("messages")
+      .select("*")
+      .eq("conversation_id", conversationId)
+      .order("created_at", { ascending: true });
+
+    const seenIds = new Set<string>();
+    // Track outbound messages by content+time for content-based dedup
+    const outboundSignatures: Array<{ text: string; time: number }> = [];
+    const merged: Array<Record<string, unknown>> = [];
+
+    const normalize = (s: string | null): string =>
+      (s ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+
+    for (const m of zernioMapped) {
+      const key = (m.platform_message_id || m.id) as string | null;
+      if (key && !seenIds.has(key)) {
+        seenIds.add(key);
+        merged.push(m as unknown as Record<string, unknown>);
+        // Record outbound signatures for content-based dedup
+        if (m.direction === "outbound" && m.text) {
+          outboundSignatures.push({
+            text: normalize(m.text as string),
+            time: new Date(m.created_at as string).getTime(),
+          });
+        }
+      }
+    }
+
+    if (localMessages) {
+      for (const m of localMessages) {
+        // First try ID-based dedup
+        const key = m.platform_message_id || m.id;
+        if (key && seenIds.has(key)) continue;
+
+        // For outbound messages without platform_message_id, try content-based dedup.
+        // If a Zernio message has the same text within ±60 seconds, it's the same DM.
+        if (m.direction === "outbound" && !m.platform_message_id && m.text) {
+          const normText = normalize(m.text);
+          const localTime = new Date(m.created_at).getTime();
+          const isDupe = outboundSignatures.some(
+            (sig) =>
+              sig.text === normText &&
+              Math.abs(sig.time - localTime) < 60_000, // 60-second window
+          );
+          if (isDupe) continue; // Skip — Zernio already has this message
+        }
+
+        if (key) {
+          seenIds.add(key);
+        }
+        merged.push(m as unknown as Record<string, unknown>);
+      }
+    }
+
+    // Sort merged messages by created_at for consistent chronological display
+    merged.sort((a, b) => {
+      const aTime = new Date(a.created_at as string).getTime();
+      const bTime = new Date(b.created_at as string).getTime();
+      return aTime - bTime;
+    });
+
+    return NextResponse.json(merged);
   } catch (error) {
     console.error("Failed to fetch messages from Zernio API:", error);
     return NextResponse.json(
diff --git a/app/api/webhooks/late/route.ts b/app/api/webhooks/late/route.ts
index df73226..dd9383c 100644
--- a/app/api/webhooks/late/route.ts
+++ b/app/api/webhooks/late/route.ts
@@ -6,6 +6,7 @@ import { matchTrigger } from "@/lib/flow-engine/trigger-matcher";
 import { resolveWebhookSecret, verifyWebhookSignature } from "@/lib/zernio-webhook";
 import { upsertContactForSender } from "@/lib/inbox-sync";
 import { processComment } from "@/lib/comment-processor";
+import { createZernioClient } from "@/lib/zernio-client";
 import type { Database } from "@/lib/types/database";
 import { messagePreview } from "@/lib/message-preview";
 
@@ -137,8 +138,10 @@ async function handleWebhook(request: NextRequest) {
 
   const { message: msg, account } = payload;
 
-  // Ignore outbound messages (sent by the bot itself) to prevent loops
-  if (msg.direction === "outbound") {
+  // Ignore outbound messages (sent by the bot itself) to prevent loops.
+  // Accept both "outgoing" (Zernio's actual enum value) and the legacy
+  // "outbound" spelling for resilience.
+  if (msg.direction === "outgoing" || msg.direction === "outbound") {
     return NextResponse.json({ ok: true, skipped: true });
   }
 
@@ -159,6 +162,8 @@ async function handleWebhook(request: NextRequest) {
   // Prevent loops: if the sender is another connected account in this
   // workspace, skip. This happens when both sides of a DM conversation
   // are connected (e.g. during testing).
+  // NOTE: Facebook page DMs can arrive with sender.username=null (same bug
+  // as comments), so we also check by sender.id against all workspace channels.
   if (msg.sender.username) {
     const { data: senderChannel } = await supabase
       .from("channels")
@@ -172,6 +177,22 @@ async function handleWebhook(request: NextRequest) {
       return NextResponse.json({ ok: true, skipped: true, reason: "sender_is_own_account" });
     }
   }
+  // Defense-in-depth: also check by late_account_id in case username is null
+  // (Facebook page accounts). Any sender whose account ID matches a connected
+  // channel in this workspace is our own bot.
+  if (msg.sender.id) {
+    const { data: senderChannelById } = await supabase
+      .from("channels")
+      .select("id")
+      .eq("workspace_id", channel.workspace_id)
+      .eq("late_account_id", msg.sender.id)
+      .eq("is_active", true)
+      .maybeSingle();
+
+    if (senderChannelById) {
+      return NextResponse.json({ ok: true, skipped: true, reason: "sender_is_own_account" });
+    }
+  }
 
   // Verify HMAC-SHA256 signature against the workspace-level secret
   // (falls back to the legacy per-channel secret during transition).
@@ -231,24 +252,47 @@ async function processMessageEvent(
 
   const preview = messagePreview(msg.text);
 
-  const { data: conversation } = await supabase
+  // Two-step upsert to avoid overwriting late_conversation_id on existing
+  // conversations. The webhook receives Zernio's conversation ID (conv.id),
+  // but for comment-triggered flows we set late_conversation_id to the
+  // sender's PSID/IGA ID via sendFirstMessageAsPrivateReply. If we blindly
+  // overwrite it here on every incoming message, we'd break the inbox link.
+  // Step 1: try INSERT (only fires for new contacts).
+  const { data: newConversation } = await supabase
     .from("conversations")
-    .upsert(
-      {
-        workspace_id: channel.workspace_id,
-        channel_id: channel.id,
-        contact_id: contactId,
-        platform: channel.platform,
-        late_conversation_id: conv.id,
+    .insert({
+      workspace_id: channel.workspace_id,
+      channel_id: channel.id,
+      contact_id: contactId,
+      platform: channel.platform,
+      late_conversation_id: conv.id,
+      status: "open",
+      last_message_at: new Date().toISOString(),
+      last_message_preview: preview,
+      unread_count: 1,
+    })
+    .select("id, is_automation_paused")
+    .single();
+
+  let conversation = newConversation;
+
+  // Step 2: if INSERT failed (contact already exists), UPDATE without
+  // touching late_conversation_id.
+  if (!conversation) {
+    const { data: existingConversation } = await supabase
+      .from("conversations")
+      .update({
         status: "open",
         last_message_at: new Date().toISOString(),
         last_message_preview: preview,
-        unread_count: 1,
-      },
-      { onConflict: "channel_id,contact_id" }
-    )
-    .select("id, is_automation_paused")
-    .single();
+      })
+      .eq("channel_id", channel.id)
+      .eq("contact_id", contactId)
+      .select("id, is_automation_paused")
+      .single();
+
+    conversation = existingConversation;
+  }
 
   if (!conversation) {
     console.error("Failed to upsert conversation for webhook message");
@@ -264,7 +308,27 @@ async function processMessageEvent(
       .then(() => {});
   }
 
-  // Messages are stored by Zernio (source of truth) — no local insert needed.
+  // Store the incoming DM locally so the inbox has a reliable history even
+  // when Zernio's API returns stale or incomplete data. Use platformMessageId
+  // (not msg.id which is Zernio's internal id) so it matches what the messages
+  // route returns and dedup works when both sources are merged.
+  const { data: existingMsg } = await supabase
+    .from("messages")
+    .select("id")
+    .eq("conversation_id", conversation.id)
+    .eq("platform_message_id", msg.platformMessageId || msg.id)
+    .maybeSingle();
+
+  if (!existingMsg) {
+    await supabase.from("messages").insert({
+      conversation_id: conversation.id,
+      direction: "inbound",
+      text: msg.text,
+      attachments: msg.attachments?.length ? msg.attachments : null,
+      platform_message_id: msg.platformMessageId || msg.id,
+      status: "sent",
+    });
+  }
 
   // ── Flow engine ───────────────────────────────────────────────────────────
 
@@ -281,12 +345,22 @@ async function processMessageEvent(
       },
     };
 
-    const handled = await handleGlobalKeywords(
+    // Look up workspace API key for keyword confirmation DMs
+    const { data: kwWorkspace } = await supabase
+      .from("workspaces")
+      .select("late_api_key_encrypted")
+      .eq("id", channel.workspace_id)
+      .single();
+
+    const handled = await handleGlobalKeywords({
       supabase,
-      channel.workspace_id,
+      workspaceId: channel.workspace_id,
+      workspaceApiKey: kwWorkspace?.late_api_key_encrypted ?? null,
+      lateConversationId: conv.id,
+      lateAccountId: account.id,
       contactId,
-      msg.text || undefined
-    );
+      text: msg.text || undefined,
+    });
 
     if (!handled) {
       const trigger = await matchTrigger(supabase, {
@@ -310,7 +384,30 @@ async function processMessageEvent(
             lateAccountId: account.id,
           });
         } catch (err) {
-          console.error("Flow execution error:", err);
+          const errMsg = err instanceof Error ? err.message : String(err);
+
+          // Distinguish 24h-window failures from other errors. Meta only
+          // allows businesses to message within 24h of the contact's last
+          // message; sending after the window fails with a specific error.
+          // Logging it distinctly surfaces this operational gap instead of
+          // collapsing it into a generic message_failed event.
+          const is24hWindowError = /24.*hour|window|outside.*allowed/i.test(errMsg);
+
+          console.error("Flow execution error:", errMsg);
+
+          await supabase.from("analytics_events").insert({
+            workspace_id: channel.workspace_id,
+            contact_id: contactId,
+            flow_id: trigger.flow_id,
+            event_type: is24hWindowError
+              ? "message_failed_24h_window"
+              : "message_failed",
+            metadata: {
+              error: errMsg,
+              triggerId: trigger.id,
+              ...(is24hWindowError ? { reason: "24h_messaging_window" } : {}),
+            },
+          });
         }
       }
     }
@@ -340,10 +437,24 @@ async function handleCommentWebhook(
 
   // Prevent loops: our own comments (e.g. the configured public reply) also
   // arrive as comment.received and must never re-trigger a flow.
-  if (
-    payload.comment.author?.username &&
-    payload.comment.author.username === channel.username
-  ) {
+  // Facebook page comments arrive with username=null (Meta strips author
+  // identity from page-owned comments by design — Graph API v26.0 doesn't
+  // even list a `from` field in the Comment reference).
+  // We check THREE identifiers for defense-in-depth:
+  //   1. username (works for Instagram, fails for Facebook)
+  //   2. display_name (works for both, but fragile — string match)
+  //   3. platform_page_id (works for Facebook — author.id = FB Page ID)
+  // NOTE: payload.account.id is the Zernio internal account ID, NOT the FB
+  // Page ID. author.id is the FB Page ID. They are DIFFERENT ID SYSTEMS and
+  // must never be compared to each other.
+  const authorName = payload.comment.author?.name?.trim();
+  const authorUsername = payload.comment.author?.username?.trim();
+  const authorId = payload.comment.author?.id;
+  const isOwnComment =
+    (authorUsername && authorUsername === channel.username) ||
+    (authorName && channel.display_name && authorName === channel.display_name) ||
+    (authorId && channel.platform_page_id && authorId === channel.platform_page_id);
+  if (isOwnComment) {
     return NextResponse.json({ ok: true, skipped: true, reason: "own_comment" });
   }
 
@@ -384,12 +495,39 @@ async function handleCommentWebhook(
 
 // ── Global keywords ─────────────────────────────────────────────────────────
 
-async function handleGlobalKeywords(
-  supabase: Awaited<ReturnType<typeof createServiceClient>>,
-  workspaceId: string,
-  contactId: string,
-  text: string | undefined
-): Promise<boolean> {
+/**
+ * Context object for keyword confirmation DMs. Passing a single object avoids
+ * the "too many positional parameters" problem where a caller silently passes
+ * arguments in the wrong order.
+ */
+interface KeywordConfirmationParams {
+  supabase: Awaited<ReturnType<typeof createServiceClient>>;
+  workspaceId: string;
+  workspaceApiKey: string | null;
+  lateConversationId: string | null;
+  lateAccountId: string | null;
+  contactId: string;
+  text: string | undefined;
+}
+
+/**
+ * Checks the incoming text against the workspace's global keywords. When a
+ * STOP/START keyword matches, updates the contact's subscription and sends a
+ * confirmation DM so the contact knows their opt-in/opt-out was received.
+ *
+ * The confirmation DM is only sent when we have a late_conversation_id (i.e.
+ * a DM context). Comment-triggered flows do not have one at keyword-check
+ * time, so the confirmation is a no-op there — the early return below guards it.
+ */
+async function handleGlobalKeywords({
+  supabase,
+  workspaceId,
+  workspaceApiKey,
+  lateConversationId,
+  lateAccountId,
+  contactId,
+  text,
+}: KeywordConfirmationParams): Promise<boolean> {
   if (!text) return false;
 
   const { data: workspace } = await supabase
@@ -415,6 +553,17 @@ async function handleGlobalKeywords(
           .from("contacts")
           .update({ is_subscribed: false })
           .eq("id", contactId);
+
+        // Send confirmation DM. No-ops when there is no DM conversation yet
+        // (e.g. keyword sent on a comment-triggered flow) or when outside the
+        // 24h messaging window.
+        await sendKeywordConfirmation({
+          workspaceApiKey,
+          lateConversationId,
+          lateAccountId,
+          message: "You've been unsubscribed from our messages. Text START to resubscribe anytime.",
+        });
+
         return true;
       }
       if (kw.action === "subscribe") {
@@ -422,6 +571,14 @@ async function handleGlobalKeywords(
           .from("contacts")
           .update({ is_subscribed: true })
           .eq("id", contactId);
+
+        await sendKeywordConfirmation({
+          workspaceApiKey,
+          lateConversationId,
+          lateAccountId,
+          message: "You're subscribed! Reply STOP anytime to opt out.",
+        });
+
         return true;
       }
       return false;
@@ -430,3 +587,34 @@ async function handleGlobalKeywords(
 
   return false;
 }
+
+/**
+ * Sends a single confirmation DM. Silently no-ops when the prerequisites for
+ * sending (API key, conversation ID, account ID) are missing — this happens
+ * for comment-triggered flows where no DM conversation exists yet.
+ */
+async function sendKeywordConfirmation({
+  workspaceApiKey,
+  lateConversationId,
+  lateAccountId,
+  message,
+}: {
+  workspaceApiKey: string | null;
+  lateConversationId: string | null;
+  lateAccountId: string | null;
+  message: string;
+}): Promise<void> {
+  if (!workspaceApiKey || !lateConversationId || !lateAccountId) return;
+
+  try {
+    const zernio = createZernioClient(workspaceApiKey);
+    await zernio.messages.sendInboxMessage({
+      path: { conversationId: lateConversationId },
+      body: { accountId: lateAccountId, message },
+    });
+  } catch (err) {
+    // Most likely cause is the 24h messaging window having elapsed; log and
+    // move on rather than surfacing this as a flow failure.
+    console.error("Failed to send keyword confirmation DM:", err);
+  }
+}
diff --git a/backup_system_prompt.txt b/backup_system_prompt.txt
new file mode 100644
index 0000000..1ef403f
--- /dev/null
+++ b/backup_system_prompt.txt
@@ -0,0 +1,92 @@
+You are Pallavi, the educator and creator behind Khilta. You have a B.Ed and NTT certification with 10+ years teaching children ages 2-8.
+
+You personally designed and created every worksheet and activity at Khilta. This is YOUR work.
+
+YOUR PERSONALITY:
+- Warm, encouraging, genuine — like a friendly teacher
+- Keep replies SHORT (2-3 sentences max)
+- Use emojis naturally but don't overdo it (1-2 per message)
+- You ARE Pallavi. Never say "I'm part of the team" — say "I'm Pallavi" or "I"
+
+YOUR GOAL: Help parents and teachers discover Khilta's worksheets and guide them to get the full collection. Every conversation should naturally move toward them experiencing the worksheets — starting with a free sample, then the full bundle.
+
+CRITICAL — LINKS IN DMs:
+Instagram and Facebook DMs make links clickable ONLY when you include the full URL with https://
+- ✅ CORRECT: "https://khilta.com/go"
+- ❌ WRONG: "khilta.com/go" (shows as plain text, NOT clickable)
+ALWAYS write full URLs with https:// prefix. Never write bare domain names.
+
+THE SAMPLE-TO-BUNDLE FUNNEL (your core strategy):
+When someone shows ANY interest, offer a free sample first:
+"I'd love for you to try some of our worksheets! Just comment 'FREE' on our Instagram posts and I'll send you a sample pack. 🌸"
+
+Once they've seen or asked about the sample, explain:
+"That's just a tiny glimpse — it's only about 2-5% of what we have! The full collection has 400+ worksheets across 28 categories covering almost every learning need. You can get it all at https://khilta.com/go 📚"
+
+WHAT KHILTA OFFERS:
+1. FREE sample worksheets → comment "FREE" on Instagram posts
+2. FOCUS & attention worksheets → comment "FOCUS"
+3. Full bundle: 400+ worksheets, 10,000+ pages, 28 categories, ages 2-8 → https://khilta.com/go
+4. 1-on-1 consultation with Pallavi → https://khilta.com/book
+
+NEVER mention specific prices. If they ask about cost, say: "You can check it all out at https://khilta.com/go! 😊"
+
+FAQ — COMMON QUESTIONS:
+
+Q: Is it a hardcopy or e-book?
+A: All digital (PDF) — instant download, print at home! Get the full collection at https://khilta.com/go 📄
+
+Q: Where can I get them? / How do I buy?
+A: Head to https://khilta.com/go for instant access to everything! You can also comment "FREE" on our posts to try a sample first. 🌸
+
+Q: What ages are these for?
+A: Ages 2-8! From toddlers tracing lines to early elementary kids with math, reading, and more. Try a free sample — comment "FREE" on our posts!
+
+Q: Where are you based?
+A: India 🇮🇳 But our worksheets are loved by parents and teachers worldwide!
+
+Q: Who created these? / Did you make them?
+A: Yes! I'm Pallavi — I personally designed every worksheet. B.Ed + NTT certified, 10+ years classroom experience. 🌸
+
+Q: Do you have worksheets for autism / SEN / special needs?
+A: Absolutely! Many of our activities are great for diverse learning needs, especially our FOCUS worksheets. Comment "FOCUS" on our posts for a free sample! The full collection at https://khilta.com/go covers so many different needs.
+
+Q: I'm a teacher, can I use these?
+A: Perfect! Many teachers use our worksheets in class. The full bundle at https://khilta.com/go has 400+ activities across 28 categories — great for classrooms!
+
+Q: What's in the bundle?
+A: 400+ worksheets across 28 categories — tracing, counting, coloring, mazes, matching, patterns, phonics, and MUCH more. Ages 2-8. That's 10,000+ pages of activities! Get it at https://khilta.com/go 📚
+
+Q: I already got the sample / I want more
+A: The sample is just 2-5% of what we offer! The full collection covers almost every learning need. Get everything at https://khilta.com/go 🌟
+
+CONVERSATION STRATEGY:
+- If interested → offer FREE sample first → then explain it's just 2-5% → point to https://khilta.com/go for full bundle
+- If they mention a specific need (autism, math, reading, etc.) → mention relevant worksheets → offer sample → full bundle covers much more
+- Don't ask too many questions — provide information and solutions
+- Every reply should gently move them toward trying a sample or visiting https://khilta.com/go
+- Don't keep asking "what age?" repeatedly — answer their question and guide forward
+
+WHEN YOU DON'T KNOW:
+- Never make up information about Khilta
+- If asked about refunds, GST, shipping, payment methods: "You can find all the details at https://khilta.com/go! 🌸"
+
+OFF-TOPIC:
+- Gently redirect: "I help with early learning activities! Comment 'FREE' on our posts to try some worksheets 😊"
+
+LANGUAGE:
+- Reply in the same language the person uses
+- Default to simple, friendly English
+
+CRITICAL — WHEN NOT TO REPLY (SKIP RULE):
+If you do NOT clearly understand what the person is saying, or you don't have a genuinely useful answer, respond with EXACTLY one word: SKIP
+
+This includes:
+- Messages with attachments you can't see (you'll see [Attachment: image] in the message)
+- Messages that are just a name, "thanks", or a greeting with no question
+- Messages where you're not confident you understand the meaning
+- Messages in a language you can't fully understand
+- Messages that are just business names, random text, or unclear
+
+Never guess. Never make up information. Never respond when confused.
+When in doubt, SKIP — silence is always better than a wrong reply.
\ No newline at end of file
diff --git a/components/flow-builder/panels/AiResponsePanel.tsx b/components/flow-builder/panels/AiResponsePanel.tsx
index 0386842..e6e9446 100644
--- a/components/flow-builder/panels/AiResponsePanel.tsx
+++ b/components/flow-builder/panels/AiResponsePanel.tsx
@@ -14,6 +14,8 @@ interface AiResponsePanelData {
   maxTokens?: number;
   contextMessages?: number;
   sendDirectly?: boolean;
+  maxRetries?: number;
+  fallbackMessage?: string;
   [key: string]: unknown;
 }
 
@@ -161,6 +163,47 @@ export function AiResponsePanel({ data: rawData, onChange }: AiResponsePanelProp
           yourself with a Send Message node.
         </p>
       </div>
+
+      {/* Resilience */}
+      <div className="space-y-3 rounded-lg border border-border bg-muted/30 p-3">
+        <h4 className="text-xs font-semibold text-foreground">Resilience</h4>
+
+        {/* Max Retries */}
+        <div>
+          <label className="mb-1 block text-[11px] font-medium text-muted-foreground">
+            Max Retries
+          </label>
+          <input
+            type="number"
+            value={data.maxRetries ?? 3}
+            onChange={(e) => onChange({ ...data, maxRetries: parseInt(e.target.value) || 0 })}
+            min={0}
+            max={10}
+            className="w-full rounded-lg border border-border bg-card px-3 py-2 text-sm text-foreground focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
+          />
+          <p className="mt-1 text-[11px] text-muted-foreground/60">
+            Retry attempts with exponential backoff on transient errors (rate
+            limits, timeouts). Set to 0 to disable.
+          </p>
+        </div>
+
+        {/* Fallback Message */}
+        <div>
+          <label className="mb-1 block text-[11px] font-medium text-muted-foreground">
+            Fallback Message
+          </label>
+          <textarea
+            value={data.fallbackMessage ?? ""}
+            onChange={(e) => onChange({ ...data, fallbackMessage: e.target.value })}
+            placeholder="I'm having trouble responding right now, but I'll get back to you shortly! 😊"
+            rows={2}
+            className="w-full resize-none rounded-lg border border-border bg-card px-3 py-2 text-sm text-foreground placeholder:text-muted-foreground/60 focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
+          />
+          <p className="mt-1 text-[11px] text-muted-foreground/60">
+            Sent to the contact when all retries fail, instead of ghosting them.
+          </p>
+        </div>
+      </div>
     </div>
   );
 }
diff --git a/components/inbox/message-thread.tsx b/components/inbox/message-thread.tsx
index fe330ca..7f09033 100644
--- a/components/inbox/message-thread.tsx
+++ b/components/inbox/message-thread.tsx
@@ -184,10 +184,50 @@ export function MessageThread({
               `/api/v1/messages?conversationId=${conversation.id}`
             );
             if (res.ok) {
-              const freshMessages = await res.json();
+              const freshMessages: Message[] = await res.json();
               setMessages((prev) => {
-                const optimistic = prev.filter((m) => m.id.startsWith("optimistic-"));
-                return [...freshMessages, ...optimistic];
+                // Dedup: when we send a message, the POST updates
+                // last_message_at which fires this realtime handler.
+                // Zernio often already has the sent message by then, so it
+                // appears in freshMessages. We must NOT also keep the local
+                // optimistic/confirmed copy — that's what causes duplicates.
+                // Match by platform_message_id when available, and fall back
+                // to (direction + text + time window) for optimistic messages
+                // that have null IDs.
+                const freshKeys = new Set(
+                  freshMessages
+                    .map((m) => m.platform_message_id || m.id)
+                    .filter(Boolean)
+                );
+                const freshTexts = new Set(
+                  freshMessages
+                    .filter((m) => m.direction === "outbound" && m.text)
+                    .map((m) => m.text)
+                );
+                const extra = prev.filter((m) => {
+                  // Only preserve local-only messages (optimistic or sent-)
+                  if (
+                    !m.id.startsWith("optimistic-") &&
+                    !m.id.startsWith("sent-")
+                  ) {
+                    return false;
+                  }
+                  // Drop if the same platform_message_id is in fresh data
+                  if (m.platform_message_id && freshKeys.has(m.platform_message_id)) {
+                    return false;
+                  }
+                  // Drop if same outbound text is in fresh data (handles
+                  // optimistic messages with null platform_message_id)
+                  if (
+                    m.direction === "outbound" &&
+                    m.text &&
+                    freshTexts.has(m.text)
+                  ) {
+                    return false;
+                  }
+                  return true;
+                });
+                return [...freshMessages, ...extra];
               });
             }
           } catch (err) {
diff --git a/lib/comment-processor.ts b/lib/comment-processor.ts
index 68515c0..aab9d79 100644
--- a/lib/comment-processor.ts
+++ b/lib/comment-processor.ts
@@ -2,6 +2,7 @@ import type { SupabaseClient } from "@supabase/supabase-js";
 import type { Database, Json } from "@/lib/types/database";
 import { executeFlow } from "@/lib/flow-engine/engine";
 import { createZernioClient } from "@/lib/zernio-client";
+import { generateText, createGateway } from "ai";
 
 type Channel = Database["public"]["Tables"]["channels"]["Row"];
 type Trigger = Database["public"]["Tables"]["triggers"]["Row"];
@@ -21,7 +22,195 @@ interface CommentKeywordConfig {
     matchType?: "exact" | "contains" | "startsWith";
   }>;
   postIds?: string[];
-  replyText?: string;
+  /** Public comment reply. Can be a single string or an array of variants —
+   * when it's an array, one variant is picked at random per comment so the
+   * comment section doesn't look like a bot army with identical replies.
+   *
+   * IMPORTANT: No reply variant should contain any trigger keyword — otherwise
+   * our own reply can trigger the automation again, creating an infinite loop.
+   */
+  replyText?: string | string[];
+}
+
+/**
+ * Picks one reply from a replyText config value. Supports both legacy single
+ * strings and new variant arrays. Returns null if replyText is missing/empty.
+ */
+function pickReplyText(replyText?: string | string[]): string | null {
+  if (!replyText) return null;
+  if (typeof replyText === "string") {
+    return replyText.trim() || null;
+  }
+  if (Array.isArray(replyText) && replyText.length > 0) {
+    // Pick a random variant
+    const variants = replyText.map((r) => r.trim()).filter(Boolean);
+    if (variants.length === 0) return null;
+    return variants[Math.floor(Math.random() * variants.length)];
+  }
+  return null;
+}
+
+/**
+ * Returns all known reply texts across all triggers (flattened from arrays).
+ * Used to detect if an incoming comment is actually OUR OWN bot reply —
+ * a defense-in-depth guard against infinite self-reply loops.
+ *
+ * The check is case-insensitive and matches on the first 40 chars of the
+ * comment text to handle truncation by the platform.
+ */
+function isLikelyOurOwnReply(
+  commentText: string,
+  allReplyTexts: string[],
+): boolean {
+  const lower = commentText.toLowerCase().trim().slice(0, 60);
+  if (!lower) return false;
+  return allReplyTexts.some(
+    (r) => r.toLowerCase().trim().slice(0, 60) === lower,
+  );
+}
+
+/**
+ * Pre-filter: determines whether an unmatched comment should be skipped
+ * WITHOUT calling the AI — saving tokens and preventing useless replies.
+ *
+ * Patterns from Zernio's official blog on Instagram comment moderation
+ * (https://zernio.com/blog/instagram-comment-moderation-api).
+ */
+function shouldSkipComment(text: string): boolean {
+  const lower = text.toLowerCase().trim();
+
+  // Too short to be a meaningful question
+  if (lower.length < 4) return true;
+
+  // Contains a URL — likely spam/promo, not a question about Khilta
+  if (/https?:\/\//i.test(text)) return true;
+
+  // Just tagging another user ("@username check this")
+  if (/^@\w+/.test(lower)) return true;
+
+  // Common spam phrases (Zernio detectSpam patterns)
+  if (/\b(dm me|check bio|click here|free money|winner|follow for follow|fff|l4l|c4c)\b/i.test(text)) return true;
+
+  // Pure gratitude/greetings with no question — no useful answer to give
+  if (/^(thanks|thank you|ty|tysm|nice|great|good|wow|awesome|amazing|beautiful|love this|congratulations|congrats|good job|well done|keep it up|god bless|blessed|happy|excited)\b/i.test(lower)) return true;
+
+  // Just a name (people tag friends in comments: "Anna Alejo", "Maria Santos")
+  if (/^[a-z]+ [a-z]+$/i.test(lower) && lower.split(/\s+/).length === 2) return true;
+
+  return false;
+}
+
+// ── AI comment reply system prompt ─────────────────────────────────────────
+// Separate from the DM system prompt — shorter, focused on public comment
+// replies. Must be SHORT (Instagram public comments), helpful, and willing
+// to SKIP when it can't confidently help.
+const COMMENT_AI_SYSTEM_PROMPT = `You are Pallavi, creator of Khilta — early learning worksheets for ages 2-8.
+
+Someone commented on our Instagram/Facebook post. Your job: decide if you can give a genuinely helpful reply, and if so, write a SHORT public comment reply.
+
+RESPONSE RULES (CRITICAL):
+- If you clearly understand the comment AND have a useful answer → reply in 1-2 short sentences
+- If you DON'T fully understand, the comment is unclear, or you have nothing useful to add → respond with EXACTLY: SKIP
+- Never guess. Never make up information. Never respond when confused.
+- When in doubt, SKIP.
+
+WHEN TO REPLY:
+- Questions about ages, worksheets, how to get them → give a short helpful answer + mention they can comment a keyword for free worksheets
+- Questions about what Khilta is → brief explanation
+
+WHEN TO SKIP:
+- Compliments, gratitude, greetings with no question
+- Comments in a language you don't fully understand
+- Comments that are just names, tags, or emoji
+- Anything you're not 100% sure about
+
+FORMAT:
+- Reply in the same language as the comment
+- Maximum 2 sentences, SHORT (Instagram public comment)
+- 1 emoji max
+- NO links (Instagram comments don't make links clickable)
+- If replying: suggest commenting "FREE" for a free sample worksheet
+
+WHAT KHILTA OFFERS:
+- FREE sample worksheets (comment FREE on posts)
+- 400+ worksheets, 10,000+ pages, ages 2-8
+- All digital PDF, instant download
+- Never mention prices
+
+Remember: SKIP is always better than a wrong or useless reply.`;
+
+/**
+ * Sends an unmatched comment to the AI for evaluation. Returns a public
+ * reply if the AI is confident, or null if the AI decided to SKIP.
+ *
+ * Uses the same AI Gateway (GPT-4o-mini) as the DM AI Smart Concierge.
+ */
+async function tryAiCommentReply(
+  supabase: SupabaseClient<Database>,
+  channel: Channel,
+  comment: IncomingComment,
+): Promise<string | null> {
+  try {
+    // Get workspace API keys
+    const { data: workspace } = await supabase
+      .from("workspaces")
+      .select("ai_api_key, late_api_key_encrypted")
+      .eq("id", channel.workspace_id)
+      .single();
+
+    if (!workspace?.late_api_key_encrypted) return null;
+
+    const aiGatewayKey = workspace.ai_api_key || process.env.AI_GATEWAY_API_KEY;
+    if (!aiGatewayKey) return null;
+
+    const model = "openai/gpt-4o-mini";
+
+    const gw = createGateway({ apiKey: aiGatewayKey });
+    const result = await generateText({
+      model: gw(model),
+      system: COMMENT_AI_SYSTEM_PROMPT,
+      messages: [
+        {
+          role: "user",
+          content: `Comment from @${comment.author.username || "user"}: "${comment.text}"`,
+        },
+      ],
+      temperature: 0.5, // Lower temp = more conservative, fewer guesses
+      maxOutputTokens: 150,
+    });
+
+    const reply = result.text.trim();
+
+    // AI decided to skip
+    if (reply.toUpperCase() === "SKIP" || reply.length < 2) {
+      // Log the skip for monitoring
+      await supabase.from("analytics_events").insert({
+        workspace_id: channel.workspace_id,
+        event_type: "comment_ai_skipped",
+        metadata: {
+          commentText: comment.text.slice(0, 200),
+          author: comment.author.username || comment.author.name,
+        },
+      });
+      return null;
+    }
+
+    // Log the successful AI reply for monitoring
+    await supabase.from("analytics_events").insert({
+      workspace_id: channel.workspace_id,
+      event_type: "comment_ai_replied",
+      metadata: {
+        commentText: comment.text.slice(0, 200),
+        aiReply: reply.slice(0, 200),
+        author: comment.author.username || comment.author.name,
+      },
+    });
+
+    return reply;
+  } catch (err) {
+    console.error("AI comment reply failed:", err);
+    return null; // On error, don't reply — fail gracefully
+  }
 }
 
 /**
@@ -74,7 +263,7 @@ export async function getActiveCommentTriggers(
 
 export interface ProcessCommentResult {
   matched: boolean;
-  skipped?: "already_processed";
+  skipped?: "already_processed" | "own_comment" | "rate_limited";
   triggerId?: string;
   error?: string;
 }
@@ -104,13 +293,120 @@ export async function processComment({
 
   if (alreadyLogged) return { matched: false, skipped: "already_processed" };
 
+  // Defense-in-depth: skip comments authored by our own account.
+  // The webhook handler does this check first, but we also check here so that
+  // even if the webhook guard is bypassed (e.g., different author field shape),
+  // we never process our own bot replies. This prevents infinite self-reply loops.
+  if (comment.author.username && comment.author.username === channel.username) {
+    return { matched: false, skipped: "own_comment" };
+  }
+  if (comment.author.name && channel.display_name &&
+      comment.author.name.trim() === channel.display_name.trim()) {
+    return { matched: false, skipped: "own_comment" };
+  }
+  // Check by platform Page ID — Facebook sends author.id = FB Page ID for
+  // page-owned comments. This is the most reliable check (unlike username
+  // which is null, or display_name which is a fragile string match).
+  if (comment.author.id && channel.platform_page_id &&
+      comment.author.id === channel.platform_page_id) {
+    return { matched: false, skipped: "own_comment" };
+  }
+
+  // ── One-DM-per-user-per-post rule ──────────────────────────────────────────
+  // Industry standard (Meta, ManyChat, Spur): a user should receive at most ONE
+  // automated DM and ONE public reply per post, no matter how many comments they
+  // leave. Without this, commenting the same keyword twice (or commenting two
+  // different matching keywords) sends duplicate worksheet DMs — which looks
+  // spammy and can hurt account reputation.
+  //
+  // We block in TWO cases:
+  //  1. dm_sent=true → DM already delivered successfully
+  //  2. matched_trigger_id IS NOT NULL AND created <5min ago → flow in progress
+  //     (prevents race condition when two comments arrive seconds apart)
+  // Case 2 has a 5-minute TTL so a permanently failed DM (dm_sent stays false)
+  // can be retried after the flow finishes.
+  if (comment.author.id) {
+    const { data: existingLogs } = await supabase
+      .from("comment_logs")
+      .select("dm_sent, reply_sent, created_at, matched_trigger_id")
+      .eq("channel_id", channel.id)
+      .eq("post_id", comment.postId)
+      .eq("author_id", comment.author.id)
+      .not("matched_trigger_id", "is", null);
+    if (existingLogs && existingLogs.length > 0) {
+      const hasDelivered = existingLogs.some((l) => l.dm_sent);
+      const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+      const hasInProgress = existingLogs.some(
+        (l) => !l.dm_sent && l.created_at > fiveMinAgo
+      );
+      if (hasDelivered || hasInProgress) {
+        console.log(
+          `[dedup] Author ${comment.author.id} on post ${comment.postId}: ` +
+          `${hasDelivered ? "DM already sent" : "flow in progress"} — skipping`,
+        );
+        return { matched: false, skipped: "rate_limited" };
+      }
+    }
+  }
+
   const triggers = await getActiveCommentTriggers(supabase, {
     channelId: channel.id,
     workspaceId: channel.workspace_id,
   });
   const matchedTrigger = matchCommentTrigger(triggers, comment);
 
+  // ── Self-reply loop guard: check if this comment matches any of our own
+  // configured replyTexts. If the bot's own reply happens to contain a trigger
+  // keyword (e.g. replying "Fun rainbow challenge" which still matches COLOR
+  // via partial match), the webhook may fire again for our own reply.
+  // The existing author checks (username/display_name/platform_page_id) are the
+  // primary defense, but Meta sometimes sends different author field shapes,
+  // so this content-based check is a safety net.
+  const allReplyTexts = triggers.flatMap((t) => {
+    const cfg = t.config as unknown as CommentKeywordConfig;
+    if (!cfg.replyText) return [];
+    return Array.isArray(cfg.replyText) ? cfg.replyText : [cfg.replyText];
+  });
+  if (isLikelyOurOwnReply(comment.text, allReplyTexts)) {
+    console.log(
+      `[loop-guard] Comment "${comment.text.slice(0, 40)}..." matches our own reply text — skipping`,
+    );
+    return { matched: false, skipped: "own_comment" };
+  }
+
   if (!matchedTrigger) {
+    // ── AI comment reply for unmatched comments ────────────────────────────
+    // Pre-filter: skip spam, greetings, tags, links without wasting AI tokens
+    if (!shouldSkipComment(comment.text)) {
+      // Send to AI — it will decide whether to reply or SKIP
+      const aiReply = await tryAiCommentReply(supabase, channel, comment);
+
+      if (aiReply) {
+        // AI had a confident answer — post it as a public reply
+        const { data: workspace } = await supabase
+          .from("workspaces")
+          .select("late_api_key_encrypted")
+          .eq("id", channel.workspace_id)
+          .single();
+
+        if (workspace?.late_api_key_encrypted) {
+          try {
+            const zernio = createZernioClient(workspace.late_api_key_encrypted);
+            await zernio.comments.replyToInboxPost({
+              path: { postId: comment.postId },
+              body: {
+                accountId: channel.late_account_id,
+                message: aiReply,
+                commentId: comment.id,
+              },
+            });
+          } catch (err) {
+            console.error("Failed to post AI comment reply:", err);
+          }
+        }
+      }
+    }
+
     await logComment({ supabase, channel, comment, triggerId: null });
     return { matched: false };
   }
@@ -168,7 +464,8 @@ export async function processComment({
     }
 
     let replySent = false;
-    if (config.replyText) {
+    const replyMessage = pickReplyText(config.replyText);
+    if (replyMessage) {
       const { data: workspace } = await supabase
         .from("workspaces")
         .select("late_api_key_encrypted")
@@ -182,7 +479,7 @@ export async function processComment({
             path: { postId: comment.postId },
             body: {
               accountId: channel.late_account_id,
-              message: config.replyText,
+              message: replyMessage,
               commentId: comment.id,
             },
           });
@@ -215,6 +512,30 @@ export async function processComment({
 
     let dmSent = false;
     if (conversation) {
+      // Store the triggering comment as an inbound message so the inbox
+      // shows what the contact commented, not just the DM flow that followed.
+      await supabase.from("messages").insert({
+        conversation_id: conversation.id,
+        direction: "inbound",
+        text: comment.text,
+        platform_message_id: `comment_${comment.id}`,
+        status: "sent",
+      });
+
+      // Claim the comment log BEFORE the flow runs. This closes a race condition
+      // where two comments from the same user arrive in quick succession (seconds
+      // apart), both pass the dedup check above (because neither log is written
+      // yet), and both trigger a DM. We write dm_sent=false initially — the dedup
+      // above already checks dm_sent=true, so a concurrent comment from a DIFFERENT
+      // post will pass correctly. For the same post, the reply_sent guard prevents
+      // duplicate public replies.
+      await logComment({
+        supabase, channel, comment,
+        triggerId: matchedTrigger.id,
+        dmSent: false,  // Will be updated to true ONLY if DM actually succeeds
+        replySent,
+      });
+
       try {
         await executeFlow(supabase, {
           triggerId: matchedTrigger.id,
@@ -228,7 +549,7 @@ export async function processComment({
             text: comment.text,
             sender: {
               id: senderId,
-              name: comment.author.name,
+              name: senderName, // Use senderName (falls back to username) — comment.author.name is often empty for IG comments
               username: comment.author.username,
             },
           },
@@ -239,9 +560,25 @@ export async function processComment({
             post_id: comment.postId,
           },
         });
-        dmSent = true;
+
+        // Verify the DM was actually sent. executeSendMessage now re-throws on
+        // failure, so reaching here means the first message was sent. But we
+        // still verify via the messages table to handle edge cases (partial
+        // multi-message sends where the first succeeds but a later one fails).
+        const { data: recentMessages } = await supabase
+          .from("messages")
+          .select("status")
+          .eq("conversation_id", conversation.id)
+          .eq("direction", "outbound")
+          .eq("sent_by_flow_id", matchedTrigger.flow_id)
+          .gte("created_at", new Date(Date.now() - 60000).toISOString()) // last 60s
+          .order("created_at", { ascending: false })
+          .limit(1);
+
+        dmSent = recentMessages?.[0]?.status === "sent";
       } catch (err) {
         console.error("Failed to execute comment flow:", err);
+        dmSent = false;
       }
     }
 
diff --git a/lib/flow-engine/engine.ts b/lib/flow-engine/engine.ts
index da6464c..21558c4 100644
--- a/lib/flow-engine/engine.ts
+++ b/lib/flow-engine/engine.ts
@@ -37,6 +37,31 @@ export async function executeFlow(
     context.variables.message ??= context.incomingMessage.text;
   }
 
+  // Seed {{contact_name}} from the incoming message sender name so comment
+  // flows (which set variables.commenter_name) and DM flows can personalize
+  // their messages without each node having to look up the contact. Idempotent:
+  // only set if not already present, so comment-triggered flows that seed
+  // {{commenter_name}} keep their own value and DM flows get the sender name.
+  // FALLBACK CHAIN: name → username → contact display_name from DB
+  // (Facebook/IG DMs may have null name — same bug pattern as comment-processor)
+  const senderName =
+    context.incomingMessage.sender?.name ||
+    context.incomingMessage.sender?.username;
+  if (senderName) {
+    context.variables.contact_name ??= senderName;
+  }
+  // If still not set, try contact display_name from DB
+  if (!context.variables.contact_name && context.contactId) {
+    const { data: contact } = await supabase
+      .from("contacts")
+      .select("display_name")
+      .eq("id", context.contactId)
+      .maybeSingle();
+    if (contact?.display_name) {
+      context.variables.contact_name = contact.display_name;
+    }
+  }
+
   // Check for active session waiting for input
   const { data: activeSession } = await supabase
     .from("flow_sessions")
@@ -64,6 +89,16 @@ export async function executeFlow(
   const nodes = flow.nodes as unknown as FlowNode[];
   const edges = flow.edges as unknown as FlowEdge[];
 
+  // Guard against malformed flow data — nodes/edges must be arrays.
+  // Supabase can return null/string if the JSONB column is corrupted.
+  // Without this guard, nodes.find() throws "i.find is not a function" (minified).
+  if (!Array.isArray(nodes) || !Array.isArray(edges)) {
+    console.error(
+      `Flow ${context.flowId} has malformed nodes/edges (nodes: ${typeof nodes}, edges: ${typeof edges})`
+    );
+    return;
+  }
+
   // Get channel platform and late_account_id
   const { data: channel } = await supabase
     .from("channels")
@@ -283,7 +318,22 @@ async function traverseNodes(
   });
 
   // Execute the node
-  const result = await executeNode(supabase, node, context, sessionId);
+  let result: string | void;
+  try {
+    result = await executeNode(supabase, node, context, sessionId);
+  } catch (error) {
+    // Node execution failed (e.g. DM send failure). Mark the session as
+    // cancelled so it doesn't strand as "active" forever — which would cause
+    // the next message from this contact to resume a dead session.
+    // Note: DB CHECK constraint allows 'active', 'completed', 'expired', 'cancelled'.
+    // 'cancelled' is the closest to 'failed' (can't add 'failed' without migration).
+    console.error(`Node ${node.id} (${node.type}) failed in flow ${context.flowId}:`, error);
+    await supabase
+      .from("flow_sessions")
+      .update({ status: "cancelled" })
+      .eq("id", sessionId);
+    throw error;
+  }
 
   // Persist variables written by output-producing nodes so they survive
   // pauses (resumeSession reloads them from the session row).
@@ -398,6 +448,21 @@ async function sendFirstMessageAsPrivateReply(
       body: { accountId: lateAccountId, message: text },
     });
 
+    // Link the conversation to its Zernio conversation ID so the inbox
+    // can fetch the message thread. For Facebook, Zernio's conversation
+    // ID equals the commenter's PSID (sender.id). For Instagram, it's
+    // set later when the contact sends a DM. Without this, the inbox
+    // shows "Select a conversation" forever because the messages API
+    // returns 404 when late_conversation_id is null.
+    const senderId = context.incomingMessage?.sender?.id;
+    if (senderId && !context.lateConversationId) {
+      await supabase
+        .from("conversations")
+        .update({ late_conversation_id: senderId })
+        .eq("id", context.conversationId);
+      context.lateConversationId = senderId;
+    }
+
     await supabase.from("messages").insert({
       conversation_id: context.conversationId,
       direction: "outbound",
@@ -421,7 +486,19 @@ async function sendFirstMessageAsPrivateReply(
       sent_by_flow_id: context.flowId,
       status: "failed",
     });
-    return;
+
+    await supabase.from("analytics_events").insert({
+      workspace_id: context.workspaceId,
+      flow_id: context.flowId,
+      contact_id: context.contactId,
+      event_type: "message_failed",
+      metadata: { error: error instanceof Error ? error.message : "Unknown error" },
+    });
+
+    // Re-throw so the caller (executeFlow → processComment) knows the DM failed
+    // and can mark dm_sent=false in the comment log. Without this, the pre-written
+    // dm_sent=true stays, permanently locking the user out (phantom lockout bug).
+    throw error;
   }
 
   if (data.messages.length > 1) {
@@ -463,7 +540,24 @@ async function executeSendMessage(
     }
   }
 
-  // Resolve late_conversation_id from conversation if not in context
+  // ── Comment-triggered flows must always use Private Reply API ──────────────
+  // Meta's sendInboxMessage (standard DM) requires the user to have messaged the
+  // page within the last 24h. But Meta's sendPrivateReplyToComment API allows
+  // replying to a comment via DM for up to 7 DAYS after the comment was posted.
+  // Comment-triggered flows ALWAYS have comment_id + post_id in context, so we
+  // always use the private reply endpoint here — regardless of whether a DM
+  // conversation already exists. This prevents the "24h window" failure that
+  // blocked returning users (who DM'd >24h ago) from receiving their worksheet.
+  if (
+    context.variables?.comment_id &&
+    context.variables?.post_id &&
+    lateAccountId
+  ) {
+    await sendFirstMessageAsPrivateReply(supabase, zernio, data, context, lateAccountId);
+    return;
+  }
+
+  // ── Regular DM flows (not comment-triggered) ───────────────────────────────
   let lateConversationId = context.lateConversationId;
   if (!lateConversationId) {
     const { data: conversation } = await supabase
@@ -473,14 +567,6 @@ async function executeSendMessage(
       .single();
 
     if (!conversation?.late_conversation_id) {
-      // Comment-triggered flows have no DM conversation yet. Instagram allows
-      // exactly one private reply per comment, so deliver the first message via
-      // the private-reply endpoint instead of silently dropping the whole node
-      // (users build comment flows with plain Send Message nodes, not Private Reply).
-      if (context.variables?.comment_id && context.variables?.post_id && lateAccountId) {
-        await sendFirstMessageAsPrivateReply(supabase, zernio, data, context, lateAccountId);
-        return;
-      }
       console.error("No late_conversation_id found for conversation:", context.conversationId);
       return;
     }
@@ -545,6 +631,14 @@ async function executeSendMessage(
         status: "sent",
       });
 
+      // Update conversation preview so inbox sidebar shows latest message
+      await supabase.from("conversations")
+        .update({
+          last_message_preview: text.slice(0, 100),
+          last_message_at: new Date().toISOString(),
+        })
+        .eq("id", context.conversationId);
+
       await supabase.from("analytics_events").insert({
         workspace_id: context.workspaceId,
         flow_id: context.flowId,
@@ -568,6 +662,11 @@ async function executeSendMessage(
         event_type: "message_failed",
         metadata: { error: error instanceof Error ? error.message : "Unknown error" },
       });
+
+      // Re-throw so callers know the send failed (matches sendFirstMessageAsPrivateReply
+      // and executePrivateReply behavior). Without this, the flow continues as if the
+      // DM was sent successfully, potentially sending follow-up messages into the void.
+      throw error;
     }
 
     // Small delay between messages
@@ -774,6 +873,7 @@ async function executeHttpRequest(
         ...data.headers,
       },
       body: data.method !== "GET" ? body : undefined,
+      signal: AbortSignal.timeout(10000), // Prevent indefinite hang on slow endpoints
     });
 
     const responseData = await response.text();
@@ -788,6 +888,12 @@ async function executeHttpRequest(
     }
   } catch (error) {
     console.error("HTTP request failed:", error);
+    // Store error in response variable so downstream nodes don't get literal tokens
+    if (data.responseVariable && context.variables) {
+      context.variables[data.responseVariable] = JSON.stringify({
+        error: error instanceof Error ? error.message : "Request failed",
+      }) as string;
+    }
   }
 }
 
@@ -842,6 +948,11 @@ async function executeSubscription(
 }
 
 function executeABSplit(data: ABSplitNodeData): string {
+  // Guard against empty/missing paths array — prevents TypeError crash
+  if (!data.paths?.length) {
+    console.error("A/B split node has no paths configured");
+    return "handle:default";
+  }
   const totalWeight = data.paths.reduce((sum, p) => sum + p.weight, 0);
   const random = Math.random() * totalWeight;
 
@@ -888,8 +999,14 @@ async function executeCommentReply(
     lateAccountId = channel.late_account_id;
   }
 
-  const commentId = context.variables?.comment_id || context.incomingMessage.sender?.id;
-  if (!commentId) return;
+  // Use comment_id from context variables. NEVER fall back to sender.id —
+  // that's the commenter's PSID/IGA user ID, not a comment ID, and passing it
+  // here would make the API reply to the wrong entity (or fail silently).
+  const commentId = context.variables?.comment_id;
+  if (!commentId) {
+    console.error("No comment_id in context variables for commentReply node");
+    return;
+  }
 
   const postId = context.variables?.post_id;
   if (!postId) {
@@ -906,6 +1023,17 @@ async function executeCommentReply(
     });
   } catch (error) {
     console.error("Failed to post comment reply:", error);
+    await supabase.from("analytics_events").insert({
+      workspace_id: context.workspaceId,
+      flow_id: context.flowId,
+      contact_id: context.contactId,
+      event_type: "message_failed",
+      metadata: {
+        error: error instanceof Error ? error.message : "Unknown error",
+        node: "commentReply",
+      },
+    });
+    throw error;
   }
 }
 
@@ -941,8 +1069,14 @@ async function executePrivateReply(
     lateAccountId = channel.late_account_id;
   }
 
-  const commentId = context.variables?.comment_id || context.incomingMessage.sender?.id;
-  if (!commentId) return;
+  // Use comment_id from context variables. NEVER fall back to sender.id —
+  // that's the commenter's PSID/IGA user ID, not a comment ID, and passing it
+  // here would make the API reply to the wrong entity (or fail silently).
+  const commentId = context.variables?.comment_id;
+  if (!commentId) {
+    console.error("No comment_id in context variables for privateReply node");
+    return;
+  }
 
   const postId = context.variables?.post_id;
   if (!postId) {
@@ -977,6 +1111,19 @@ async function executePrivateReply(
       sent_by_flow_id: context.flowId,
       status: "failed",
     });
+
+    await supabase.from("analytics_events").insert({
+      workspace_id: context.workspaceId,
+      flow_id: context.flowId,
+      contact_id: context.contactId,
+      event_type: "message_failed",
+      metadata: { error: error instanceof Error ? error.message : "Unknown error" },
+    });
+
+    // Re-throw so the caller knows the DM failed and can handle it
+    // (e.g. mark dm_sent=false, enable retry). Without this, the flow
+    // silently continues as if the message was delivered.
+    throw error;
   }
 }
 
diff --git a/lib/flow-engine/nodes/ai-response.ts b/lib/flow-engine/nodes/ai-response.ts
index 7e899b6..7ad019b 100644
--- a/lib/flow-engine/nodes/ai-response.ts
+++ b/lib/flow-engine/nodes/ai-response.ts
@@ -74,10 +74,12 @@ export async function executeAiResponse(
   }
 
   // Fetch last N messages from the conversation for context
+  // Include attachments so the AI knows when a message contained an
+  // image/sticker/etc it cannot see — prevents hallucinated guesses.
   const contextMessages = data.contextMessages || 10;
   const { data: recentMessages } = await supabase
     .from("messages")
-    .select("direction, text")
+    .select("direction, text, attachments")
     .eq("conversation_id", context.conversationId)
     .order("created_at", { ascending: false })
     .limit(contextMessages);
@@ -89,27 +91,172 @@ export async function executeAiResponse(
     // Reverse to get chronological order (oldest first)
     const chronological = [...recentMessages].reverse();
     for (const msg of chronological) {
-      if (!msg.text) continue;
+      if (!msg.text && !msg.attachments) continue;
+      let content = msg.text || "";
+      // Append attachment metadata so the AI knows there was an image/sticker
+      // it cannot process. This lets the system prompt's SKIP rule fire.
+      const rawAttachments = msg.attachments;
+      const attachmentList = Array.isArray(rawAttachments) ? rawAttachments : [];
+      if (attachmentList.length > 0) {
+        const types = attachmentList
+          .map((a: unknown) => {
+            if (typeof a === "object" && a !== null && "type" in a) {
+              return String((a as { type?: string }).type || "attachment");
+            }
+            return "attachment";
+          })
+          .join(", ");
+        content += content ? ` [Attachment: ${types}]` : `[Attachment: ${types}]`;
+      }
       aiMessages.push({
         role: msg.direction === "inbound" ? "user" : "assistant",
-        content: msg.text,
+        content,
       });
     }
   }
 
+  // ── RAG Knowledge Base Search ──────────────────────────────────────────
+  // Search the knowledge_base table for relevant context based on the
+  // latest user message. Inject the results into the system prompt so the
+  // AI has accurate, specific information to answer with.
+  let ragContext = "";
+  const aiGatewayKeyEarly = workspace.ai_api_key || process.env.AI_GATEWAY_API_KEY;
+
+  if (aiGatewayKeyEarly) {
+    try {
+      // Get the latest inbound message (the user's current question)
+      const latestUserMsg = aiMessages
+        .filter((m) => m.role === "user")
+        .pop();
+
+      if (latestUserMsg && latestUserMsg.content.trim().length > 2) {
+        // Generate embedding for the user's message via Vercel AI Gateway
+        const embedResponse = await fetch(
+          "https://ai-gateway.vercel.sh/v1/embeddings",
+          {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${aiGatewayKeyEarly}`,
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              model: "openai/text-embedding-3-small",
+              input: latestUserMsg.content.slice(0, 1000),
+            }),
+          }
+        );
+
+        if (embedResponse.ok) {
+          const embedData = await embedResponse.json();
+          const queryEmbedding: number[] = embedData.data[0].embedding;
+          const embeddingStr = `[${queryEmbedding.join(",")}]`;
+          const escapedQuery = latestUserMsg.content.replace(/'/g, "''").slice(0, 500);
+
+          // Call hybrid search RPC (keyword + semantic with RRF fusion)
+          const { data: searchResults, error: searchError } = await supabase.rpc(
+            "hybrid_search_kb" as never,
+            {
+              query_text: escapedQuery,
+              query_embedding: embeddingStr,
+              match_count: 3,
+              full_text_weight: 1.0,
+              semantic_weight: 1.5, // Slightly favor semantic for conversational queries
+              rrf_k: 50,
+            } as never
+          ) as { data: Array<{ question: string; answer: string; score: number }> | null; error: unknown };
+
+          if (!searchError && searchResults && searchResults.length > 0) {
+            // Build context string from search results
+            const contextParts = searchResults.map(
+              (r: { question: string; answer: string }) => `Q: ${r.question}\nA: ${r.answer}`
+            );
+            ragContext = `\n\n---\n## KNOWLEDGE BASE RESULTS (use these to answer the user's question accurately)\n${contextParts.join("\n\n")}\n---\n`;
+          }
+        }
+      }
+    } catch (ragError) {
+      // RAG failure should NOT block the response — just log and continue
+      console.warn("RAG search failed (non-blocking), continuing with base prompt:", ragError);
+    }
+  }
+
   try {
     const model = data.model || "openai/gpt-4o-mini";
     const aiGatewayKey = workspace.ai_api_key || process.env.AI_GATEWAY_API_KEY;
-    const gw = createGateway({ apiKey: aiGatewayKey || undefined });
-    const result = await generateText({
-      model: gw(model),
-      system: data.systemPrompt || "You are a helpful customer support agent.",
-      messages: aiMessages,
-      temperature: data.temperature ?? 0.7,
-      maxOutputTokens: data.maxTokens ?? 500,
-    });
 
-    const text = result.text;
+    // Retry with exponential backoff for transient errors (rate limits,
+    // timeouts, 5xx responses). Classifies errors so permanent failures
+    // (auth, bad request) don't waste retry attempts.
+    const maxRetries = data.maxRetries ?? 3;
+    let lastError: Error | null = null;
+
+    const isTransient = (err: unknown): boolean => {
+      const msg = err instanceof Error ? err.message : String(err);
+      const transient = [
+        "rate limit", "rate_limit", "429", "timeout", "timed out",
+        "ETIMEDOUT", "ECONNRESET", "ECONNREFUSED", "fetch failed",
+        "503", "502", "500", "network", "temporarily unavailable",
+        "overloaded", "capacity",
+      ];
+      return transient.some((t) => msg.toLowerCase().includes(t.toLowerCase()));
+    };
+
+    const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+    let text = "";
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const gw = createGateway({ apiKey: aiGatewayKey || undefined });
+        const result = await generateText({
+          model: gw(model),
+          system: (data.systemPrompt || "You are a helpful customer support agent.") + ragContext,
+          messages: aiMessages,
+          temperature: data.temperature ?? 0.7,
+          maxOutputTokens: data.maxTokens ?? 500,
+        });
+
+        text = result.text;
+        lastError = null;
+        break; // success
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+
+        if (attempt < maxRetries && isTransient(err)) {
+          // Exponential backoff: 1s, 2s, 4s, 8s...
+          const backoffMs = Math.min(1000 * Math.pow(2, attempt), 8000);
+          await sleep(backoffMs);
+          continue;
+        }
+
+        // Permanent error or out of retries — stop retrying
+        break;
+      }
+    }
+
+    // All retries exhausted — send fallback instead of ghosting the contact
+    if (lastError) {
+      throw lastError;
+    }
+
+    // ── SKIP detection ──────────────────────────────────────────────────────
+    // The AI may decide it cannot confidently help with this message.
+    // In that case it returns exactly "SKIP" (enforced by the system prompt).
+    // When it does, we DON'T send any message to the contact — silence is
+    // better than a confused or hallucinated reply.
+    if (text.trim().toUpperCase() === "SKIP") {
+      // Log the skip for monitoring so we can calibrate the threshold later
+      await supabase.from("analytics_events").insert({
+        workspace_id: context.workspaceId,
+        flow_id: context.flowId,
+        contact_id: context.contactId,
+        event_type: "ai_skipped",
+        metadata: { reason: "AI returned SKIP — not confident enough to reply" },
+      });
+
+      // Cancel the session — no message sent, downstream nodes don't run
+      return cancelRun(supabase, sessionId);
+    }
 
     // Expose the generated text to downstream nodes as {{ai_response}}
     context.variables = { ...(context.variables ?? {}), ai_response: text };
@@ -143,20 +290,40 @@ export async function executeAiResponse(
   } catch (error) {
     console.error("Failed to generate or send AI response:", error);
 
-    await supabase.from("messages").insert({
-      conversation_id: context.conversationId,
-      direction: "outbound",
-      text: "[AI response failed]",
-      sent_by_flow_id: context.flowId,
-      status: "failed",
-    });
+    // Send a user-facing fallback instead of "[AI response failed]" so the
+    // contact is not left hanging. Falls back to a generic message.
+    const fallbackMessage =
+      data.fallbackMessage ||
+      "I'm having trouble responding right now, but I'll get back to you shortly! 😊";
+
+    // Try to send the fallback via Zernio
+    try {
+      await zernio.messages.sendInboxMessage({
+        path: { conversationId: lateConversationId },
+        body: { accountId: lateAccountId, message: fallbackMessage },
+      });
+
+      await supabase.from("messages").insert({
+        conversation_id: context.conversationId,
+        direction: "outbound",
+        text: fallbackMessage,
+        sent_by_flow_id: context.flowId,
+        platform_message_id: null,
+        status: "sent",
+      });
+    } catch (sendErr) {
+      console.error("Failed to send AI fallback message:", sendErr);
+    }
 
     await supabase.from("analytics_events").insert({
       workspace_id: context.workspaceId,
       flow_id: context.flowId,
       contact_id: context.contactId,
       event_type: "message_failed",
-      metadata: { error: error instanceof Error ? error.message : "Unknown error" },
+      metadata: {
+        error: error instanceof Error ? error.message : "Unknown error",
+        fallback_sent: true,
+      },
     });
 
     return cancelRun(supabase, sessionId);
diff --git a/lib/flow-engine/types.ts b/lib/flow-engine/types.ts
index 5545544..c91b3c0 100644
--- a/lib/flow-engine/types.ts
+++ b/lib/flow-engine/types.ts
@@ -147,6 +147,17 @@ export interface AiResponseNodeData {
    * {{ai_response}} without double-sending. Defaults to true for back-compat.
    */
   sendDirectly?: boolean;
+  /**
+   * Maximum number of retry attempts when the AI provider returns a transient
+   * error (rate limit, timeout, 5xx). Each retry uses exponential backoff.
+   * Defaults to 3. Set to 0 to disable retries.
+   */
+  maxRetries?: number;
+  /**
+   * Fallback message sent to the contact when all retry attempts fail. If
+   * unset, a generic default is used. Prevents the contact from being ghosted.
+   */
+  fallbackMessage?: string;
 }
 
 export interface EnrollSequenceNodeData {
diff --git a/lib/flow-triggers.ts b/lib/flow-triggers.ts
index 5b4fd3d..be27018 100644
--- a/lib/flow-triggers.ts
+++ b/lib/flow-triggers.ts
@@ -55,7 +55,12 @@ export function buildDesiredTriggers(
         const postIds = data.postIds ?? nodeConfig.postIds;
         if (Array.isArray(postIds) && postIds.length > 0) config.postIds = postIds;
         const replyText = data.replyText ?? nodeConfig.replyText;
-        if (typeof replyText === "string" && replyText.trim()) config.replyText = replyText;
+        // replyText can be a single string or an array of variants for rotation
+        if (typeof replyText === "string" && replyText.trim()) {
+          config.replyText = replyText;
+        } else if (Array.isArray(replyText) && replyText.length > 0) {
+          config.replyText = replyText;
+        }
       } else if (type === "postback" || type === "quick_reply") {
         const payload = data.payload ?? nodeConfig.payload;
         if (payload !== undefined) config.payload = payload;
diff --git a/lib/sequence-processor.ts b/lib/sequence-processor.ts
index d959bdd..59a8e8a 100644
--- a/lib/sequence-processor.ts
+++ b/lib/sequence-processor.ts
@@ -155,6 +155,23 @@ async function sendSequenceMessage(
 
   const zernio = createZernioClient(workspace.late_api_key_encrypted);
 
+  // Interpolate template variables ({{contact_name}} etc.)
+  // Uses simple flat-key lookup (sequences only have contact_name, no nested objects).
+  // The engine's interpolateVariables supports dot paths for complex flow variables;
+  // sequences don't need that complexity.
+  let variables: Record<string, string> = {};
+  const { data: contact } = await supabase
+    .from("contacts")
+    .select("display_name")
+    .eq("id", contactId)
+    .maybeSingle();
+  if (contact?.display_name) {
+    variables.contact_name = contact.display_name;
+  }
+  const interpolatedText = text.replace(/\{\{(\w+)\}\}/g, (token, key: string) =>
+    variables[key] ?? token
+  );
+
   // Get channel's late_account_id
   const { data: channel } = await supabase
     .from("channels")
@@ -188,17 +205,25 @@ async function sendSequenceMessage(
   try {
     const response = await zernio.messages.sendInboxMessage({
       path: { conversationId: conversation.late_conversation_id },
-      body: { accountId: channel.late_account_id, message: text },
+      body: { accountId: channel.late_account_id, message: interpolatedText },
     });
 
     // Store outbound message
     await supabase.from("messages").insert({
       conversation_id: conversation.id,
       direction: "outbound",
-      text,
+      text: interpolatedText,
       status: "sent",
       platform_message_id: response.data?.data?.messageId || null,
     });
+
+    // Update conversation preview
+    await supabase.from("conversations")
+      .update({
+        last_message_preview: interpolatedText.slice(0, 100),
+        last_message_at: new Date().toISOString(),
+      })
+      .eq("id", conversation.id);
   } catch (err) {
     console.error("Failed to send sequence message:", err);
 
@@ -206,7 +231,7 @@ async function sendSequenceMessage(
     await supabase.from("messages").insert({
       conversation_id: conversation.id,
       direction: "outbound",
-      text,
+      text: interpolatedText,
       status: "failed",
     });
   }
diff --git a/lib/types/database.ts b/lib/types/database.ts
index a10caf0..749599f 100644
--- a/lib/types/database.ts
+++ b/lib/types/database.ts
@@ -142,6 +142,7 @@ export interface Database {
           is_active: boolean;
           last_comment_cursor: string | null;
           comment_rules: Json | null;
+          platform_page_id: string | null;
           created_at: string;
           updated_at: string;
         };
@@ -158,6 +159,7 @@ export interface Database {
           is_active?: boolean;
           last_comment_cursor?: string | null;
           comment_rules?: Json | null;
+          platform_page_id?: string | null;
           created_at?: string;
           updated_at?: string;
         };
@@ -172,6 +174,7 @@ export interface Database {
           is_active?: boolean;
           last_comment_cursor?: string | null;
           comment_rules?: Json | null;
+          platform_page_id?: string | null;
           updated_at?: string;
         };
         Relationships: [
diff --git a/new_system_prompt.txt b/new_system_prompt.txt
new file mode 100644
index 0000000..081818a
--- /dev/null
+++ b/new_system_prompt.txt
@@ -0,0 +1,165 @@
+You are Pallavi, the educator and creator behind Khilta. You have a B.Ed and NTT certification with 10+ years teaching children ages 2-8.
+
+You personally designed and created every worksheet and activity at Khilta. This is YOUR work.
+
+Always speak as Pallavi in first person: "I'm Pallavi", "I", "I created these". Never refer to yourself as a team member or third party.
+
+---
+
+## HOW TO TALK
+- Warm, encouraging, genuine — like a friendly teacher who truly cares
+- SHORT replies (2-3 sentences max). DMs should feel human, not marketing copy.
+- Use emojis naturally (1-2 per message, don't overdo it)
+- Vary your words — NEVER repeat the same phrasing twice in one conversation
+- Be conversational. If someone says "Good night" or "Happy Birthday" — a simple warm reply is fine, don't over-explain.
+
+---
+
+## YOUR GOAL
+Help parents and teachers discover Khilta's worksheets. Guide them from free sample → full bundle naturally. But ALWAYS answer their actual question FIRST with real information before suggesting anything.
+
+---
+
+## LINKS (CRITICAL)
+Instagram and Facebook DMs only make links clickable with the full https:// prefix.
+- ✅ CORRECT: "https://khilta.com/go"
+- ❌ WRONG: "khilta.com/go" (NOT clickable, useless)
+ALWAYS use full https:// prefix. NEVER write bare domain names.
+
+---
+
+## ANTI-REPETITION (CRITICAL)
+You can see the last 10 messages in this conversation. USE THEM.
+- If you already said "comment FREE" → DON'T say it again. Move forward.
+- If you already shared https://khilta.com/go → DON'T repeat it unless they ask for the link again.
+- If you already gave a piece of information → DON'T repeat it.
+- NEVER reuse the same sentence or phrasing from earlier in the conversation.
+- Each reply must ADD new value or directly address their latest message.
+- If the person is repeating themselves, they feel unheard. Give a DIFFERENT answer that addresses their specific need.
+
+---
+
+## READ THE CONVERSATION BEFORE REPLYING
+What you say depends on WHERE the person is in the conversation:
+- First message / greeting → welcome warmly, ask what they need
+- Asked a specific question → answer it directly with real detail from the knowledge base
+- Already got a free sample → ask how it went, suggest the full bundle
+- Expressing frustration or repeating themselves → acknowledge their need, give NEW information
+- Already told you their child's age or situation → DON'T ask again. Remember it.
+- Asking about something you already covered → confirm briefly, don't re-explain
+
+---
+
+## KHILTA — WHAT WE ACTUALLY OFFER
+
+### Quick Links
+- Full bundle (everything) → https://khilta.com/go
+- Free sample pack → comment "FREE" on Instagram posts
+- 1-on-1 consultation with Pallavi → https://khilta.com/book
+
+### Comment Keywords (people type these on posts to get specific worksheets)
+- FREE → free sample pack (24 worksheets)
+- FOCUS → focus & attention worksheet
+- CRACK → secret code / crack the code worksheet
+- PATTERN → pattern matching worksheet
+- COLOR or COLOUR → color code breaker worksheet
+- FOLLOW → follow the pattern worksheet
+- COPY → copy the patterns worksheet
+
+### The Bundle
+- 10,000+ pages across 400+ worksheets in 28+ categories
+- Ages 2-8
+- All digital PDF — instant download, print at home
+- No physical shipping anywhere in the world
+
+### Categories (what's inside)
+- Alphabet & Tracing: letter recognition, handwriting, tracing A-Z, alphabet activity books
+- Numbers & Counting: number tracing, counting with pictures, addition, subtraction, time/clock reading
+- Coloring & Shapes: shape recognition, coloring pages, 2D shapes, creative expression
+- Stories & Reading: illustrated storybooks (Lion & Mouse, Ugly Duckling, Goldilocks, etc.)
+- Flashcards & Posters: fruit, number, alphabet, weather flashcards (print, cut, learn)
+- Activities & Crafts: cut & paste, craft activities, fine motor skill development
+- Mazes & Logic: mazes, problem-solving, spatial reasoning, sequencing
+- Pattern Matching: copy patterns, follow patterns, pattern recognition
+- Phonics: letter sounds, beginning sounds, word building
+- Math: addition, subtraction, multiplication basics, counting with fruits
+- Focus & Attention: concentration activities, attention span building
+- Color Recognition: color matching, color-by-number, color identification
+- Handwriting: tracing lines, curves, pencil control, letter formation
+- Animals & Nature: animal-themed activities, nature coloring
+
+### Age Guidance (general — every child is different)
+- Ages 2-3: tracing lines, coloring, shape sorting, picture matching, flashcards
+- Ages 3-4: alphabet tracing, number tracing (1-10), coloring, simple mazes, pattern matching
+- Ages 4-5: letter sounds/phonics, counting (1-20), cut & paste, craft activities
+- Ages 5-6: beginning reading, simple addition, color-by-number, storybooks
+- Ages 6-8: math (addition/subtraction), reading comprehension, advanced mazes, logic puzzles
+
+### Need-Based Guidance
+- Motor skills → tracing worksheets, coloring within lines, cut & paste, craft activities
+- Autism / SEN / Special needs → FOCUS worksheets (concentration), tracing, matching, pattern activities (structured and predictable)
+- Reading / Phonics → alphabet tracing, phonics worksheets, storybooks, flashcards
+- Math → number tracing, counting, addition with fruits, clock/time, arrange & sort
+- Concentration → FOCUS worksheets, mazes, pattern matching
+- Writing / Handwriting → tracing lines, alphabet tracing workbook, trace & color
+- Creativity → coloring books, craft activities, themed packs (dinosaurs, unicorns)
+
+---
+
+## PRICE — CRITICAL RULES
+NEVER mention specific prices. NEVER. Not for India, not for international — different customers see different prices based on their country.
+- If asked "how much" or "what's the price" → "You can check all the details at https://khilta.com/go! 😊"
+- If asked to reduce/negotiate price → acknowledge warmly, redirect to the VALUE of 10,000+ pages, suggest trying free samples first
+- NEVER say "it costs" or "the price is" or mention any number
+- NEVER agree or disagree with a price they mention
+
+---
+
+## ANSWERING SPECIFIC QUESTIONS
+When someone asks a specific question, USE THE KNOWLEDGE BASE above to give a REAL answer. Don't just redirect to a link.
+
+- "Do you have phonics?" → "Yes! We have phonics worksheets covering letter sounds, beginning sounds, and word building. They're part of the full bundle at https://khilta.com/go 📚"
+- "Need motor skill activities" → "Our tracing, coloring, cut & paste, and craft activities are specifically designed for fine motor development! They help kids build pencil control and hand strength. 💪 Try a free sample — comment FREE on our posts!"
+- "For autistic kids" → "Many of our activities work beautifully for autistic children! Our FOCUS worksheets build concentration, and the structured pattern activities provide the predictability kids often enjoy. Comment FOCUS on our posts for a sample! 🌸"
+- "Do you have math worksheets?" → "Yes! Number tracing, counting with pictures, addition with fruits, subtraction, and even time/clock reading. Comment FREE for a sample! 🔢"
+- "Is it hardcopy or ebook?" → "All digital PDF! Instant download and you print at home. 📄 Get everything at https://khilta.com/go"
+- "Did you create these?" → "Yes! I'm Pallavi — I personally designed every worksheet. B.Ed + NTT certified, 10+ years teaching. 🌸"
+- "Where are you based?" → "India 🇮🇳 But our worksheets are loved by parents and teachers worldwide!"
+- "I need the sheets from your reels" → "Those are our signature worksheets! 🌟 Comment the keyword from the reel (like PATTERN, COLOR, FOCUS) and I'll send it right away!"
+
+---
+
+## SAMPLE-TO-BUNDLE FUNNEL
+When someone shows interest (first time), offer free sample:
+"I'd love for you to try some! Comment 'FREE' on our posts for a sample pack. 🌸"
+
+After they've tried or seen samples, explain:
+"That's just 2-5% of what we have! The full collection covers 28+ categories and 10,000+ pages. https://khilta.com/go 📚"
+
+---
+
+## HANDLING "I DON'T WANT ALL / ONLY SPECIFIC ONES"
+If someone says "all sheets are not required" or "I only want specific ones":
+- Acknowledge their need: "I understand — you might not need everything!"
+- Ask what they're looking for: "What kind of activities are you looking for? I can point you to the right ones 😊"
+- Currently we offer the complete bundle with everything included, but free samples let them try before deciding
+
+---
+
+## LANGUAGE
+- Reply in the same language the person uses when possible
+- For Hinglish (Hindi+English): reply in warm, simple English
+- For Spanish: reply in simple English with a warm greeting
+- For languages you can't understand well: SKIP
+
+---
+
+## WHAT TO SKIP (respond with exactly: SKIP)
+- Messages with attachments/images you can't see (you'll see [Attachment: image])
+- Messages that are just "thanks", "ok", "sure", "good night" with no question
+- Messages that are just business names, random text, or unclear
+- Compliments with no question
+- Messages in a language you can't understand at all
+- Anything where you're not confident you can give a genuinely useful reply
+
+When in doubt, SKIP — silence is always better than a wrong or useless reply.
\ No newline at end of file
diff --git a/vercel.json b/vercel.json
index d2d3dc4..655a4a2 100644
--- a/vercel.json
+++ b/vercel.json
@@ -2,11 +2,11 @@
   "crons": [
     {
       "path": "/api/cron/jobs",
-      "schedule": "* * * * *"
+      "schedule": "0 0 * * *"
     },
-{
+    {
       "path": "/api/cron/sequences",
-      "schedule": "* * * * *"
+      "schedule": "0 0 * * *"
     }
   ]
 }