Write and Send Email Sequences with AI

You write one email in a {sequence} email sequence for [Company], which helps [type of customer] [get the outcome].

Write email number {email_number} of {email_total} to {first_name} at {company}.

What we know about them: {signal}
Proof you may use, and nothing else: [one customer result you can back up, with the customer's permission]
Sender: [Your name], [Your role], [Company]

Rules:
1. Use only the facts above. If a detail is missing, leave it out. Never invent a number, a customer or a quote.
2. Keep the body to 120 words or fewer for cold and sales email, and 180 or fewer for nurture and welcome email.
3. Ask for one thing only, and make it the last sentence before the sign-off.
4. Write in plain text. No images, no bold, and no links in the first cold email.
5. Do not use these phrases: "I hope this email finds you well", "just checking in", "touching base", "quick question", "circle back".
6. If the sequence is cold, end with this line exactly: If this isn't relevant, reply "no" and I won't email again.
7. If the sequence is nurture or welcome, end with %%UNSUBSCRIBE_FOOTER%% on its own line.
8. For email 2 onwards, write it as a follow-up in the same thread. Add something new, and don't repeat the first email.

Return exactly this, with nothing before or after:
SUBJECT: 
BODY:

// gate.js: paste into an n8n Code node right after "Collect draft".
// Mode: Run Once for All Items. Each item needs json.output (the model's text),
// json.sequence, json.email_number and json.email_total.
// Each item comes out with pass, reasons, subject, body, body_to_send (footer filled in),
// gap_days (days to wait after this email is sent), next_send_date and is_last.
// Edit the four settings below before the first run.

// 1. Your footer for nurture and welcome email: postal address and unsubscribe link.
const FOOTER = "[Company], [postal address]\nUnsubscribe: [unsubscribe link]";
// 2. Word limits: the body may have this many words or fewer.
//    If you change these, change rule 2 in the drafting prompt to match.
const LIMITS = { cold: 120, sales: 120, nurture: 180, welcome: 180 };
const SUBJECT_MAX_WORDS = 8;
// 3. Days to wait after each email before the next one. One number per gap,
//    so a sequence has one more email than it has gaps.
//    Matches the templates: cold days 1, 4, 8, 14; sales 0, 2, 5, 9;
//    nurture 0, 3, 7, 14, 21; welcome 0, 1, 3, 7, 12.
const GAPS = { cold: [3, 4, 6], sales: [2, 3, 4], nurture: [3, 4, 7, 7], welcome: [1, 2, 4, 5] };
// 4. Phrases no draft may use.
const BANNED = ["i hope this email finds you well", "just checking in", "touching base", "quick question", "circle back"];

const FOOTER_TOKEN = "%%UNSUBSCRIBE_FOOTER%%";
const COLD_OPT_OUT = 'reply "no" and i won\'t email again';

function normalize(s) {
  return String(s || "")
    .replace(/\r\n?/g, "\n")
    .replace(/[\u201C\u201D]/g, '"').replace(/[\u2018\u2019]/g, "'")
    .replace(/\*\*(SUBJECT|BODY):\*\*/gi, "$1:")
    .trim();
}

function addDays(iso, n) {
  const d = new Date(iso + "T00:00:00Z");
  d.setUTCDate(d.getUTCDate() + n);
  return d.toISOString().slice(0, 10);
}

function countWords(s) { return String(s).split(/\s+/).filter(Boolean).length; }

function check(raw, sequence, emailNumber, emailTotal, today) {
  const reasons = [];
  const seq = String(sequence || "").trim().toLowerCase();
  const num = parseInt(emailNumber, 10) || 1;
  const gaps = GAPS[seq] || [];
  const planned = gaps.length + 1;
  const total = parseInt(emailTotal, 10) || planned;
  const empty = { subject: "", body_to_send: "", gap_days: "", next_send_date: "", is_last: false };

  if (!LIMITS[seq]) reasons.push(`Unknown sequence "${sequence}"`);
  else if (total !== planned) reasons.push(`email_total is ${total} but GAPS in gate.js plans ${planned} ${seq} emails: make them match`);
  if (num > total) reasons.push(`email_number ${num} is past email_total ${total}: the sequence should already be done`);

  const text = normalize(raw);
  const m = text.match(/^SUBJECT:[ \t]*(.+?)\n+BODY:[ \t]*\n?([\s\S]+)$/i);
  if (!m) return { pass: false, reasons: ["Output is not in the SUBJECT / BODY format", ...reasons], body: text, ...empty };
  const subject = m[1].trim();
  const body = m[2].trim();
  const lower = body.toLowerCase();

  if (/\[[^\]]+\]/.test(subject + "\n" + body)) reasons.push("A [square bracket] placeholder is still in the draft");
  if (/\{\{?[^}]*\}?\}/.test(subject + "\n" + body)) reasons.push("A {field} was not filled in");
  const words = countWords(body.replace(FOOTER_TOKEN, ""));
  if (LIMITS[seq] && words > LIMITS[seq]) reasons.push(`Body is ${words} words, limit is ${LIMITS[seq]} or fewer`);
  if (countWords(subject) > SUBJECT_MAX_WORDS) reasons.push(`Subject is ${countWords(subject)} words, limit is ${SUBJECT_MAX_WORDS} or fewer`);
  for (const p of BANNED) if ((subject + " " + lower).toLowerCase().includes(p)) reasons.push(`Banned phrase: "${p}"`);
  if (seq === "cold" && !lower.includes(COLD_OPT_OUT)) reasons.push("Cold email is missing the opt-out line");
  if (seq === "cold" && num === 1 && /https?:\/\/|www\./i.test(body)) reasons.push("First cold email contains a link");
  const marketing = seq === "nurture" || seq === "welcome";
  if (marketing && !body.includes(FOOTER_TOKEN)) reasons.push("Marketing email is missing the footer token");
  if (marketing && /\[[^\]]+\]/.test(FOOTER)) reasons.push("FOOTER in gate.js still has [square brackets]: add your address and unsubscribe link");

  const isLast = num >= total;
  // No date when the sequence is unknown or the gaps run out: the reasons above say why.
  const gap = isLast || typeof gaps[num - 1] !== "number" ? "" : gaps[num - 1];
  const base = today || new Date().toISOString().slice(0, 10);
  return {
    pass: reasons.length === 0, reasons, subject, body,
    body_to_send: body.replace(FOOTER_TOKEN, marketing ? FOOTER : "").trim(),
    gap_days: gap,
    next_send_date: gap === "" ? "" : addDays(base, gap),
    is_last: isLast,
  };
}

if (typeof module !== "undefined" && module.exports) module.exports = { check, normalize, addDays };
if (typeof $input !== "undefined") {
  return $input.all().map(item => ({
    json: { ...item.json, ...check(item.json.output, item.json.sequence, item.json.email_number, item.json.email_total) },
  }));
}

// stop-check.js: paste into an n8n Code node before drafting a follow-up.
// Mode: Run Once for Each Item. The item needs:
//   json.email     the contact's address
//   json.messages  the messages in the contact's thread (Gmail "Get a thread")
//   json.bounces   recent bounce notices from the inbox (Gmail "Get many messages"
//                  with the search: from:(mailer-daemon OR postmaster) newer_than:30d)
// Bounces are checked in both places, because a bounce notice does not always
// land in the original thread.
// Output: stop (true/false) and why ("replied", "bounced" or "").

function fromOf(msg) {
  if (msg.From) return String(msg.From);
  if (msg.from) return typeof msg.from === "string" ? msg.from : JSON.stringify(msg.from);
  const h = (msg.payload && msg.payload.headers) || msg.headers || [];
  const f = h.find(x => String(x.name).toLowerCase() === "from");
  return f ? String(f.value) : "";
}

function textOf(msg) {
  return [msg.snippet, msg.text, msg.textPlain, msg.html, msg.textAsHtml, msg.Subject, msg.subject]
    .filter(Boolean).map(String).join("\n");
}

const BOUNCE_SENDER = /mailer-daemon|postmaster/i;

function shouldStop(contactEmail, messages, bounces) {
  const who = String(contactEmail || "").trim().toLowerCase();
  for (const m of messages || []) {
    const from = fromOf(m).toLowerCase();
    if (BOUNCE_SENDER.test(from)) return { stop: true, why: "bounced" };
    if (who && from.includes(who)) return { stop: true, why: "replied" };
  }
  // A bounce notice names the failed address in its text, so match the contact's address.
  for (const b of bounces || []) {
    if (!BOUNCE_SENDER.test(fromOf(b))) continue;
    if (who && textOf(b).toLowerCase().includes(who)) return { stop: true, why: "bounced" };
  }
  return { stop: false, why: "" };
}

if (typeof module !== "undefined" && module.exports) module.exports = { shouldStop };
if (typeof $json !== "undefined") {
  return { json: { ...$json, ...shouldStop($json.email, $json.messages, $json.bounces) } };
}

// review-check.js: paste into an n8n Code node for rows whose status is "drafted".
// Mode: Run Once for Each Item. The item needs json.messages (the draft's thread,
// from Gmail "Get a thread" with Simplify off, so each message keeps labelIds and
// internalDate), json.gap_days and json.is_last from the sheet row.
// When someone has sent the draft, it returns sent: true, the date it went out,
// and the next send date counted from that day. Update the row with these.

function addDays(iso, n) {
  const d = new Date(iso + "T00:00:00Z");
  d.setUTCDate(d.getUTCDate() + n);
  return d.toISOString().slice(0, 10);
}

function reviewCheck(messages, gapDays, isLast) {
  const sent = (messages || []).filter(m => {
    const labels = m.labelIds || m.labels || [];
    return labels.includes("SENT") && !labels.includes("DRAFT");
  });
  if (!sent.length) return { sent: false, sent_date: "", next_send_date: "" };
  const last = sent.reduce((a, b) => (Number(b.internalDate) > Number(a.internalDate) ? b : a));
  const sentDate = new Date(Number(last.internalDate)).toISOString().slice(0, 10);
  const done = isLast === true || String(isLast).toLowerCase() === "true";
  const gap = parseInt(gapDays, 10);
  return {
    sent: true,
    sent_date: sentDate,
    next_send_date: done || isNaN(gap) ? "" : addDays(sentDate, gap),
    new_status: done ? "done" : "sent",
  };
}

if (typeof module !== "undefined" && module.exports) module.exports = { reviewCheck };
if (typeof $json !== "undefined") {
  return { json: { ...$json, ...reviewCheck($json.messages, $json.gap_days, $json.is_last) } };
}