@conversionpros/aiva 1.0.0

package/follow-up-handler.js

@@ -0,0 +1,606 @@
+// ── Follow-Up Handler ────────────────────────────────────
+// Scans for dead conversations and uses AI to decide follow-ups
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+const { db, stmts } = require('./router-db');
+
+const CONFIG_PATH = path.join(process.env.HOME, '.openclaw', 'openclaw.json');
+
+// ── Sent-By Reintroduction Logic (shared) ────────────────
+const { addReintroIfNeeded } = require('./router-utils');
+
+function getOpenClawPassword() {
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    return config?.gateway?.auth?.password || '';
+  } catch { return ''; }
+}
+
+function getSetting(key) {
+  const row = stmts.getSetting.get(key);
+  return row ? row.value : '';
+}
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [FOLLOW-UP] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [FOLLOW-UP] ${msg}`);
+}
+
+function isBusinessHours() {
+  // Robust PST/PDT calculation using Intl.DateTimeFormat for reliable timezone parts
+  const now = new Date();
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: 'America/Los_Angeles',
+    hour: 'numeric', hour12: false,
+    weekday: 'short',
+    year: 'numeric', month: 'numeric', day: 'numeric'
+  }).formatToParts(now);
+  
+  const get = (type) => parts.find(p => p.type === type)?.value;
+  const hour = parseInt(get('hour'), 10);  // 0-23 in America/Los_Angeles
+  const weekday = get('weekday');          // "Sun", "Mon", etc.
+  
+  if (weekday === 'Sun') return false; // No Sundays
+  
+  const startHour = parseInt(getSetting('followUpStartHour')) || 8;
+  const endHour = parseInt(getSetting('followUpEndHour')) || 18;
+  
+  // Hard floor/ceiling: never outside 8-18 regardless of settings
+  const effectiveStart = Math.max(startHour, 8);
+  const effectiveEnd = Math.min(endHour, 18);
+  
+  return hour >= effectiveStart && hour < effectiveEnd;
+}
+
+function isErrorMessage(text) {
+  if (!text) return false;
+  const t = text.toLowerCase();
+  return /no response from openclaw|openclaw.*error|internal server error|ECONNREFUSED|agent.*timeout|session.*failed|tool.*error/i.test(t);
+}
+
+// Sanitize outbound messages — strip any mention of internal systems
+function sanitizeOutbound(text) {
+  if (!text) return text;
+  // If the message mentions OpenClaw at all, it's contaminated — reject it
+  if (/openclaw/i.test(text)) {
+    log('BLOCKED outbound message containing "OpenClaw"', { snippet: text.substring(0, 100) });
+    return null;
+  }
+  return text;
+}
+
+function sendIMessage(phone, text) {
+  if (isErrorMessage(text)) {
+    log('BLOCKED error message from reaching contact', { phone, text: text.substring(0, 80) });
+    return false;
+  }
+  try {
+    const tmpFile = `/tmp/imsg-fu-${Date.now()}.txt`;
+    fs.writeFileSync(tmpFile, text);
+    execSync(`imsg send --to "${phone}" --text "$(cat ${tmpFile})"`, { timeout: 15000, encoding: 'utf-8', shell: '/bin/bash' });
+    try { fs.unlinkSync(tmpFile); } catch(e) {}
+    log('iMessage sent', { phone, len: text.length });
+    return true;
+  } catch (err) {
+    log('iMessage send failed', { phone, error: err.message });
+    return false;
+  }
+}
+
+async function sendWhatsApp(phone, text) {
+  if (isErrorMessage(text)) {
+    log('BLOCKED error message from reaching contact (WA)', { phone, text: text.substring(0, 80) });
+    return false;
+  }
+  try {
+    const waListener = require('./wa-listener');
+    const result = await waListener.sendMessage(phone, text);
+    if (result.success) {
+      log('WhatsApp sent', { phone, len: text.length });
+      return true;
+    } else {
+      log('WhatsApp send failed', { phone, error: result.error });
+      return false;
+    }
+  } catch (err) {
+    log('WhatsApp send error', { phone, error: err.message });
+    return false;
+  }
+}
+
+function parseTimeDelay(delayStr) {
+  // Returns a datetime string for next_follow_up_at
+  const now = new Date();
+  
+  if (!delayStr || delayStr === 'never') return null;
+  
+  const hourMatch = delayStr.match(/(\d+)\s*hour/i);
+  if (hourMatch) {
+    const ms = parseInt(hourMatch[1]) * 3600000;
+    return new Date(now.getTime() + ms).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+  }
+  
+  const dayMatch = delayStr.match(/(\d+)\s*day/i);
+  if (dayMatch) {
+    const ms = parseInt(dayMatch[1]) * 86400000;
+    return new Date(now.getTime() + ms).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+  }
+  
+  if (/tomorrow\s*morning/i.test(delayStr)) {
+    // Calculate tomorrow 9 AM in America/Los_Angeles properly
+    // Get current LA date parts
+    const laParts = new Intl.DateTimeFormat('en-US', {
+      timeZone: 'America/Los_Angeles',
+      year: 'numeric', month: '2-digit', day: '2-digit'
+    }).formatToParts(now);
+    const laGet = (t) => laParts.find(p => p.type === t)?.value;
+    const laYear = parseInt(laGet('year'));
+    const laMonth = parseInt(laGet('month')) - 1;
+    const laDay = parseInt(laGet('day'));
+    // Create tomorrow 9 AM in LA by brute-force: scan UTC hours to find when LA shows 9 AM tomorrow
+    const tomorrowDay = laDay + 1;
+    // Start from a rough UTC guess (tomorrow 17:00 UTC ≈ 9 AM PST) and adjust
+    let target = new Date(Date.UTC(laYear, laMonth, tomorrowDay, 17, 0, 0));
+    // Verify and adjust: get the LA hour for this UTC time
+    const checkHour = (d) => parseInt(new Intl.DateTimeFormat('en-US', { timeZone: 'America/Los_Angeles', hour: 'numeric', hour12: false }).format(d));
+    const checkDay = (d) => parseInt(new Intl.DateTimeFormat('en-US', { timeZone: 'America/Los_Angeles', day: 'numeric' }).format(d));
+    // Adjust until we hit 9 AM on the right day
+    for (let adj = -3; adj <= 3; adj++) {
+      const candidate = new Date(target.getTime() + adj * 3600000);
+      if (checkHour(candidate) === 9 && checkDay(candidate) === tomorrowDay) {
+        target = candidate;
+        break;
+      }
+    }
+    return target.toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+  }
+  
+  // Default: 4 hours
+  return new Date(now.getTime() + 4 * 3600000).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+}
+
+function getAnthropicApiKey() {
+  if (process.env.ANTHROPIC_API_KEY) return process.env.ANTHROPIC_API_KEY;
+  // Read from openclaw's auth config
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    // Try to extract from the auth token (OpenClaw uses this for its proxy)
+    const authToken = cfg?.auth?.apiKeys?.[0] || cfg?.gateway?.auth?.apiKeys?.[0];
+    if (authToken) return authToken;
+  } catch(e) {}
+  // Fallback: the known key for this installation
+  return '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';
+}
+
+async function callXAIDirect(systemPrompt, userMessage) {
+  const apiKey = 'xai-Gn37fuJg5ty4gvWFG2rbth34AxNORUKH8r4vTXQDtjwMGUqKZ7nYy8u2YStosGUCVBEg7VMHSqQZcKS4';
+  try {
+    const resp = await fetch('https://api.x.ai/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+      body: JSON.stringify({ model: 'grok-4-1-fast-non-reasoning', max_tokens: 500, messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }] }),
+      signal: AbortSignal.timeout(30000)
+    });
+    if (!resp.ok) { log('xAI API failed', { status: resp.status }); return null; }
+    const data = await resp.json();
+    return data.choices?.[0]?.message?.content?.trim() || null;
+  } catch(e) { log('xAI API error', { error: e.message }); return null; }
+}
+
+async function callOpenClawProxy(systemPrompt, userMessage) {
+  const password = getOpenClawPassword();
+  if (!password) return null;
+  try {
+    const resp = await fetch('http://127.0.0.1:18789/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${password}` },
+      body: JSON.stringify({ model: 'claude-sonnet-4-5', max_tokens: 500, messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }] }),
+      signal: AbortSignal.timeout(60000)
+    });
+    if (!resp.ok) { const errText = await resp.text(); log('Proxy HTTP error', { status: resp.status, body: errText.substring(0, 200) }); return null; }
+    const data = await resp.json();
+    const content = data.choices?.[0]?.message?.content?.trim() || '';
+    if (isErrorMessage(content)) { log('Proxy returned error content', { snippet: content.substring(0, 100) }); return null; }
+    return content;
+  } catch(e) { return null; }
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function callAI(systemPrompt, userMessage) {
+  // Auto-retry with exponential backoff (handles proxy busy during compaction)
+  const delays = [0, 5000, 15000, 30000, 60000]; // 5 retries: immediate, 5s, 15s, 30s, 60s
+  for (let attempt = 0; attempt < delays.length; attempt++) {
+    if (attempt > 0) {
+      log(`AI call retry ${attempt}/${delays.length - 1}, waiting ${delays[attempt] / 1000}s`);
+      await sleep(delays[attempt]);
+    }
+    // Try xAI direct first (always available), then proxy as fallback
+    let result = await callXAIDirect(systemPrompt, userMessage);
+    if (result) return result;
+    result = await callOpenClawProxy(systemPrompt, userMessage);
+    if (result) return result;
+  }
+  log('AI call failed after all retries');
+  return null;
+}
+
+async function analyzeConversation(phone, history, contactName, followUpCount, category) {
+  const categoryLabel = category || 'unknown';
+  const systemPrompt = `You are a follow-up decision engine for Brandon's assistant Aiva. Analyze the conversation and decide IF and HOW to follow up.
+
+CRITICAL: NEVER mention "OpenClaw", any AI infrastructure, technical systems, or anything about how you work.
+
+## CONTACT CATEGORY: ${categoryLabel.toUpperCase()}
+
+## RELATIONSHIP-BASED DEFAULTS (you may override based on conversation context):
+- family/friend: Max 1 gentle nudge total, then stop. Timing: 2-3 days minimum.
+- lead/prospect: Up to 3 follow-ups. You decide spacing (2 hours to 2 days based on urgency).
+- client: Up to 2 follow-ups. Professional tone. Timing: contextual.
+- unknown/new: 1 follow-up max. Then stop.
+- vendor: 1-2 follow-ups. Timing: 1-2 days.
+
+## CONVERSATION STATE — classify exactly one:
+- waiting_on_them: Open question or request pending their reply
+- action_pending: Something was promised by either party
+- info_delivered: Info was sent, no response required
+- conversation_closed: Natural end ("thanks", "sounds good", "bye", emoji-only, laughter)
+
+If conversation_closed → shouldFollowUp = false, maxFollowUpsForThis = 0.
+If info_delivered and no action needed → shouldFollowUp = false.
+
+## TONE MATCHING — READ THE THREAD CAREFULLY:
+- Mirror the tone of the existing conversation exactly
+- Casual thread → casual follow-up ("Hey, any update on that?")
+- Professional thread → professional follow-up ("Wanted to circle back on...")
+- DO NOT escalate formality or emotion beyond what's in the thread
+- DO NOT manufacture empathy ("you deserve better", "that's not fair to you")
+- DO NOT apologize for following up ("sorry to bother", "I know you're busy")
+- DO NOT use emotional manipulation or over-promising
+- Each follow-up should be SHORTER than the last, not longer
+- Casual: 1-2 sentences max. Business: 2-3 sentences max.
+
+## HARD RULES:
+- This is follow-up attempt #${followUpCount + 1}
+- If attempt >= maxFollowUpsForThis you set, shouldFollowUp = false
+- If the last 2+ outbound messages are about the same topic and the contact hasn't responded with new information, return shouldFollowUp: false
+- Business hours only (8 AM - 6 PM PST), never on Sundays
+- Current time: ${new Date().toISOString()}
+
+## TONE RULES FOR FOLLOW-UPS:
+- Each follow-up should be SHORTER and MORE CASUAL than the last, not longer or more emotional
+- NEVER apologize for following up ("sorry to bother", "I feel bad", "I'm embarrassed")
+- NEVER escalate emotional language or make dramatic promises
+- If you've already followed up once, the next one should be ultra-brief (e.g., "Hey, just circling back on this")
+- If you've followed up twice with no reply, STOP (shouldFollowUp = false)
+- A human would send ONE brief nudge and then wait. Be that human.
+
+Respond in JSON ONLY:
+{
+  "shouldFollowUp": true/false,
+  "maxFollowUpsForThis": 0-3,
+  "nextFollowUpIn": "4 hours" | "tomorrow morning" | "2 days" | "never",
+  "suggestedMessage": "Short, natural follow-up text",
+  "reasoning": "Brief explanation",
+  "conversationState": "waiting_on_them" | "conversation_closed" | "info_delivered" | "action_pending",
+  "topic": "brief topic label (e.g., 'plane tickets', 'meeting schedule')"
+}`;
+  const userMsg = `Contact: ${contactName} (${phone})\nContact category: ${categoryLabel}\nFollow-up attempt: #${followUpCount + 1}\n\nConversation:\n${history}\n\nShould we follow up?`;
+
+  const content = await callAI(systemPrompt, userMsg);
+  if (!content) return null;
+  try {
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    return JSON.parse(jsonMatch[0]);
+  } catch(e) { return null; }
+}
+
+function fetchConversationHistory(phone, limit = 25) {
+  try {
+    const output = execSync(`imsg chats 2>/dev/null | grep "${phone}"`, { timeout: 5000, encoding: 'utf-8' }).trim();
+    const chatIdMatch = output.match(/^\[(\d+)\]/);
+    if (!chatIdMatch) return null;
+    
+    const chatId = chatIdMatch[1];
+    const historyRaw = execSync(`imsg history --chat-id ${chatId} --limit ${limit}`, { timeout: 10000, encoding: 'utf-8' }).trim();
+    if (!historyRaw) return null;
+
+    const lines = historyRaw.split('\n').filter(l => l.trim());
+    const messages = lines.map(line => {
+      const match = line.match(/^(\S+)\s+\[(sent|recv)\]\s+\S+:\s+(.*)$/);
+      if (!match) return null;
+      return { ts: match[1], direction: match[2], text: match[3] };
+    }).filter(Boolean);
+
+    return messages.reverse().map(m => {
+      const sender = m.direction === 'sent' ? 'Brandon/Aiva' : 'Them';
+      return `[${new Date(m.ts).toLocaleString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true })}] ${sender}: ${m.text}`;
+    }).join('\n');
+  } catch {
+    return null;
+  }
+}
+
+async function checkForDeadConversations() {
+  log('Scanning for dead conversations...');
+  
+  // Get conversations where our last message was outbound and at least 1 hour ago
+  const deadConvos = db.prepare(`
+    SELECT m.phone, m.message_preview, m.timestamp,
+      COALESCE(NULLIF(cr.name, ''), NULLIF(cr.name, 'Unknown'), m.phone) as contact_name,
+      COALESCE(cr.source, 'imessage') as channel
+    FROM message_log m
+    INNER JOIN (
+      SELECT phone, MAX(id) as max_id FROM message_log
+      WHERE forwarded_to != 'group' AND forwarded_to NOT LIKE '%group%'
+      GROUP BY phone
+    ) latest ON m.phone = latest.phone AND m.id = latest.max_id
+    LEFT JOIN contact_rules cr ON cr.phone = m.phone
+    LEFT JOIN follow_up_tracker ft ON ft.phone = m.phone
+    WHERE m.direction = 'outbound'
+      AND m.timestamp <= datetime('now', '-1 hour')
+      AND (ft.phone IS NULL OR ft.status NOT IN ('cold', 'completed', 'paused'))
+      AND m.phone != ?
+  `).all(getSetting('masterPhone') || '+15099794110');
+  
+  log('Dead conversations found', { count: deadConvos.length });
+  
+  for (const conv of deadConvos) {
+    const existing = stmts.getFollowUpByPhone.get(conv.phone);
+    if (existing) continue; // Already tracked
+    
+    // Create a new tracker entry
+    const now = new Date().toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+    stmts.upsertFollowUp.run(
+      conv.phone,
+      conv.channel === 'whatsapp' ? 'whatsapp' : 'imessage',
+      conv.contact_name,
+      conv.message_preview || '',
+      conv.timestamp || now,
+      'active',
+      conv.timestamp || now
+    );
+    log('New follow-up tracker created', { phone: conv.phone, name: conv.contact_name });
+  }
+}
+
+async function processFollowUps() {
+  if (getSetting('followUpEnabled') !== 'true') {
+    log('Follow-ups disabled, skipping');
+    return;
+  }
+  
+  if (!isBusinessHours()) {
+    log('Outside business hours, skipping');
+    return;
+  }
+  
+  // First scan for new dead conversations
+  await checkForDeadConversations();
+  
+  // Then process active follow-ups that are due
+  const dueFollowUps = stmts.getActiveFollowUps.all();
+  log('Due follow-ups', { count: dueFollowUps.length });
+  
+  const maxDefault = parseInt(getSetting('followUpMaxDefault')) || 3;
+  
+  for (const fu of dueFollowUps) {
+    if (fu.opted_out) {
+      log('Skipping opted-out contact', { phone: fu.phone });
+      continue;
+    }
+    
+    // Safety ceiling — hard max before AI even runs (AI will typically cap lower)
+    const maxFollowUps = fu.max_follow_ups || maxDefault;
+    if (fu.follow_up_count >= Math.max(maxFollowUps, 3)) {
+      stmts.markFollowUpCold.run(fu.phone);
+      // Notify Brandon
+      const masterPhone = getSetting('masterPhone') || '+15099794110';
+      sendIMessage(masterPhone, `Follow-up limit reached for ${fu.contact_name} (${fu.phone}). Marked as cold after ${fu.follow_up_count} attempts. Last message: "${(fu.last_our_message || '').substring(0, 100)}"`);
+      log('Marked cold — max follow-ups reached', { phone: fu.phone, count: fu.follow_up_count });
+      continue;
+    }
+    
+    // Get conversation history
+    const history = fetchConversationHistory(fu.phone);
+    if (!history) {
+      log('No history found, skipping', { phone: fu.phone });
+      continue;
+    }
+    
+    // ── Daily follow-up cap (max 1 per contact per day) ──
+    const maxDailyFollowUps = parseInt(getSetting('maxDailyFollowUps')) || 1;
+    const recentFollowUps = stmts.countRecentFollowUps.get(fu.phone);
+    const followUpCountToday = recentFollowUps?.count || 0;
+    if (followUpCountToday >= maxDailyFollowUps) {
+      log('RATE LIMIT: daily follow-up cap reached, skipping', { phone: fu.phone, followUpCountToday, maxDailyFollowUps });
+      // Push next check to tomorrow
+      const tomorrow = new Date(Date.now() + 24 * 3600000).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+      stmts.incrementFollowUp.run(tomorrow, fu.phone);
+      continue;
+    }
+
+    // Hard silence check: if contact hasn't replied to our last 2+ messages, mark cold immediately
+    const historyLines = history.split('\n').filter(l => l.trim());
+    let consecutiveOurs = 0;
+    for (let i = historyLines.length - 1; i >= 0; i--) {
+      if (/Brandon\/Aiva:/.test(historyLines[i])) consecutiveOurs++;
+      else break;
+    }
+    if (consecutiveOurs >= 2) {
+      stmts.markFollowUpCold.run(fu.phone);
+      const masterPhone = getSetting('masterPhone') || '+15099794110';
+      sendIMessage(masterPhone, `Silence detected for ${fu.contact_name} (${fu.phone}) — ${consecutiveOurs} unanswered messages. Marked cold.`);
+      log('Hard silence cap — contact not replying, marked cold', { phone: fu.phone, consecutiveOurs });
+      continue;
+    }
+    
+    // Fetch contact category from contact_rules
+    const contactRule = db.prepare('SELECT category FROM contact_rules WHERE phone = ?').get(fu.phone);
+    const category = contactRule?.category || 'unknown';
+    
+    // AI analysis
+    const analysis = await analyzeConversation(fu.phone, history, fu.contact_name, fu.follow_up_count, category);
+    if (!analysis) {
+      log('AI analysis failed, skipping', { phone: fu.phone });
+      continue;
+    }
+    
+    // Use AI's max follow-ups instead of flat default
+    const aiMax = analysis.maxFollowUpsForThis ?? analysis.maxFollowUpsForThisConvo;
+    if (typeof aiMax === 'number' && aiMax >= 0 && fu.follow_up_count >= aiMax) {
+      stmts.markFollowUpCold.run(fu.phone);
+      log('AI max follow-ups reached', { phone: fu.phone, aiMax, count: fu.follow_up_count, relationship: analysis.relationshipType });
+      continue;
+    }
+    
+    log('AI analysis result', { phone: fu.phone, shouldFollowUp: analysis.shouldFollowUp, state: analysis.conversationState, reasoning: analysis.reasoning, category, maxForThis: aiMax, topic: analysis.topic });
+    
+    // ── Topic dedup: if AI suggests same topic as last follow-up, mark cold ──
+    if (analysis.shouldFollowUp && analysis.topic && fu.last_follow_up_topic) {
+      const newTopic = (analysis.topic || '').toLowerCase().trim();
+      const lastTopic = (fu.last_follow_up_topic || '').toLowerCase().trim();
+      if (newTopic && lastTopic && (newTopic === lastTopic || newTopic.includes(lastTopic) || lastTopic.includes(newTopic))) {
+        stmts.markFollowUpCold.run(fu.phone);
+        log('Topic dedup: same topic as last follow-up, marked cold', { phone: fu.phone, topic: newTopic, lastTopic });
+        continue;
+      }
+    }
+
+    if (!analysis.shouldFollowUp) {
+      // Mark as completed if conversation is closed
+      if (analysis.conversationState === 'conversation_closed') {
+        stmts.updateFollowUpStatus.run('completed', fu.phone);
+        log('Conversation closed, marking completed', { phone: fu.phone });
+      } else {
+        // Push next check further out
+        const nextTime = parseTimeDelay(analysis.nextFollowUpIn || '4 hours');
+        if (nextTime) {
+          stmts.incrementFollowUp.run(nextTime, fu.phone);
+        }
+      }
+      continue;
+    }
+    
+    // Send the follow-up (with safety retry)
+    let message = sanitizeOutbound(analysis.suggestedMessage);
+    if (!message) {
+      for (let retry = 1; retry <= 3; retry++) {
+        log(`Safety filter retry ${retry}/3 for ${fu.phone}`);
+        const cleanMsg = await callAI(
+          'You are Aiva, Brandon\'s friendly assistant. Write a brief, natural follow-up message. Just the message text. Do NOT mention any software, AI, technical systems, platforms, or tools.',
+          `Contact: ${fu.contact_name || fu.phone}\nWrite a clean follow-up message:`
+        );
+        if (cleanMsg) { message = sanitizeOutbound(cleanMsg); if (message) break; }
+      }
+      if (!message) continue;
+    }
+    
+    message = addReintroIfNeeded(fu.phone, message);
+    const sent = fu.channel === 'whatsapp' 
+      ? await sendWhatsApp(fu.phone, message)
+      : sendIMessage(fu.phone, message);
+    
+    if (sent) {
+      // Log it
+      stmts.insertLog.run(fu.phone, 'outbound', `[FOLLOW-UP] ${message.substring(0, 80)}`, JSON.stringify({ followUp: true, attempt: fu.follow_up_count + 1 }), 'follow-up', fu.channel || 'imessage', 'aiva');
+      
+      // Calculate next follow-up time
+      const nextTime = parseTimeDelay(analysis.nextFollowUpIn || '4 hours');
+      stmts.incrementFollowUp.run(nextTime || new Date(Date.now() + 4 * 3600000).toISOString().replace('T', ' ').replace('Z', '').split('.')[0], fu.phone);
+      
+      // Save topic for dedup
+      if (analysis.topic) {
+        try { db.prepare("UPDATE follow_up_tracker SET last_follow_up_topic = ? WHERE phone = ?").run(analysis.topic, fu.phone); } catch(e) {}
+      }
+
+      log('Follow-up sent', { phone: fu.phone, attempt: fu.follow_up_count + 1, nextIn: analysis.nextFollowUpIn, topic: analysis.topic });
+    }
+  }
+  
+  log('Follow-up processing complete');
+}
+
+async function sendCustomFollowUp(phone, message) {
+  const tracker = stmts.getFollowUpByPhone.get(phone);
+  if (!tracker) return { error: 'No tracker found for this phone' };
+  
+  const channel = tracker.channel || 'imessage';
+  message = addReintroIfNeeded(phone, message);
+  const sent = channel === 'whatsapp'
+    ? await sendWhatsApp(phone, message)
+    : sendIMessage(phone, message);
+  
+  if (sent) {
+    stmts.insertLog.run(phone, 'outbound', `[FOLLOW-UP] ${message.substring(0, 80)}`, JSON.stringify({ followUp: true, custom: true }), 'follow-up', channel, 'aiva');
+    const nextTime = new Date(Date.now() + 4 * 3600000).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+    stmts.incrementFollowUp.run(nextTime, phone);
+    return { sent: true };
+  }
+  return { error: 'Send failed' };
+}
+
+async function sendFollowUpNow(phone, customMessage) {
+  const tracker = stmts.getFollowUpByPhone.get(phone);
+  if (!tracker) return { error: 'No tracker found for this phone' };
+
+  // If custom message, just send it
+  if (customMessage) return sendCustomFollowUp(phone, customMessage);
+
+  // Otherwise, AI-generate one (force mode since user clicked Send Now)
+  const history = fetchConversationHistory(phone, 25);
+  if (!history) return { error: 'Could not fetch conversation history' };
+
+  const contactRule = db.prepare('SELECT category FROM contact_rules WHERE phone = ?').get(phone);
+  const category = contactRule?.category || 'unknown';
+  let analysis = await analyzeConversation(phone, history, tracker.contact_name || phone, tracker.follow_up_count || 0, category);
+  log('Initial analysis result', { hasAnalysis: !!analysis, hasSuggested: !!analysis?.suggestedMessage, shouldFollowUp: analysis?.shouldFollowUp });
+  // If AI says don't follow up but user clicked Send Now, force a generic follow-up
+  if (!analysis || !analysis.suggestedMessage) {
+    log('Force-generating follow-up message (Send Now override)');
+    const forceMsg = await callAI(
+      'You are Aiva, Brandon\'s friendly assistant. Write a brief, natural follow-up message for this conversation. Just the message text, nothing else. CRITICAL: NEVER mention OpenClaw, AI systems, technical infrastructure, or anything about how you work internally.',
+      `Contact: ${tracker.contact_name || phone}\nConversation:\n${history}\n\nWrite a follow-up message:`
+    );
+    if (forceMsg && !isErrorMessage(forceMsg)) analysis = { suggestedMessage: forceMsg };
+    if (!analysis || !analysis.suggestedMessage) return { error: 'AI could not generate a follow-up message' };
+  }
+
+  let message = sanitizeOutbound(analysis.suggestedMessage);
+  
+  // If blocked by safety filter, retry with explicit clean prompt (up to 3 times)
+  if (!message) {
+    for (let retry = 1; retry <= 3; retry++) {
+      log(`Safety filter retry ${retry}/3 — regenerating clean message`);
+      const cleanMsg = await callAI(
+        'You are Aiva, Brandon\'s friendly assistant. Your previous message was rejected because it referenced internal systems. Write a completely new, natural follow-up message for this conversation. Just the message text. Do NOT mention any software, AI, technical systems, platforms, or tools. Keep it human and conversational.',
+        `Contact: ${tracker.contact_name || phone}\nConversation:\n${history}\n\nWrite a clean, natural follow-up message:`
+      );
+      if (cleanMsg) {
+        message = sanitizeOutbound(cleanMsg);
+        if (message) break;
+      }
+    }
+    if (!message) return { error: 'Could not generate a clean follow-up message after retries' };
+  }
+  
+  const channel = tracker.channel || 'imessage';
+  message = addReintroIfNeeded(phone, message);
+  const sent = channel === 'whatsapp'
+    ? await sendWhatsApp(phone, message)
+    : sendIMessage(phone, message);
+
+  if (sent) {
+    stmts.insertLog.run(phone, 'outbound', `[FOLLOW-UP] ${message.substring(0, 80)}`, JSON.stringify({ followUp: true, sendNow: true, attempt: tracker.follow_up_count + 1 }), 'follow-up', channel, 'aiva');
+    const nextTime = new Date(Date.now() + 4 * 3600000).toISOString().replace('T', ' ').replace('Z', '').split('.')[0];
+    stmts.incrementFollowUp.run(nextTime, phone);
+    log('Send-now follow-up sent', { phone, attempt: tracker.follow_up_count + 1 });
+    return { sent: true, message };
+  }
+  return { error: 'Send failed' };
+}
+
+module.exports = { processFollowUps, checkForDeadConversations, analyzeConversation, sendCustomFollowUp, sendFollowUpNow };