@conversionpros/aiva 1.0.0

package/router-v2/conversation-engine.js

@@ -0,0 +1,498 @@
+// ── Conversation Engine - Sonnet Context Assembly + Response ──
+// The brain. Single AI call per message. Handles intent detection,
+// response generation, and tool calls in one pass.
+'use strict';
+
+const { getStmts, getSetting } = require('./db');
+const { callSonnet } = require('./utils/ai');
+const { buildBasePrompt } = require('./prompts/base');
+const { buildSchedulingPrompt } = require('./prompts/scheduling');
+const { buildLeadQualPrompt } = require('./prompts/lead-qualification');
+const { buildFirstContactPrompt } = require('./prompts/first-contact');
+const { buildStylePrompt } = require('./prompts/style-overrides');
+const { buildPlaybookPrompt } = require('./playbook');
+const { buildPreferencesPrompt } = require('./learning-loop');
+const { checkToolPermission, canAutoReply, isBlocked } = require('./permission-gate');
+const { getSchedulingRule } = require('./scheduler');
+const { search: searchKnowledge } = require('./knowledge-base');
+const { escalate, appendToEscalation, getActiveEscalation } = require('./escalation-bridge');
+const { getContact, getOrCreateContact, updateContext, markIntroduced } = require('./contact-manager');
+const { sendMessage } = require('./outbound-sender');
+const { analyzeQualification, shouldEscalateForOutreach } = require('./lead-qualifier');
+const { validateResponse } = require('./utils/response-validator');
+
+/**
+ * Resolve the effective response mode for a contact using three-tier hierarchy:
+ * 1. Per-contact manual override (if set and not empty)
+ * 2. Per-channel default (imessage or whatsapp specific)
+ * 3. Global default (falls back to 'block')
+ * @param {Object} contact - Contact object with response_mode field
+ * @param {string} channel - Channel identifier ('imessage', 'whatsapp', etc.)
+ * @returns {string} The resolved response mode
+ */
+function mv2ResolveEffectiveMode(contact, channel) {
+  // 1. Per-contact manual override
+  if (contact && contact.response_mode && contact.response_mode.trim() !== '') {
+    return contact.response_mode;
+  }
+  // 2. Per-channel default
+  if (channel === 'imessage') {
+    const imDefault = getSetting('imessageDefaultMode');
+    if (imDefault && imDefault.trim() !== '') return imDefault;
+  }
+  if (channel === 'whatsapp') {
+    const waDefault = getSetting('whatsappDefaultMode');
+    if (waDefault && waDefault.trim() !== '') return waDefault;
+  }
+  // 3. Global default
+  const globalDefault = getSetting('defaultResponseMode');
+  return (globalDefault && globalDefault.trim() !== '') ? globalDefault : 'block';
+}
+
+// Tool definitions for Sonnet
+const TOOL_DEFINITIONS = [
+  {
+    type: 'function',
+    function: {
+      name: 'schedule_appointment',
+      description: 'MANDATORY tool for ALL scheduling actions. You MUST call this tool - never pretend to check availability or book without it.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['check_availability', 'book', 'reschedule', 'cancel'], description: 'Scheduling action' },
+          date: { type: 'string', description: 'Date in YYYY-MM-DD format (for check_availability)' },
+          startTime: { type: 'string', description: 'ISO datetime for appointment start (e.g. 2026-03-05T14:00:00-08:00)' },
+          endTime: { type: 'string', description: 'ISO datetime for appointment end (e.g. 2026-03-05T15:00:00-08:00)' },
+          duration: { type: 'number', description: 'Meeting duration in minutes (default 30)' },
+          summary: { type: 'string', description: 'Event title/summary' },
+          description: { type: 'string', description: 'Event description' },
+          attendeeEmail: { type: 'string', description: 'Email address of the attendee to invite' },
+          eventId: { type: 'string', description: 'Event ID for reschedule/cancel' },
+          newStart: { type: 'string', description: 'New start time for reschedule' },
+          newEnd: { type: 'string', description: 'New end time for reschedule' },
+        },
+        required: ['action'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'search_knowledge_base',
+      description: 'Search FAQ and workspace files for information to answer a question.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query' },
+        },
+        required: ['query'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'escalate',
+      description: 'Escalate to the main agent when you cannot confidently answer. Do not acknowledge any delay to the contact.',
+      parameters: {
+        type: 'object',
+        properties: {
+          reason: { type: 'string', description: 'Why this needs escalation' },
+          isClientSupport: { type: 'boolean', description: 'True if this is a client reporting a bug/issue with their AIVA system' },
+        },
+        required: ['reason'],
+      },
+    },
+  },
+];
+
+function log(msg, data) {
+  const ts = new Date().toISOString();
+  if (data) console.log(`[${ts}] [ENGINE] ${msg}`, JSON.stringify(data));
+  else console.log(`[${ts}] [ENGINE] ${msg}`);
+}
+
+/**
+ * Build the full system prompt with composable modules.
+ * Only injects modules when relevant - target ~800 tokens, max ~1500.
+ * @param {Object} contact - Contact record with context
+ * @param {Object} options - { conversationState, messageText }
+ * @returns {string}
+ */
+function buildSystemPrompt(contact, options = {}) {
+  const parts = [];
+
+  // 1. Base prompt (always)
+  const awayMessage = getSetting('awayMessage');
+  parts.push(buildBasePrompt(contact, { awayMessage: awayMessage || undefined }));
+
+  // 2. Playbook voice + guardrails (always)
+  const playbookContext = {
+    topic: contact.context?.last_topic || '',
+    isLead: ['lead', 'qualified-lead'].includes(contact.category),
+    isPricing: /pric|cost|budget|rate|fee|charge|afford/i.test(options.messageText || ''),
+    isObjection: /expensive|too much|cheaper|can't afford|not sure/i.test(options.messageText || ''),
+  };
+  const playbook = buildPlaybookPrompt(null, playbookContext);
+  if (playbook) parts.push(playbook);
+
+  // 3. Learned preferences (if relevant matches exist)
+  const prefs = buildPreferencesPrompt(contact.phone, options.messageText || '');
+  if (prefs) parts.push(prefs);
+
+  // 4. Style override
+  const style = buildStylePrompt(contact);
+  if (style) parts.push(style);
+
+  // 5. First contact (if not introduced)
+  if (!contact.introduced) {
+    parts.push(buildFirstContactPrompt(contact));
+  }
+
+  // 6. Lead qualification (only for leads)
+  if (['lead', 'qualified-lead'].includes(contact.category)) {
+    parts.push(buildLeadQualPrompt(contact));
+  }
+
+  // 7. Scheduling context (only when relevant)
+  const state = options.conversationState?.state;
+  const isSchedulingRelevant = state === 'scheduling' ||
+    /schedul|book|appointment|meeting|call|availab|calendar|reschedul|cancel/i.test(options.messageText || '');
+  if (isSchedulingRelevant) {
+    const rule = getSchedulingRule(contact.category);
+    const stateData = state === 'scheduling' ? JSON.parse(options.conversationState?.state_data || '{}') : {};
+    parts.push(buildSchedulingPrompt(rule, stateData));
+  }
+
+  return parts.join('\n\n');
+}
+
+/**
+ * Build conversation history messages for the AI call.
+ * @param {string} phone
+ * @param {number} [limit=10]
+ * @returns {Array<{role: string, content: string}>}
+ */
+function buildHistory(phone, limit = 10) {
+  const stmts = getStmts();
+  const messages = stmts.getRecentMessages.all(phone, limit);
+  // Messages come in DESC order, reverse for chronological
+  return messages.reverse().map(m => {
+    if (m.sent_by === 'contact') {
+      return { role: 'user', content: m.text };
+    }
+    if (m.sent_by === 'brandon') {
+      // Brandon's manual messages shown as assistant with attribution so AI knows
+      return { role: 'assistant', content: `[Brandon replied directly]: ${m.text}` };
+    }
+    return { role: 'assistant', content: m.text };
+  });
+}
+
+/**
+ * Process a single inbound message through the conversation engine.
+ * This is the main entry point for message processing.
+ * @param {Object} message - Normalized inbound message
+ * @returns {Promise<void>}
+ */
+async function processMessage(message) {
+  const { phone, text, channel } = message;
+
+  // Get or create contact
+  const contact = getOrCreateContact(phone, { source: channel });
+
+  // Resolve effective mode using three-tier hierarchy (FIRST - before permission checks)
+  const effectiveMode = mv2ResolveEffectiveMode(contact, channel);
+  log('Resolved mode', { phone, effectiveMode, contactMode: contact.response_mode, channel });
+
+  // Check for block mode
+  if (effectiveMode === 'block') {
+    log('Blocked by mode', { phone, effectiveMode });
+    return;
+  }
+
+  // Check for monitor-only mode
+  if (effectiveMode === 'monitor') {
+    log('Monitor only', { phone, effectiveMode });
+    return;
+  }
+
+  // Check if blocked by category
+  if (isBlocked(phone, contact)) {
+    log('Blocked contact', { phone });
+    return;
+  }
+
+  // Check auto-reply permission (only for 'auto' mode - escalate mode doesn't need it)
+  if (effectiveMode === 'auto' && !canAutoReply(phone)) {
+    log('Auto-reply disabled', { phone });
+    return;
+  }
+
+  // Handle escalate mode - directly escalate without AI processing
+  if (effectiveMode === 'escalate') {
+    log('Escalate mode - direct escalation', { phone });
+    const stmts = getStmts();
+    const recentMsgs = stmts.getRecentMessages.all(phone, 20);
+    await handleEscalation(contact, text, recentMsgs, 'Escalate mode - all messages for this contact are escalated', false);
+    runPostMessageProcessing(contact, phone, text, stmts);
+    return;
+  }
+
+  // Check for active escalation - append message
+  const activeEsc = getActiveEscalation(phone);
+  if (activeEsc) {
+    appendToEscalation(phone, text);
+    log('Appended to active escalation', { phone, escalationId: activeEsc.escalation_id });
+    return;
+  }
+
+  // Get conversation state
+  const stmts = getStmts();
+  stmts.clearExpiredStates.run();
+  const convState = stmts.getState.get(phone) || { state: 'idle', state_data: '{}' };
+
+  // Build system prompt
+  const systemPrompt = buildSystemPrompt(contact, {
+    conversationState: convState,
+    messageText: text,
+  });
+
+  // Build message history
+  const history = buildHistory(phone);
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    ...history,
+    { role: 'user', content: text },
+  ];
+
+  // Filter tools based on contact's actual permissions
+  const allowedTools = TOOL_DEFINITIONS.filter(td => {
+    const toolName = td.function?.name;
+    if (!toolName) return false;
+    const perm = checkToolPermission(phone, toolName);
+    return perm.allowed;
+  });
+
+  // Build structured permission flags for the system prompt
+  const permissionFlags = {
+    CALENDAR_VIEW: allowedTools.some(t => t.function?.name === 'check_availability'),
+    CALENDAR_BOOK: allowedTools.some(t => t.function?.name === 'schedule_appointment'),
+    CALENDAR_MODIFY: allowedTools.some(t => t.function?.name === 'reschedule_appointment'),
+    REMINDERS: allowedTools.some(t => t.function?.name === 'create_reminder'),
+    TASKS: allowedTools.some(t => t.function?.name === 'create_task'),
+    FILE_SHARING: allowedTools.some(t => t.function?.name === 'send_file'),
+    MESSAGING: allowedTools.some(t => t.function?.name === 'send_message'),
+    KNOWLEDGE_BASE: true,  // always enabled
+    ESCALATE: true,         // always enabled
+  };
+
+  const flagBlock = Object.entries(permissionFlags)
+    .map(([key, enabled]) => `${key}: ${enabled ? 'ENABLED' : 'PROHIBITED'}`)
+    .join('\n');
+
+  const permissionNote = `
+
+[CONTACT PERMISSIONS - STRICTLY ENFORCED]
+${flagBlock}
+
+[PERMISSION RULES]
+- ENABLED: You may use this capability freely
+- PROHIBITED: You MUST NOT discuss, offer, promise, or imply this capability exists
+- When a contact requests something PROHIBITED: use the escalate tool IMMEDIATELY
+- Do NOT say "let me pass that along" or "I'll let Brandon know" for PROHIBITED items
+- Do NOT acknowledge the request conversationally before escalating
+- Simply use the escalate tool. The system handles the contact's experience.
+- NEVER mention Brandon's name in relation to any PROHIBITED capability`;
+
+  // Append to system prompt
+  messages[0].content += permissionNote;
+
+  // Call Sonnet with only permitted tools
+  const callOpts = {
+    messages,
+    tools: allowedTools.length > 0 ? allowedTools : undefined,
+    maxTokens: 1000,
+    temperature: 0.7,
+  };
+
+  const result = await callSonnet(callOpts);
+
+  // Handle tool calls
+  if (result.toolCalls && result.toolCalls.length > 0) {
+    for (const toolCall of result.toolCalls) {
+      const fnName = toolCall.function?.name;
+      let args;
+      try {
+        args = JSON.parse(toolCall.function?.arguments || '{}');
+      } catch (parseErr) {
+        log('Failed to parse tool arguments', { phone, fnName, error: parseErr.message });
+        await handleEscalation(contact, text, stmts.getRecentMessages.all(phone, 20), 'Tool argument parse failure', false);
+        return;
+      }
+
+      // Permission check
+      const perm = checkToolPermission(phone, fnName);
+      if (perm.shouldEscalate) {
+        // Derive escalation type from tool name for contextual options
+        const toolTypeMap = {
+          schedule_appointment: 'scheduling', check_availability: 'scheduling',
+          reschedule_appointment: 'scheduling', cancel_appointment: 'scheduling',
+          create_task: 'task', create_reminder: 'task',
+          send_file: 'file_sharing', send_message: 'messaging',
+        };
+        await handleEscalation(contact, text, stmts.getRecentMessages.all(phone, 20), 'Permission denied for action', false, toolTypeMap[fnName] || null);
+        return;
+      }
+
+      if (fnName === 'escalate') {
+        const isClientSupport = args.isClientSupport || false;
+        await handleEscalation(contact, text, stmts.getRecentMessages.all(phone, 20), args.reason, isClientSupport);
+        runPostMessageProcessing(contact, phone, text, stmts);
+        return;
+      }
+
+      if (fnName === 'schedule_appointment') {
+        const scheduler = require('./scheduler');
+        const schedResult = await scheduler.handleToolCall(args, contact);
+
+        // Update state
+        stmts.upsertState.run(phone, 'scheduling', JSON.stringify(schedResult), null);
+
+        // Make a follow-up call with tool result
+        const followUpMessages = [
+          ...messages,
+          { role: 'assistant', content: null, tool_calls: [toolCall] },
+          { role: 'tool', tool_call_id: toolCall.id, content: JSON.stringify(schedResult) },
+        ];
+
+        const followUp = await callSonnet({ messages: followUpMessages, maxTokens: 500 });
+        if (followUp.content) {
+          await sendResponse(phone, followUp.content, channel);
+        }
+        runPostMessageProcessing(contact, phone, text, stmts);
+        return;
+      }
+
+      if (fnName === 'search_knowledge_base') {
+        const kbResults = searchKnowledge(args.query);
+
+        // Make a follow-up call with search results
+        const followUpMessages = [
+          ...messages,
+          { role: 'assistant', content: null, tool_calls: [toolCall] },
+          { role: 'tool', tool_call_id: toolCall.id, content: JSON.stringify(kbResults) },
+        ];
+
+        const followUp = await callSonnet({ messages: followUpMessages, maxTokens: 500 });
+        if (followUp.content) {
+          await sendResponse(phone, followUp.content, channel);
+        }
+        runPostMessageProcessing(contact, phone, text, stmts);
+        return;
+      }
+    }
+  }
+
+  // Direct response (no tool calls)
+  if (result.content) {
+    // Build permissions object from actual contact scopes
+    const permissions = {
+      canSchedule: allowedTools.some(t => t.function?.name === 'schedule_appointment'),
+      canCreateTask: allowedTools.some(t => t.function?.name === 'create_task'),
+      canCreateReminder: allowedTools.some(t => t.function?.name === 'create_reminder'),
+      canSendFile: allowedTools.some(t => t.function?.name === 'send_file'),
+      canSendMessage: allowedTools.some(t => t.function?.name === 'send_message'),
+    };
+
+    // Validate Sonnet's response against actual permissions
+    const validation = await validateResponse(result.content, permissions);
+
+    if (!validation.valid) {
+      // Sonnet overpromised - suppress response, send brief ack, escalate
+      log('Response overpromises capabilities - suppressing', { phone, capability: validation.reason });
+
+      const acks = [
+        "Let me check on that",
+        "Let me look into that",
+        "One sec, let me check",
+        "Give me a moment to check on that",
+      ];
+      const ack = acks[Math.floor(Math.random() * acks.length)];
+      await sendResponse(phone, ack, channel);
+
+      await handleEscalation(contact, text, stmts.getRecentMessages.all(phone, 20),
+        `Sonnet's response overpromised ${validation.reason} capability. Original response suppressed. Contact asked: "${text}"`, false, validation.reason);
+    } else {
+      await sendResponse(phone, result.content, channel);
+    }
+
+    // Update conversation state to active
+    stmts.upsertState.run(phone, 'active', '{}', null);
+
+    // Mark as introduced if first contact
+    if (!contact.introduced) {
+      markIntroduced(phone);
+    }
+  } else {
+    log('No response from Sonnet', { phone });
+  }
+
+  // Post-message: update context and run lead qualification (async, non-blocking)
+  runPostMessageProcessing(contact, phone, text, stmts);
+}
+
+/**
+ * Run post-message processing (context update + lead qualification).
+ * Extracted so all code paths can call it.
+ */
+function runPostMessageProcessing(contact, phone, text, stmts) {
+  updateContextPostMessage(contact, text).catch(err => log('Context update error', { error: err.message }));
+
+  if (['lead', 'qualified-lead'].includes(contact.category)) {
+    const recentMsgs = stmts.getRecentMessages.all(phone, 15);
+    analyzeQualification(contact, recentMsgs.reverse()).catch(err => log('Lead qual error', { error: err.message }));
+  }
+}
+
+/**
+ * Send a response to a contact and update state.
+ */
+async function sendResponse(phone, text, channel) {
+  await sendMessage({
+    phone,
+    text,
+    channel,
+    sentBy: 'aiva',
+    stateAtTime: 'auto-reply',
+  });
+}
+
+/**
+ * Handle escalation (from escalate tool call or permission denial).
+ */
+async function handleEscalation(contact, triggerMessage, recentMessages, reason, isClientSupport, escalationType = null) {
+  const context = getStmts().getContext.get(contact.phone) || {};
+
+  await escalate({
+    contact,
+    triggerMessage,
+    conversationHistory: recentMessages,
+    contactContext: context,
+    isClientSupport,
+    escalationType,
+  });
+
+  log('Escalated', { phone: contact.phone, reason, isClientSupport, escalationType });
+}
+
+/**
+ * Update contact context after processing a message.
+ */
+async function updateContextPostMessage(contact, messageText) {
+  updateContext(contact.phone, {
+    last_topic: messageText.substring(0, 100),
+  });
+}
+
+module.exports = { processMessage, buildSystemPrompt, buildHistory, TOOL_DEFINITIONS, mv2ResolveEffectiveMode };

package/router-v2/data/knowledge-base.json

@@ -0,0 +1,176 @@
+[
+  {
+    "category": "business_info",
+    "question": "What is Conversion Marketing Pros?",
+    "answer": "Conversion Marketing Pros, also called Conversion Pros or CMP, is a technology company based in Spokane, Washington. We build custom AI assistants, software, and websites for small to mid-size businesses. Our founder Brandon Burgan started the company to help business owners stop drowning in admin work and focus on what actually makes them money.",
+    "keywords": "conversion marketing pros cmp company about"
+  },
+  {
+    "category": "business_info",
+    "question": "What services does CMP offer?",
+    "answer": "We offer three main things: AIVA (your personal AI assistant that handles calls, texts, scheduling, and admin), custom software builds tailored to your business, and premium hand-coded websites. We also do auto-blogging for SEO, continuous care plans, and CRM builds. Everything we build, you own.",
+    "keywords": "services offer what do you do"
+  },
+  {
+    "category": "business_info",
+    "question": "Who is Brandon Burgan?",
+    "answer": "Brandon Burgan is the founder of Conversion Marketing Pros. He is based in Spokane, Washington and has been building software and AI solutions for small businesses. He started the company after building a proof of concept for Spokane House Plans and seeing how much AI could transform small business operations.",
+    "keywords": "brandon burgan founder owner who"
+  },
+  {
+    "category": "business_info",
+    "question": "Where is CMP located?",
+    "answer": "We are based in Spokane, Washington. We work with clients locally and remotely across the country.",
+    "keywords": "location where spokane washington address"
+  },
+  {
+    "category": "business_info",
+    "question": "What are your business hours?",
+    "answer": "Our team is generally available Monday through Friday during normal business hours, Pacific Time. AIVA, your AI assistant, is available 24/7 and can handle messages, scheduling, and questions any time of day or night.",
+    "keywords": "hours availability when open schedule business hours"
+  },
+  {
+    "category": "aiva_product",
+    "question": "What is AIVA?",
+    "answer": "AIVA is your AI-powered personal assistant. She handles your calls, texts, scheduling, follow-ups, and day-to-day admin so you can focus on running your business. Think of her as a chief of staff that never sleeps, never forgets, and costs a fraction of a real employee.",
+    "keywords": "aiva what is assistant ai"
+  },
+  {
+    "category": "aiva_product",
+    "question": "How does AIVA work?",
+    "answer": "AIVA runs on a dedicated device that we set up for you. She connects to your phone, calendar, and business tools. When someone texts or calls, AIVA can respond on your behalf, book appointments, answer questions about your business, and keep you in the loop on everything. You stay in control and can jump in any time.",
+    "keywords": "how does aiva work technology setup"
+  },
+  {
+    "category": "aiva_product",
+    "question": "What can AIVA do for my business?",
+    "answer": "AIVA can respond to leads and customer inquiries automatically, schedule and manage appointments, send follow-up messages, qualify leads through natural conversation, answer common questions about your business, and keep your calendar organized. She frees you up to focus on meeting clients and growing your business instead of being buried in admin.",
+    "keywords": "aiva features capabilities benefits business"
+  },
+  {
+    "category": "aiva_product",
+    "question": "How much does AIVA cost?",
+    "answer": "AIVA is $1,500 per month. Setup fees depend on your contract length. For a monthly plan, setup is $2,000. For a 6-month contract, setup is $1,500. For a 12-month contract, setup is $1,000. The longer you commit, the less you pay upfront.",
+    "keywords": "cost price pricing how much money subscription"
+  },
+  {
+    "category": "aiva_product",
+    "question": "What is included in the AIVA subscription?",
+    "answer": "Your $1,500 monthly subscription includes the AI assistant running 24/7, a dedicated device, automatic message handling, appointment scheduling, lead qualification, follow-up sequences, knowledge base for your business, and ongoing updates and improvements. Everything you need to run AIVA without lifting a finger.",
+    "keywords": "included subscription what do i get features"
+  },
+  {
+    "category": "aiva_product",
+    "question": "How long is the AIVA contract?",
+    "answer": "We offer three options: monthly (no long-term commitment), 6-month, and 12-month contracts. All contracts auto-renew for the same term length unless you give us 30 days notice before it ends. The longer contracts come with lower setup fees.",
+    "keywords": "contract length term commitment how long"
+  },
+  {
+    "category": "aiva_product",
+    "question": "What are the AIVA setup fees?",
+    "answer": "Setup fees cover your dedicated device and onboarding. Monthly plan is $2,000 setup. 6-month contract is $1,500 setup. 12-month contract is $1,000 setup. The setup includes getting your device configured, connecting your accounts, and a coaching session to get you started.",
+    "keywords": "setup fees onboarding initialization cost upfront"
+  },
+  {
+    "category": "services",
+    "question": "Do you build websites?",
+    "answer": "Yes! We build premium hand-coded websites. These are not template or drag-and-drop sites. They are fully coded for maximum performance, beautiful design, and perfect SEO scores. Websites typically ship in about 4 days. Website builds are a separate project with their own scope of work and pricing.",
+    "keywords": "website web design build site"
+  },
+  {
+    "category": "services",
+    "question": "Do you build CRMs or custom software?",
+    "answer": "Absolutely. Custom software is one of our biggest strengths. We build CRMs, project management tools, client portals, invoicing systems, and more. Everything is tailored to your specific business needs and you own the software when the project is complete. We embed AI into the foundation of everything we build.",
+    "keywords": "crm software custom build application"
+  },
+  {
+    "category": "services",
+    "question": "Do you work with my industry?",
+    "answer": "We work with small to mid-size businesses across all industries. We have built solutions for real estate, financial services, food service, pet care, home services, and more. Every new industry is an opportunity to build something great. If you have a business problem, we can probably solve it.",
+    "keywords": "industry vertical niche sector type of business"
+  },
+  {
+    "category": "services",
+    "question": "What makes CMP different from other agencies?",
+    "answer": "Three things. First, we embed AI into the foundation of everything we build, not as an afterthought. Second, you own everything we build for you. No lock-in, no hostage software. Third, we are a small team that actually cares about your results. We are not a big agency checking boxes. We solve real problems for real business owners.",
+    "keywords": "different unique why cmp competitive advantage"
+  },
+  {
+    "category": "services",
+    "question": "How much does a website cost?",
+    "answer": "A standard website build is $4,500. Additional front-end sites are $3,500 each. We also offer auto-blogging at $300 per month for ongoing SEO content. Website builds are separate from the AIVA subscription and come with their own scope of work.",
+    "keywords": "website cost price how much web"
+  },
+  {
+    "category": "services",
+    "question": "How much does custom software cost?",
+    "answer": "Software builds vary depending on scope and complexity. We will walk you through your specific needs, identify the biggest pain points, and put together a proposal. Everything breaks down into manageable monthly payments over time so it feels more like a subscription than a big upfront cost. We always start with your biggest problem first and prove the model before expanding.",
+    "keywords": "software cost price how much custom build"
+  },
+  {
+    "category": "common_questions",
+    "question": "How do I get started?",
+    "answer": "The best way to get started is to schedule a call with us. We will talk about your business, understand your pain points, and figure out the best solution. From there we put together a proposal and if it makes sense, we get moving. No pressure, no hard sell. We want it to be the right fit for both of us.",
+    "keywords": "get started begin sign up how start onboarding"
+  },
+  {
+    "category": "common_questions",
+    "question": "Can I cancel my AIVA subscription?",
+    "answer": "You can cancel with 30 days notice before your contract term ends. If you cancel early, the remaining balance on your contract is still owed. We do this because we invest real resources into setting up your device and system. That said, we also offer a 60-day satisfaction guarantee from final delivery, so there is built-in protection for you.",
+    "keywords": "cancel subscription stop end terminate"
+  },
+  {
+    "category": "common_questions",
+    "question": "Do you offer a trial or demo?",
+    "answer": "We do not offer a free trial, but we do have a 60-day satisfaction guarantee from final delivery. That means once everything is set up and running, you have 60 days to make sure you are happy with it. We are confident you will love it, and we stand behind our work.",
+    "keywords": "trial demo free test try"
+  },
+  {
+    "category": "common_questions",
+    "question": "What if I am not satisfied?",
+    "answer": "We offer a 60-day satisfaction guarantee from the date of final delivery. If you are not happy within that window, we will work with you to make it right. We want every client to feel great about their investment.",
+    "keywords": "not satisfied unhappy refund guarantee"
+  },
+  {
+    "category": "common_questions",
+    "question": "Who owns the code and intellectual property?",
+    "answer": "CMP owns the code during the life of the contract. Once you fully complete your contract, you receive the source code and it is yours to keep. This is how we protect our investment while making sure you end up owning everything we built for you.",
+    "keywords": "own code ip intellectual property ownership source"
+  },
+  {
+    "category": "common_questions",
+    "question": "How is payment handled?",
+    "answer": "Payment is due on the 1st of each month via Stripe. We accept credit card, ACH bank transfer, and Klarna. Cash payments require owner approval. There is a 3-day grace period for late payments, after which your service may be suspended.",
+    "keywords": "payment pay billing stripe how when"
+  },
+  {
+    "category": "common_questions",
+    "question": "Do I own the device AIVA runs on?",
+    "answer": "No, the device is owned and managed by CMP. We handle all maintenance, updates, and security on the device. This keeps everything running smoothly and means you never have to worry about the technical side. If your subscription ends, the device is recycled.",
+    "keywords": "device own hardware equipment mac"
+  },
+  {
+    "category": "common_questions",
+    "question": "What happens if I stop paying?",
+    "answer": "If payment is not received after the 3-day grace period, your AIVA service will be suspended. If the balance remains unpaid, the service will be terminated and the remaining contract balance is still owed. The device will be recycled. We always try to work with you before it gets to that point.",
+    "keywords": "stop paying late payment delinquent suspended"
+  },
+  {
+    "category": "common_questions",
+    "question": "Can AIVA be shared between multiple people?",
+    "answer": "Each AIVA subscription is for one person. Your assistant is personalized to you, your contacts, your calendar, and your business. Sharing would compromise the quality and personalization that makes AIVA effective.",
+    "keywords": "share multiple people users one person"
+  },
+  {
+    "category": "services",
+    "question": "Do you offer ongoing support after a build?",
+    "answer": "Yes. Software builds come with a 90-day warranty plus 90 days of bug fixes after delivery. We also offer continuous care plans at $300 per month for ongoing improvements and quarterly updates. We do not just build it and walk away.",
+    "keywords": "support warranty maintenance ongoing care after"
+  },
+  {
+    "category": "services",
+    "question": "Do you handle third-party API costs?",
+    "answer": "No. Any third-party API costs like MLS data feeds, payment processors, or other vendor subscriptions are set up under your own account. You pay the vendor directly. We build the integration, but you own the data relationship at cost with no markup from us. Think of it like a Costco membership. You get wholesale prices directly from the source.",
+    "keywords": "api costs third party vendor integration pricing"
+  }
+]