@conversionpros/aiva 1.0.0

package/router-v2/outbound-sender.js

@@ -0,0 +1,160 @@
+// ── Outbound Sender - Unified Send Across Channels ───────
+'use strict';
+
+const { getStmts, getSetting } = require('./db');
+const { sanitizeOutbound } = require('./utils/sanitize');
+const { normalizePhone } = require('./utils/phone');
+const { needsReintro } = require('./contact-manager');
+
+const REINTRO_PHRASES = [
+  "Hey, Aiva here - ",
+  "Hey, it's Aiva - ",
+  "Hey, Aiva here. ",
+  "It's Aiva - ",
+];
+
+// Channel adapters - lazily loaded
+let _imessageAdapter = null;
+let _whatsappAdapter = null;
+let _quoAdapter = null;
+
+function getAdapter(channel) {
+  switch (channel) {
+    case 'imessage':
+      if (!_imessageAdapter) _imessageAdapter = require('./adapters/imessage');
+      return _imessageAdapter;
+    case 'whatsapp':
+      if (!_whatsappAdapter) _whatsappAdapter = require('./adapters/whatsapp');
+      return _whatsappAdapter;
+    case 'quo':
+      if (!_quoAdapter) _quoAdapter = require('./adapters/quo');
+      return _quoAdapter;
+    default:
+      return null;
+  }
+}
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [SENDER] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [SENDER] ${msg}`);
+}
+
+/**
+ * Send a message to a contact through the appropriate channel.
+ * Handles sanitization, reintroduction, rate limiting, and logging.
+ * @param {Object} options
+ * @param {string} options.phone - E.164 phone
+ * @param {string} options.text - Message text
+ * @param {string} [options.channel='imessage'] - Channel to send through
+ * @param {string} [options.sentBy='aiva'] - Who is sending (aiva, brandon, follow-up)
+ * @param {string} [options.stateAtTime=''] - Conversation state label
+ * @param {boolean} [options.skipSanitize=false] - Skip sanitization (for pre-sanitized messages)
+ * @returns {Promise<{sent: boolean, blocked: boolean, reason: string|null}>}
+ */
+async function sendMessage({ phone, text, channel = 'imessage', sentBy = 'aiva', stateAtTime = '', skipSanitize = false }) {
+  const normalized = normalizePhone(phone);
+  const masterPhone = getSetting('masterPhone');
+  const isMaster = normalized === masterPhone;
+
+  // Rate limiting (skip for master phone)
+  if (!isMaster && sentBy === 'aiva') {
+    const stmts = getStmts();
+    const recentCount = stmts.countRecentOutbound.get(normalized, '1');
+    if (recentCount && recentCount.count >= 10) {
+      log('RATE LIMITED', { phone: normalized, count: recentCount.count });
+      return { sent: false, blocked: true, reason: 'rate_limit' };
+    }
+  }
+
+  // Sanitize
+  let finalText = text;
+  if (!skipSanitize) {
+    const sanitized = sanitizeOutbound(text, isMaster);
+    if (sanitized.blocked) {
+      log(`BLOCKED: ${sanitized.reason}`, { phone: normalized, preview: text.substring(0, 100) });
+      return { sent: false, blocked: true, reason: sanitized.reason };
+    }
+    finalText = sanitized.text;
+  }
+
+  if (!finalText) {
+    return { sent: false, blocked: true, reason: 'empty_after_sanitize' };
+  }
+
+  // Away message prepend
+  const awayMessage = getSetting('awayMessage');
+  if (awayMessage && sentBy === 'aiva') {
+    finalText = `${awayMessage}\n\n${finalText}`;
+  }
+
+  // Reintroduction logic
+  if (sentBy === 'aiva' && needsReintro(normalized)) {
+    const phrase = REINTRO_PHRASES[Math.floor(Math.random() * REINTRO_PHRASES.length)];
+    finalText = phrase + finalText;
+  }
+
+  // DRY RUN MODE: Log intended response instead of sending (Option A - parallel testing)
+  const dryRun = getSetting('v2DryRun') !== 'false'; // Default: dry run ON
+  if (dryRun) {
+    log('DRY RUN - WOULD SEND', { phone: normalized, channel, sentBy, len: finalText.length, text: finalText.substring(0, 300) });
+    // Still log to message_log so we can compare v1 vs v2 responses
+    const stmts = getStmts();
+    stmts.insertMessage.run(
+      normalized, channel, 'outbound', `[V2-DRY-RUN] ${finalText}`,
+      '[]', sentBy, stateAtTime,
+    );
+    return { sent: true, blocked: false, reason: 'dry_run' };
+  }
+
+  // Send via adapter
+  const adapter = getAdapter(channel);
+  if (!adapter) {
+    log('No adapter for channel', { channel, phone: normalized });
+    return { sent: false, blocked: false, reason: `no_adapter_${channel}` };
+  }
+
+  try {
+    const result = await adapter.send(normalized, finalText);
+    if (result.success) {
+      // Log to message_log
+      const stmts = getStmts();
+      stmts.insertMessage.run(
+        normalized, channel, 'outbound', finalText,
+        '[]', sentBy, stateAtTime,
+      );
+      log('Sent', { phone: normalized, channel, len: finalText.length });
+      return { sent: true, blocked: false, reason: null };
+    } else {
+      log('Send failed', { phone: normalized, channel, error: result.error });
+      return { sent: false, blocked: false, reason: result.error || 'send_failed' };
+    }
+  } catch (err) {
+    log('Send error', { phone: normalized, channel, error: err.message });
+    return { sent: false, blocked: false, reason: err.message };
+  }
+}
+
+/**
+ * Send an escalation timeout notification to Brandon via iMessage.
+ * @param {string} contactName - Who the escalation was about
+ * @param {string} contactPhone - Contact's phone
+ * @param {string} question - What the contact asked
+ * @returns {Promise<boolean>}
+ */
+async function sendEscalationTimeout(contactName, contactPhone, question) {
+  const notifyPhone = getSetting('escalationNotifyPhone') || '+15099794110';
+  const text = `Escalation timed out (2 strikes)\nFrom: ${contactName} (${contactPhone})\nAsked: ${question.substring(0, 200)}`;
+
+  const adapter = getAdapter('imessage');
+  if (!adapter) return false;
+
+  try {
+    const result = await adapter.send(notifyPhone, text);
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { sendMessage, sendEscalationTimeout, REINTRO_PHRASES };

package/router-v2/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "aiva-router-v2",
+  "version": "2.0.0",
+  "description": "AIVA Message Router v2 - autonomous contact messaging with escalation, learning, and scheduling",
+  "private": true,
+  "main": "index.js",
+  "dependencies": {
+    "better-sqlite3": "^11.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/router-v2/permission-gate.js

@@ -0,0 +1,86 @@
+// ── Permission Gate - Scope Checking ─────────────────────
+// Gates actions, not speech. If a contact lacks scope for an action,
+// the router escalates silently - never tells the contact they lack permission.
+'use strict';
+
+const { hasScope } = require('./contact-manager');
+
+// Map tool calls to required scopes
+const TOOL_SCOPE_MAP = {
+  schedule_appointment: 'calendar.book',
+  check_availability: 'calendar.view',
+  reschedule_appointment: 'calendar.modify',
+  cancel_appointment: 'calendar.modify',
+  search_knowledge_base: null, // no scope needed
+  escalate: null, // always allowed
+  send_message: 'messages.send',
+  create_task: 'tasks.create',
+  create_reminder: 'reminders.create',
+  send_file: 'files.send',
+};
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [PERMISSION] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [PERMISSION] ${msg}`);
+}
+
+/**
+ * Check if a contact has permission for a specific tool call.
+ * Returns { allowed: boolean, requiredScope: string|null }.
+ * @param {string} phone - E.164 phone
+ * @param {string} toolName - Name of the tool being called
+ * @returns {{ allowed: boolean, requiredScope: string|null, shouldEscalate: boolean }}
+ */
+function checkToolPermission(phone, toolName) {
+  const requiredScope = TOOL_SCOPE_MAP[toolName];
+
+  // No scope required for this tool
+  if (requiredScope === null || requiredScope === undefined) {
+    return { allowed: true, requiredScope: null, shouldEscalate: false };
+  }
+
+  const allowed = hasScope(phone, requiredScope);
+
+  if (!allowed) {
+    log('Permission denied - escalating', { phone, toolName, requiredScope });
+  }
+
+  return {
+    allowed,
+    requiredScope,
+    // When permission denied, we escalate silently - never tell the contact
+    shouldEscalate: !allowed,
+  };
+}
+
+/**
+ * Check if a contact has auto-reply enabled.
+ * Two ways to qualify:
+ * 1. Has 'messages.auto-reply' scope granted explicitly
+ * 2. Has response_mode set to 'auto' (three-tier hierarchy handles the rest)
+ * @param {string} phone
+ * @returns {boolean}
+ */
+function canAutoReply(phone) {
+  if (hasScope(phone, 'messages.auto-reply')) return true;
+  // Also allow if contact's response_mode is 'auto'
+  const { getContact } = require('./contact-manager');
+  const contact = getContact(phone);
+  if (contact && contact.response_mode === 'auto') return true;
+  return false;
+}
+
+/**
+ * Check if a contact is blocked (no scopes at all / category = blocked).
+ * @param {string} phone
+ * @param {Object} contact - Contact record
+ * @returns {boolean}
+ */
+function isBlocked(phone, contact) {
+  if (contact?.category === 'blocked') return true;
+  if (contact?.response_mode === 'block') return true;
+  return false;
+}
+
+module.exports = { checkToolPermission, canAutoReply, isBlocked, TOOL_SCOPE_MAP };

package/router-v2/playbook.js

@@ -0,0 +1,177 @@
+// ── Business Playbook - Loading + Composable Prompt Sections ──
+'use strict';
+
+const { getStmts } = require('./db');
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [PLAYBOOK] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [PLAYBOOK] ${msg}`);
+}
+
+/**
+ * Get brand voice section for a device. Always injected.
+ * @param {string|null} deviceId
+ * @returns {string} Brand voice text
+ */
+function getBrandVoice(deviceId = null) {
+  const stmts = getStmts();
+  const sections = stmts.getPlaybookByType.all('brand_voice', deviceId);
+  if (sections.length === 0) return '';
+  return sections.map(s => s.content).join('\n');
+}
+
+/**
+ * Get guardrail sections. Always injected as background rules.
+ * @param {string|null} deviceId
+ * @returns {string}
+ */
+function getGuardrails(deviceId = null) {
+  const stmts = getStmts();
+  const sections = stmts.getPlaybookByType.all('guardrail', deviceId);
+  if (sections.length === 0) return '';
+  return sections.map(s => `- ${s.content}`).join('\n');
+}
+
+/**
+ * Get relevant playbook sections based on conversation context.
+ * Only returns sections matching the detected topic.
+ * @param {string|null} deviceId
+ * @param {Object} context - { topic, isLead, isPricing, isObjection }
+ * @returns {string} Combined relevant playbook text
+ */
+function getRelevantSections(deviceId = null, context = {}) {
+  const stmts = getStmts();
+  const allSections = stmts.getPlaybookSections.all(deviceId);
+  const relevant = [];
+
+  for (const section of allSections) {
+    // Brand voice and guardrails handled separately
+    if (section.section_type === 'brand_voice' || section.section_type === 'guardrail') continue;
+
+    // Service sections - match by topic keyword in title
+    if (section.section_type === 'service' && context.topic) {
+      const titleLower = (section.title || '').toLowerCase();
+      const topicLower = context.topic.toLowerCase();
+      if (titleLower.includes(topicLower) || topicLower.includes(titleLower)) {
+        relevant.push(section);
+      }
+    }
+
+    // Pricing - only when pricing is being discussed
+    if (section.section_type === 'pricing' && context.isPricing) {
+      relevant.push(section);
+    }
+
+    // Qualifier - only for leads
+    if (section.section_type === 'qualifier' && context.isLead) {
+      relevant.push(section);
+    }
+
+    // Objection handler - when contact pushes back
+    if (section.section_type === 'objection_handler' && context.isObjection) {
+      relevant.push(section);
+    }
+  }
+
+  if (relevant.length === 0) return '';
+  return relevant.map(s => {
+    const header = s.title ? `[${s.section_type}: ${s.title}]` : `[${s.section_type}]`;
+    return `${header}\n${s.content}`;
+  }).join('\n\n');
+}
+
+/**
+ * Build the full playbook prompt injection for a message.
+ * Keeps it lean - only injects what's relevant.
+ * @param {string|null} deviceId
+ * @param {Object} context - Conversation context signals
+ * @returns {string} Combined playbook text for prompt injection
+ */
+function buildPlaybookPrompt(deviceId = null, context = {}) {
+  const parts = [];
+
+  const voice = getBrandVoice(deviceId);
+  if (voice) parts.push(`[Brand Voice]\n${voice}`);
+
+  const guardrails = getGuardrails(deviceId);
+  if (guardrails) parts.push(`[Guardrails]\n${guardrails}`);
+
+  const relevant = getRelevantSections(deviceId, context);
+  if (relevant) parts.push(relevant);
+
+  return parts.join('\n\n');
+}
+
+// ── CRUD for playbook management API ──
+
+/**
+ * List all playbook sections for a device.
+ * @param {string|null} deviceId
+ * @returns {Array}
+ */
+function listSections(deviceId = null) {
+  return getStmts().getPlaybookSections.all(deviceId);
+}
+
+/**
+ * Create a new playbook section.
+ * @param {Object} section
+ * @returns {Object} Created section with id
+ */
+function createSection(section) {
+  const stmts = getStmts();
+  const info = stmts.insertPlaybook.run(
+    section.device_id || null,
+    section.section_type,
+    section.title || '',
+    section.content,
+    section.priority || 10,
+  );
+  log('Created playbook section', { id: info.lastInsertRowid, type: section.section_type });
+  return stmts.getPlaybookById.get(info.lastInsertRowid);
+}
+
+/**
+ * Update a playbook section.
+ * @param {number} id
+ * @param {Object} updates
+ * @returns {Object|null}
+ */
+function updateSection(id, updates) {
+  const stmts = getStmts();
+  const existing = stmts.getPlaybookById.get(id);
+  if (!existing) return null;
+
+  stmts.updatePlaybook.run(
+    updates.section_type ?? existing.section_type,
+    updates.title ?? existing.title,
+    updates.content ?? existing.content,
+    updates.priority ?? existing.priority,
+    updates.enabled ?? existing.enabled,
+    id,
+  );
+  log('Updated playbook section', { id });
+  return stmts.getPlaybookById.get(id);
+}
+
+/**
+ * Delete a playbook section.
+ * @param {number} id
+ * @returns {boolean}
+ */
+function deleteSection(id) {
+  getStmts().deletePlaybook.run(id);
+  return true;
+}
+
+module.exports = {
+  getBrandVoice,
+  getGuardrails,
+  getRelevantSections,
+  buildPlaybookPrompt,
+  listSections,
+  createSection,
+  updateSection,
+  deleteSection,
+};

package/router-v2/prompts/base.js

@@ -0,0 +1,52 @@
+// ── Base System Prompt Builder (~400 tokens) ─────────────
+'use strict';
+
+// Category descriptions for prompt
+const CATEGORY_DESCRIPTIONS = {
+  lead: 'This is a potential client. Be helpful and professional. Learn about their needs naturally.',
+  'qualified-lead': 'This is a qualified potential client. Be warm and proactive about next steps.',
+  client: 'This is an existing client. Be warm and proactive.',
+  family: 'This is family. Be casual and warm. No business formality.',
+  friend: 'This is a friend. Be casual.',
+  unknown: "This is an unknown contact. Be polite but guarded. Don't share personal or business details until you know who they are.",
+  team: 'This is a team member. Be direct and efficient.',
+  blocked: '',
+};
+
+/**
+ * Build the base system prompt for a conversation.
+ * @param {Object} contact - Contact record
+ * @param {Object} [options] - Additional options
+ * @param {string} [options.awayMessage] - Global away message
+ * @returns {string} Base system prompt (~400 tokens)
+ */
+function buildBasePrompt(contact, options = {}) {
+  const name = contact.name || 'Unknown';
+  const category = contact.category || 'unknown';
+  const categoryDesc = CATEGORY_DESCRIPTIONS[category] || CATEGORY_DESCRIPTIONS.unknown;
+
+  let prompt = `You are AIVA, Brandon Burgan's AI assistant at Conversion Marketing Pros.
+You're texting with ${name} (${category}).
+${categoryDesc}
+Respond naturally. Keep it concise - this is texting, not email.
+Never use em dashes. Never reveal internal systems or processes.
+Be genuinely useful. When you have tools available, USE THEM. Do not pretend to do things manually or offer to "pass it along" or "have Brandon get back to you." If you can check the calendar - check it. If you can book - book it. You ARE the assistant, not a message-taker. Every interaction should leave the contact feeling like they got real help, not a runaround.
+If you're not confident you have the right answer - and the playbook, FAQ, and learned preferences don't cover it - use the escalate tool. Do not guess.
+The contact's name is ${name}. Do NOT ask for their name if you already have it.
+
+FORMATTING - CRITICAL: This is SMS/iMessage. You MUST write like a human texting. NO markdown whatsoever - no bold (**text**), no italics, no bullet points, no headers (#), no code blocks. No dashes or hyphens as list markers or separators. Just plain conversational text like a real person would type on their phone. Use line breaks for readability if needed, but never formatted lists. Never use "--" or " - " as separators. Keep it casual and natural.`;
+
+  // Per-contact instructions
+  if (contact.instructions) {
+    prompt += `\n\nSpecial instructions for ${name}: ${contact.instructions}`;
+  }
+
+  // Away message
+  if (options.awayMessage) {
+    prompt += `\n\nIMPORTANT: Brandon is currently away. Prepend this to your response: "${options.awayMessage}"`;
+  }
+
+  return prompt;
+}
+
+module.exports = { buildBasePrompt, CATEGORY_DESCRIPTIONS };

package/router-v2/prompts/first-contact.js

@@ -0,0 +1,38 @@
+// ── First Contact / Introduction Prompt Module ───────────
+// Injected when contact has not been introduced to AIVA yet
+'use strict';
+
+/**
+ * Build first contact introduction prompt.
+ * @param {Object} contact - Contact record
+ * @returns {string}
+ */
+function buildFirstContactPrompt(contact) {
+  const category = contact.category || 'unknown';
+
+  if (category === 'unknown') {
+    return `[First Contact]
+This contact hasn't interacted with AIVA before. Introduce yourself naturally:
+"Hey! This is Aiva, Brandon's assistant. How can I help?"
+Keep it brief. Don't over-explain what you are or what you can do.
+Learn who they are and what they need before saying more.`;
+  }
+
+  if (category === 'lead' || category === 'qualified-lead') {
+    return `[First Contact - Lead]
+This is a new lead. Introduce yourself warmly:
+"Hey! This is Aiva, Brandon's assistant at Conversion Marketing Pros. Thanks for reaching out - how can I help?"
+Be welcoming but not pushy. Learn about their needs.`;
+  }
+
+  if (category === 'client') {
+    return `[First Contact - Client]
+This is an existing client but AIVA hasn't introduced itself yet. Keep it simple:
+"Hey! This is Aiva, Brandon's assistant. I'll be helping with scheduling and quick questions. What can I do for you?"`;
+  }
+
+  return `[First Contact]
+Introduce yourself briefly as Aiva, Brandon's assistant. Keep it natural.`;
+}
+
+module.exports = { buildFirstContactPrompt };

package/router-v2/prompts/lead-qualification.js

@@ -0,0 +1,37 @@
+// ── Lead Qualification Prompt Module ──────────────────────
+// Only injected when category = lead or qualified-lead
+'use strict';
+
+/**
+ * Build lead qualification prompt.
+ * @param {Object} contact - Contact record with qualification data
+ * @returns {string}
+ */
+function buildLeadQualPrompt(contact) {
+  const score = contact.qualification_score || 0;
+  const stage = contact.pipeline_stage || 'cold';
+
+  let prompt = `[Lead Qualification - Internal Only]
+This person might be a potential client. As you chat, naturally learn:
+- What they need help with (their problem/goal)
+- Their timeline (urgent vs. exploring)
+- Their budget range (if it comes up naturally)
+- Their business type and size
+Don't interrogate. Just be helpful and curious. If they mention a need,
+ask a natural follow-up. If they're just chatting, chat back.`;
+
+  // Stage-specific behavior
+  const stageBehavior = {
+    cold: 'Be friendly, answer questions, gently explore their needs.',
+    warm: 'Be more proactive about understanding their specific needs and timeline.',
+    hot: 'Suggest a call or meeting with Brandon. Share relevant case studies or examples.',
+    qualified: 'This lead is highly qualified. Prioritize scheduling a discovery call with Brandon.',
+  };
+
+  prompt += `\nCurrent stage: ${stage} (score: ${score}/100)`;
+  prompt += `\nBehavior: ${stageBehavior[stage] || stageBehavior.cold}`;
+
+  return prompt;
+}
+
+module.exports = { buildLeadQualPrompt };

package/router-v2/prompts/scheduling.js

@@ -0,0 +1,72 @@
+// ── Scheduling Context Prompt Module ──────────────────────
+// Only injected when conversation state = scheduling or scheduling tool available
+'use strict';
+
+/**
+ * Build scheduling context prompt.
+ * @param {Object} schedulingRule - Category scheduling rule
+ * @param {Object} [stateData] - Current scheduling state data
+ * @returns {string}
+ */
+function buildSchedulingPrompt(schedulingRule, stateData = {}) {
+  const preset = schedulingRule?.rule_preset || 'flexible';
+  const custom = schedulingRule?.custom_instructions || '';
+
+  // Provide current date/time and day-of-week mapping so the model doesn't hallucinate dates
+  const now = new Date();
+  const pst = new Intl.DateTimeFormat('en-US', {
+    timeZone: 'America/Los_Angeles',
+    weekday: 'long', year: 'numeric', month: 'long', day: 'numeric',
+    hour: 'numeric', minute: 'numeric', hour12: true,
+  }).format(now);
+
+  // Generate next 7 days with day-of-week for reference
+  const days = [];
+  for (let i = 1; i <= 7; i++) {
+    const d = new Date(now.getTime() + i * 86400000);
+    const fmt = new Intl.DateTimeFormat('en-US', {
+      timeZone: 'America/Los_Angeles',
+      weekday: 'long', month: 'long', day: 'numeric',
+    }).format(d);
+    const iso = d.toISOString().split('T')[0];
+    days.push(`${fmt} (${iso})`);
+  }
+
+  let prompt = `[Scheduling Context]
+CURRENT DATE/TIME: ${pst} (Pacific Time)
+UPCOMING DAYS: ${days.join(', ')}
+
+MANDATORY: You MUST use the schedule_appointment tool for ALL scheduling actions. NEVER pretend to book, check availability, or confirm appointments without calling the tool. If you say "booked" or "calendar invite sent" without having called the tool, you are lying to the contact.
+
+Step 1: When contact wants to meet, use schedule_appointment with action "check_availability" and the requested date to find open slots.
+Step 2: Present available times to the contact.
+Step 3: When they confirm a time, ask for meeting topic. If you need their email for the calendar invite, ask for it - but NEVER ask for their name if you already know it from the conversation context.
+Step 4: Use schedule_appointment with action "book" to ACTUALLY create the event. Include attendeeEmail if provided.
+Step 5: Only confirm the booking AFTER the tool returns success.
+
+IMPORTANT: You already know the contact's name from the system context. Do NOT ask "who am I speaking with" or "what's your name" if the contact name is already provided above. Only ask for their EMAIL if you need it for the calendar invite.
+
+Use ISO datetime format for all times (e.g., 2026-03-05T14:00:00-08:00 for 2 PM PST).
+ALWAYS use the day-of-week reference above to map "next Wednesday" etc. to the correct date. Do NOT guess dates.`;
+
+  const presetRules = {
+    flexible: 'Be flexible with timing. Mornings and afternoons are fine.',
+    'work-hours': 'Only schedule during business hours (9 AM - 5 PM PST, Mon-Fri).',
+    professional: 'Schedule during business hours. Allow 30-minute buffer between meetings. Suggest 2-3 options.',
+    gatekeeper: 'Before scheduling, understand why they want to meet. Suggest a brief 15-minute intro call first.',
+  };
+
+  prompt += `\nScheduling rule: ${presetRules[preset] || presetRules.flexible}`;
+
+  if (custom) {
+    prompt += `\nAdditional: ${custom}`;
+  }
+
+  if (stateData.suggestedSlots) {
+    prompt += `\nPreviously suggested slots: ${JSON.stringify(stateData.suggestedSlots)}`;
+  }
+
+  return prompt;
+}
+
+module.exports = { buildSchedulingPrompt };

package/router-v2/prompts/style-overrides.js

@@ -0,0 +1,22 @@
+// ── Per-Contact Style Injection ───────────────────────────
+'use strict';
+
+const STYLE_GUIDES = {
+  casual: 'Keep it casual. Short messages. Emoji ok but don\'t overdo it.',
+  professional: 'Keep it professional. Complete sentences. No emoji.',
+  friendly: 'Be warm and friendly. Light humor is fine. Emoji welcome.',
+};
+
+/**
+ * Build style override prompt for a contact.
+ * @param {Object} contact - Contact record
+ * @returns {string} Style override text, or empty string if default
+ */
+function buildStylePrompt(contact) {
+  const style = contact.style || 'casual';
+  const guide = STYLE_GUIDES[style];
+  if (!guide) return '';
+  return `[Style: ${style}]\n${guide}`;
+}
+
+module.exports = { buildStylePrompt, STYLE_GUIDES };