Low Complexity                                              High Complexity
     │                                                              │
     ▼                                                              ▼
┌─────────┬──────────────┬───────────────┬──────────────┬──────────────┐
│ Confirm │   Qualify    │    Handle     │   Consult    │   Negotiate  │
│  Info   │   Fit/Need   │   Objections  │   Advise     │   Close      │
└─────────┴──────────────┴───────────────┴──────────────┴──────────────┘
     │                         │                              │
     └─────── AI ZONE ─────────┘                              │
                                                              │
                               └────────── HUMAN ZONE ────────┘

                    INBOUND                    OUTBOUND
              ┌─────────────────────┬─────────────────────┐
              │                     │                     │
    COLD      │  Rare (misdials,    │  Classic cold       │
              │  general inquiries) │  calling            │
              │                     │                     │
              ├─────────────────────┼─────────────────────┤
              │                     │                     │
    WARM      │  Form fills,        │  Follow-up calls,   │
              │  ad responses,      │  re-engagement,     │
              │  email signature    │  positive reply     │
              │  callbacks          │  callbacks          │
              │                     │                     │
              └─────────────────────┴─────────────────────┘

function selectChannel(lead: Lead): Channel {
  // Hot leads always get phone
  if (lead.temperature === 'hot' && lead.source === 'form_fill') {
    return 'ai_voice_immediate';
  }
  
  // Warm leads with phone number get phone follow-up
  if (lead.temperature === 'warm' && lead.phone && lead.emailEngagement > 0) {
    return 'ai_voice_followup';
  }
  
  // Cool leads start with email
  if (lead.temperature === 'cool') {
    return 'email_sequence';
  }
  
  // Cold leads start with email, escalate to phone if engaged
  if (lead.temperature === 'cold') {
    return 'email_then_phone_if_engaged';
  }
  
  return 'email_sequence'; // Default
}

[Form Submit] → [Trigger] → [AI Call < 60s] → [Qualify] → [Send Agreement]
                                                │
                                                └→ [Disqualify] → [Nurture]

[Positive Reply] → [Extract Phone] → [AI Call < 5m] → [Qualify] → [Send Agreement]
                         │
                         └→ [No Phone] → [Reply asking for phone or continue email]

[Inbound Call] → [AI Answers] → [Identify Intent] → [Qualify] → [Route/Close]
                                       │
                                       └→ [Wrong Number / Service Issue] → [Handle/Escalate]

[Sequence Complete] → [Filter: 2+ Opens] → [Has Phone?] → [AI Follow-up Call]
                                                │
                                                └→ [No Phone] → [Re-engage Email or Move to Nurture]

[90 Days Since Close Lost] → [AI Re-engagement Call] → [Still Interested?] → [Requalify]
                                                              │
                                                              └→ [No] → [Extend Interval or Remove]

function generateOpener(lead: Lead): string {
  switch (lead.source) {
    case 'paid_ad_form':
      return `Hey, is this ${lead.firstName}? Great-calling about the form you just filled out for ${lead.formTopic}. Got a quick second?`;
    
    case 'organic_form':
      return `Hey ${lead.firstName}, this is [Agent] from [Company]. You reached out through our website-wanted to see how I can help.`;
    
    case 'cold_email_positive_reply':
      return `Hey, this is [Agent]-you just replied to my email about [topic]. Got a minute?`;
    
    case 'cold_email_followup':
      return `Hey ${lead.firstName}, this is [Agent] from [Company]. I sent you a few emails about [topic]-figured a quick call might be easier. Got 30 seconds?`;
    
    case 'inbound_marketing_number':
      return `Hey, this is [Agent]-you calling about [most likely reason based on number placement]?`;
    
    case 'cold_call':
      return `Hey, quick question-[highly relevant question that earns attention]?`;
    
    case 'referral':
      return `Hey ${lead.firstName}, this is [Agent] from [Company]. ${lead.referrerName} suggested I reach out-got a minute?`;
    
    case 'reengagement':
      return `Hey ${lead.firstName}, this is [Agent] from [Company]. We talked a few months back about [topic]. Wanted to check if anything's changed on your end.`;
    
    default:
      return `Hey, this is [Agent] from [Company]. How can I help you?`;
  }
}

Day 1:  Email 1 (cold touch)
Day 4:  Email 2 (follow-up, new angle)
Day 9:  Email 3 (final value + graceful exit)
Day 12: [If opened 2+ emails] AI Voice Follow-up
Day 12: [If no engagement] Move to nurture

Trigger:     Form submission
Immediate:   AI Voice Call (attempt 1)
+5 minutes:  [If no answer] SMS + Voicemail
+30 minutes: [If no answer] AI Voice Call (attempt 2)
+2 hours:    [If no answer] Email with booking link
+24 hours:   AI Voice Call (attempt 3)
+48 hours:   [If no contact] Enter email nurture sequence

Day 1: Email 1 + LinkedIn connection request + AI Voice Call (attempt 1)
Day 2: [If call connected] Continue on phone
Day 2: [If no answer] LinkedIn message
Day 4: Email 2 + AI Voice Call (attempt 2)
Day 7: Email 3 (reference all channels)

interface SequenceState {
  emailsSent: number;
  emailsOpened: number;
  callsAttempted: number;
  callsConnected: number;
  smssSent: number;
  lastContactDate: Date;
  leadStatus: 'new' | 'engaged' | 'stale' | 'converted' | 'disqualified';
}

function determineNextAction(state: SequenceState, lead: Lead): Action {
  // Hot lead with no contact yet → keep calling
  if (lead.temperature === 'hot' && state.callsConnected === 0 && state.callsAttempted < 3) {
    return { action: 'call', delay: calculateCallDelay(state.callsAttempted) };
  }
  
  // Engaged in email but no call connection → try phone
  if (state.emailsOpened >= 2 && state.callsAttempted === 0 && lead.phone) {
    return { action: 'call', delay: 0 };
  }
  
  // Multiple call attempts, no answer → SMS + voicemail combo
  if (state.callsAttempted >= 2 && state.callsConnected === 0) {
    return { action: 'sms_voicemail', delay: 0 };
  }
  
  // Email sequence incomplete → continue email
  if (state.emailsSent < 3) {
    return { action: 'email', delay: getEmailInterval(state.emailsSent) };
  }
  
  // Sequence complete, no engagement → nurture
  if (state.emailsSent >= 3 && state.emailsOpened === 0 && state.callsConnected === 0) {
    return { action: 'move_to_nurture', delay: 0 };
  }
  
  // Default: wait and reassess
  return { action: 'wait', delay: 86400000 }; // 24 hours
}

"Hey [Name], this is [Agent] from [Company]. Quick question about [topic]-
give me a call back at [number] or just text me. Thanks."

Hey-just left you a voicemail about [topic]. 
[One-line value prop]. 
Text me back if you want the details.

function shouldCallNow(lead: Lead, currentTime: Date): boolean {
  // Always call hot leads immediately (within legal hours)
  if (lead.temperature === 'hot') {
    return isWithinLegalCallingHours(currentTime, lead.timezone);
  }
  
  // Cold leads: wait for optimal window
  if (lead.temperature === 'cold') {
    return isOptimalCallingWindow(currentTime, lead.timezone, lead.industry);
  }
  
  // Warm leads: call during business hours
  return isWithinBusinessHours(currentTime, lead.timezone);
}

❌ Bad (Too Long):
"Great, so I'll send over the service agreement which includes all the 
details about pricing, pickup schedules, container options, and rebate 
structures, and once you've had a chance to review it you can sign 
digitally through the link, and if you have any questions you can call 
this number or reply to the email."

✓ Good (Chunked):
"Great-I'll send over the service agreement now."
[pause for acknowledgment]
"Once you've looked it over, you can sign right from the email."
[pause]
"Any questions, just call this number back."

❌ Bad (Stacked Questions):
"How many fryers are you running and how often do you change the oil?"

✓ Good (Sequential):
"How many fryers are you running?"
[wait for answer]
"And how often do you change the oil?"

Opening → Qualification → Offer → Collection → Close
   │           │           │          │         │
   └───────────┴───────────┴──────────┴─────────┘
              (Always moving forward)

❌ Bad (Request Without Context):
"What's your email address?"

✓ Good (Signal Then Request):
"I'll send over the agreement now-what's the best email?"

❌ Bad (No Acknowledgment):
Prospect: "We've got four fryers."
Agent: "How often do you change the oil?"

✓ Good (Acknowledgment):
Prospect: "We've got four fryers."
Agent: "Got it-four fryers. And how often do you change the oil?"

Prospect: "Wait, before we continue-how much is this going to cost?"

Agent: "Good question. The exact pricing depends on your volume-I'll 
cover that in just a second. Let me just get one more detail first 
so I can give you an accurate number. How often do you change the oil?"

interface MustHaveData {
  qualification: {
    // Information needed to determine if they're a fit
    // Example: service area, volume threshold, decision-maker status
  };
  delivery: {
    // Information needed to deliver next step
    // Example: email address (if sending agreement)
  };
  identification: {
    // Minimum info to find them later
    // Example: first name + company OR first name + phone
  };
}

Phone Friction Cost = (questions asked) × (avg seconds per question) × (drop-off risk per question)
Form Friction Cost = (empty fields) × (completion difficulty) × (abandonment risk per field)

interface HardDisqualifiers {
  serviceArea: {
    check: (location: string) => boolean;
    exitScript: "We don't service that area yet...";
  };
  minimumVolume: {
    check: (volume: number) => boolean;
    exitScript: "For that volume, our service doesn't quite work...";
  };
  // etc.
}

interface SoftQualifiers {
  volumeTier: 'high' | 'medium' | 'low';
  timeline: 'immediate' | 'this_quarter' | 'exploring';
  hasCurrentVendor: boolean;
  locationCount: number;
}

┌─────────────────────────────────────────┐
│           ALL CONNECTED CALLS            │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│    HARD DISQUALIFIER CHECK (Early)      │
│    - Service area?                       │
│    - Minimum threshold?                  │
└─────────────────────────────────────────┘
                    │
        ┌──────────┴──────────┐
        │                     │
   [DISQUALIFIED]        [PASSES]
        │                     │
        ▼                     ▼
   Exit gracefully    ┌─────────────────────────────────────────┐
                      │      SOFT QUALIFIER COLLECTION          │
                      │      - Volume/tier                      │
                      │      - Timeline                         │
                      │      - Current situation                │
                      └─────────────────────────────────────────┘
                                          │
                                          ▼
                      ┌─────────────────────────────────────────┐
                      │         NEXT STEP EXECUTION             │
                      │         - Send agreement                │
                      │         - Book meeting                  │
                      │         - Route to human                │
                      └─────────────────────────────────────────┘

[Acknowledge their situation]
[Explain why fit isn't right-make it about logistics, not them]
[Offer alternative or future path]
[End warmly]

Example:
"Got it-for that volume, our truck routes don't quite pencil out 
economically. We need about [threshold] to make the logistics work. 
You might want to check [alternative]. But if things change on your 
end, definitely give me a call back. Appreciate your time."

Prospect: "I need to think about it."

Listen: [Let them finish]

Acknowledge: "Totally fair-it's not a small decision."

Inquire: "Is there something specific you're unsure about, or is it more about timing?"

[Based on their answer, resolve the actual concern]

Resolve (if timing): "No pressure at all. I'll send the agreement so you have it when you're ready."
Resolve (if uncertainty): "What would you need to see to feel good about moving forward?"

Don't: Give a specific number that may not apply.
Do: Give a range or framework, then redirect to deliverable.

"It depends on your volume-typically [range]. The exact pricing is in the 
agreement. Want me to send it over so you can see the specifics?"

Don't: Push or create artificial urgency.
Do: Respect, make next step easy, leave door open.

"Totally understand. I'll send the agreement now so you have it when you're 
ready. No pressure-take a look and let me know if any questions come up."

Don't: Bash the competitor.
Do: Surface pain, offer comparison value.

"Totally makes sense-most [businesses] do. Out of curiosity, how happy 
are you with them? When something goes wrong, are you able to get help quickly?"

Don't: Refuse or over-qualify before sending.
Do: Agree, but try to get one qualification point first.

"Yeah, absolutely. Quick question first-[single most important qualifier]? 
Just want to make sure I send you the right info."

Don't: End the conversation.
Do: Arm them or route to decision-maker.

"No problem. Who handles this decision? I can either reach out to them 
directly, or I can send you something to pass along-whatever's easier."

"Perfect-so you've got 4 fryers, changing oil twice a week, and you're 
in [city]. You'd definitely qualify for our service."

"What I'll do now is send over the service agreement so you can see 
everything in writing."

"What's the best email to send that to?"

"You'll get it in the next few minutes. You can sign directly from 
the email whenever you're ready."

"Any questions, just call or text this number."

Agent: "Perfect-based on what you told me, you'd definitely qualify for 
rebates. I'll send over the service agreement so you can see everything 
in writing."

Agent: "What's the best email to send that to?"

Prospect: "john@bigtonys.com"

Agent: "Got it-J-O-H-N at big tonys dot com?"

Prospect: "Yeah."

Agent: "Cool-I'll send it in the next couple minutes. You'll fill in 
the address and a few details, then you can sign right from the email. 
Any questions, just call or text this number back."

Prospect: "Sounds good."

Agent: "Appreciate it-talk soon."

"I hear you-let me get you to someone who can help with that."

"What's the best number to reach you, and when's a good time?"

"Someone will call you back within [timeframe]."

interface HandoffRecord {
  prospectName: string;
  prospectPhone: string;
  preferredCallbackTime?: string;
  conversationSummary: string;
  prospectNeed: string;
  qualificationData: Partial<QualificationData>;
  handoffReason: 'requested_human' | 'complex_question' | 'service_issue' | 'edge_case';
}

# SYSTEM PROMPT: [Agent Name] for [Company] ([Context/Scenario])

## 1. Persona and Core Goal
- Role/identity
- Context/scenario
- Primary objective
- Personality and tone

## 2. Available Data
- What information is available pre-call
- Variable placeholders and their sources

## 3. Conversational Rules
- Short turns
- One question at a time
- Linear flow
- Specific constraints

## 4. Conversation Flow
- Stage 1: [Opening]
- Stage 2: [Qualification]
- Stage 3: [Offer/Collection]
- Stage 4: [Close]
- [Each stage with scripts and response handling]

## 5. Protocols
- Objection handling
- Edge case handling
- Escalation triggers
- Error recovery

## 6. Company Knowledge
- Service/product details
- Pricing guidelines (what to say, what not to say)
- Differentiators
- Service area / constraints

## 7. Operational Constraints
- Legal requirements
- Disclosure rules
- Topics to avoid
- Boundaries

## 1. Persona Definition

**Role:** [Name], [Title] at [Company]
**Context:** [What situation triggers this conversation]
**Objective:** [Primary goal of the conversation]
**Personality:** [2-3 adjectives describing demeanor]
**Tone:** [Where on the spectrum from formal to casual]

Formal ─────────────────────────────────────────────────── Casual
   │                         │                              │
   │                         │                              │
"Good afternoon,         "Hi [Name],                    "Hey, quick
I'm calling from         this is [Agent]                question-"
[Company] regarding      from [Company]."
your recent inquiry."

**Voice Characteristics:**
- Pace: [Normal / Slightly Faster / Slightly Slower]
- Energy: [Calm / Moderate / Enthusiastic]
- Pauses: [Minimal / Natural / Deliberate]

**Avoid:**
- Sounding like a telemarketer (high energy, scripted feel)
- Sounding like a robot (monotone, no acknowledgments)
- Sounding desperate (too many qualifiers, excessive politeness)
- Sounding scripted (identical phrasing every time)

interface ConversationState {
  name: string;
  goal: string;
  entryCondition: string;
  script: string;
  responseHandling: ResponseHandler[];
  exitConditions: ExitCondition[];
  fallback: string;
}

interface ResponseHandler {
  condition: string;  // What the prospect says/does
  action: string;     // What the agent does
  nextState?: string; // Where to go next
}

interface ExitCondition {
  condition: string;
  nextState: string;
}

### STATE: Volume Qualification

**Goal:** Determine if prospect meets volume threshold

**Entry Condition:** Location confirmed in service area

**Script:** "How many fryers are you running?"

**Response Handling:**

| Response | Action | Next State |
|----------|--------|------------|
| [Number provided] | Store, acknowledge: "Got it-[X] fryers." | Frequency Question |
| "I don't know" | Use fallback question | Fallback: Direct Volume |
| [Off-topic response] | Redirect gently | (Stay in state) |
| [Clearly disqualifying] | Move to disqualification | Disqualification |

**Fallback:** 
"No worries-do you go through at least 50 gallons a month? Like a drum or more?"

**Exit Conditions:**
- Fryer count captured → Frequency Question
- Direct volume confirmed ≥ threshold → Collect Details
- Volume < threshold → Disqualification

                    ┌─────────────┐
                    │   OPENING   │
                    └──────┬──────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
              ▼            ▼            ▼
         [Confirmed]  [Unclear]   [Wrong Number]
              │            │            │
              │            │            ▼
              │            │       ┌─────────┐
              │            │       │   END   │
              │            │       └─────────┘
              │            │
              └──────┬─────┘
                     │
                     ▼
              ┌─────────────┐
              │  LOCATION   │
              │   CHECK     │
              └──────┬──────┘
                     │
         ┌───────────┼───────────┐
         │           │           │
         ▼           ▼           ▼
    [In Area]   [Out of Area]  [Unclear]
         │           │           │
         │           ▼           │
         │    ┌─────────────┐    │
         │    │ DISQUALIFY  │    │
         │    └─────────────┘    │
         │                       │
         └───────────┬───────────┘
                     │
                     ▼
              ┌─────────────┐
              │   VOLUME    │
              │   CHECK     │
              └──────┬──────┘
                     │
                    ...

**Universal Redirect Patterns:**

| Prospect Action | Response |
|-----------------|----------|
| Asks question before you're ready | "Good question-let me get one more detail first, then I'll cover that." |
| Goes off-topic | "Got it. Let me just finish up here and then we can discuss that." |
| Tries to end call early | "I hear you-just need your email and you're all set." |
| Asks something you can't answer | "That's covered in the agreement-want me to send it over?" |

Agent: "How many fryers are you running?"

Expected Responses:
- "Three."
- "We have 4."
- "About five or six."

Handling: Acknowledge, store, continue.
"Got it-[X] fryers."

Agent: "How many fryers are you running?"

Ambiguous Responses:
- "A few."
- "Not sure."
- "What do you mean?"

Handling: Clarify without making them feel dumb.
"Ballpark is fine-like 2, 4, more than that?"

Agent: "How many fryers are you running?"

Tangential Response:
- "We're actually a pretty small operation."
- "We do a lot of fried food."

Handling: Extract signal, reframe, or re-ask.
"Got it-so on the smaller side. Would you say 2 fryers? 3?"

Agent: "How many fryers are you running?"

Objection Response:
- "Why do you need to know that?"
- "What's this about?"

Handling: Explain rationale, then continue.
"Just trying to see if you'd qualify for rebates-based on volume. So roughly how many?"

Agent: "Where's your restaurant located?"

Disqualifying Response:
- "We're in California."
- [Outside service area]

Handling: Exit gracefully.
"Ah, we don't service California yet-we're on the East Coast currently. 
If we expand that way, I can reach back out. Appreciate your time."

**Catch-All Response:**
"Got it. Let me make sure I understand-[paraphrase what you think they meant]. 
Is that right?"

If still unclear after one clarification:
"Tell you what-let me send over the details and you can take a look. 
What's the best email?"

## 6. Company Knowledge

**Service Description:**
[One paragraph describing what the company does in plain language]

**Key Differentiators:**
- [Differentiator 1-what you do differently]
- [Differentiator 2-what outcome this produces]
- [Differentiator 3-what risk this removes]

**Qualification Thresholds:**
- Minimum: [threshold]
- Service area: [regions/states]
- Decision-maker requirement: [yes/no]

**Pricing Framework:**
- Structure: [How pricing works-tiers, per-unit, flat, etc.]
- Range: [General range-"typically between X and Y"]
- What to say: "The exact pricing is in the agreement based on your volume."
- What NOT to say: [Specific numbers, guarantees, promises]

**Redirect Phrases for Complex Questions:**
- "That's covered in detail in the agreement."
- "Let me send that over so you can see the specifics."
- "I want to make sure you have accurate info-let me send the documentation."

**Unknown Question Protocol:**

1. Don't guess or make up information
2. Don't say "I don't know" bluntly
3. Do redirect to authoritative source

Script:
"That's a good question-I want to make sure you get accurate info on that. 
It's covered in the agreement I'll send over, or you can ask that when we follow up."

## 7. Operational Constraints

**Legal:**
- Only call between [times] in prospect's local time
- If asked if this is recorded, say: "This call may be recorded for quality purposes."
- If asked if this is AI, say: [Disclosure script]
- Do not call numbers on suppression list

**Operational:**
- Service area: [List of valid regions]
- Cannot commit to specific pricing without agreement
- Cannot promise specific timelines for delivery/service
- Must escalate: [List of escalation triggers]

**Brand:**
- Do not disparage competitors by name
- Do not discuss: [List of off-limits topics]
- Do not use: [List of forbidden phrases]
- Do not promise: [List of things you cannot guarantee]

**Data:**
- Email is only delivery method (no SMS for agreements)
- Always confirm email spelling
- Do not collect: [Sensitive data you shouldn't capture]

**AI Disclosure Protocol:**

If REQUIRED (by law or policy):
Opening: "Hi, this is [Name], an AI assistant from [Company]..."

If REQUESTED by prospect:
Prospect: "Is this a robot?" / "Am I talking to AI?"

Response:
"Yeah, I'm an AI assistant. But I can answer your questions and get you 
set up. What did you want to know?"

[If they demand human:]
"No problem-let me get your info and have someone call you back. 
What's your name and the best number?"

**Opening:**
"Hey, is this [firstName]?"

[If yes:]
"Great-calling about [companyName/formTopic] and the form you just filled out. Got a quick second?"

**Qualification (Light):**
The form likely captured basic qualification. Confirm and supplement:

"Just to make sure I send you the right info-[key qualification question based on what form didn't capture]?"

**Transition to Close:**
"Perfect-based on that, you'd be a good fit. I'll send over [deliverable]. 
You have [email from form]-that still the best one?"

**Close:**
"Cool-sending it now. You'll see everything in there-[brief description]. 
Any questions, just call this number back."

✓ "I have [restaurantName] on file-that correct?"
✗ "What's the name of your restaurant?"

Prospect: "I'm actually filling out more info right now."

Agent: "Oh perfect-I'll let you finish. Just wanted to make sure you got 
through okay. Any questions as you go?"

Prospect: "I was just browsing, didn't mean to submit."

Agent: "No worries-happens all the time. Are you still in the market for 
[solution], or were you just researching?"

[If still interested:] "Want me to send some info for when you're ready?"
[If not:] "Totally fair. If anything changes, you've got my number."

**Opening:**
"Hey [firstName], this is [Agent] from [Company]. You reached out through 
our website-wanted to see what I can help you with."

**Intent Discovery:**
Let them explain. Then clarify if needed:

"Got it. So you're looking for [paraphrase]-is that right?"

**Qualification:**
Based on their stated need, qualify against your criteria:

"Let me ask a couple questions to make sure we can help. [Qualification questions]"

**Route:**
Based on qualification + need:
- Qualified + ready: Send agreement/book meeting
- Qualified + researching: Send info, set follow-up
- Not qualified: Explain why, offer alternative

type InboundIntent = 
  | 'ready_to_buy'      // "I want to sign up"
  | 'comparing_options' // "What makes you different from X?"
  | 'has_question'      // "I wanted to ask about..."
  | 'wrong_fit'         // "Do you do [thing you don't do]?"
  | 'existing_customer' // "I already use you and have an issue"
  | 'unclear';          // Can't determine

function handleByIntent(intent: InboundIntent): NextStep {
  switch (intent) {
    case 'ready_to_buy':
      return { action: 'qualify_briefly_then_close' };
    case 'comparing_options':
      return { action: 'differentiate_then_qualify' };
    case 'has_question':
      return { action: 'answer_then_qualify' };
    case 'wrong_fit':
      return { action: 'clarify_and_potentially_disqualify' };
    case 'existing_customer':
      return { action: 'route_to_service' };
    case 'unclear':
      return { action: 'ask_clarifying_question' };
  }
}

**Opening:**
"Hey, this is [Agent]-you just replied to my email about [topic]. Got a minute?"

**Context Acknowledgment:**
Reference what they said in the reply:

[If they asked a question:]
"You asked about [X]-let me give you the quick version."

[If they said "send info":]
"Happy to send that over-let me ask a quick question first to make 
sure I send the right thing."

[If they expressed strong interest:]
"Sounds like this is something you're looking at now-let me get a few 
details and I can send over everything you need."

**Qualification:**
Full qualification-don't assume fit based on email reply alone.

**Close:**
Based on qualification, send appropriate next step.

function extractPhoneFromSignature(emailBody: string): string | null {
  // Common signature patterns
  const phonePatterns = [
    /(?:phone|tel|cell|mobile|m|p)[:\s]*([+\d\s\-().]+)/i,
    /(\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4})/,
  ];
  
  for (const pattern of phonePatterns) {
    const match = emailBody.match(pattern);
    if (match) return normalizePhone(match[1]);
  }
  return null;
}

**Opening:**
"Hey [firstName], this is [Agent] from [Company]. I sent you a few emails 
about [topic]-figured a quick call might be easier. Got 30 seconds?"

**Engagement Check:**
"Did any of those land in your inbox, or did they get buried?"

[This is diagnostic-if they say "I saw them," they chose not to reply]
[If they say "didn't see them," they might be warmer than expected]

**Value Re-pitch:**
Offer the value proposition in a new way:

"Quick version: [one-sentence value prop]. Most [personas] we talk to are 
dealing with [pain]-is that something you've run into?"

**Qualification:**
If they engage, run standard qualification.

**Exit:**
If they're clearly not interested:
"No problem. If anything changes, you've got my number. Appreciate your time."

interface EmailEngagement {
  emailsSent: number;
  emailsOpened: number;
  linksClicked: number;
}

function shouldCallNonResponder(engagement: EmailEngagement): boolean {
  // Only call if they opened at least 2 emails (shows awareness)
  // Or clicked any link (shows interest)
  return engagement.emailsOpened >= 2 || engagement.linksClicked > 0;
}

**Opening (< 10 seconds):**
"Hey [firstName], quick question-[highly relevant question that earns attention]?"

Example:
"Hey John, quick question-do you ever have trouble getting your grease vendor 
to answer when something goes wrong?"

[Notice: No company name, no intro, no "how are you." Straight to relevance.]

**If They Engage:**
"Got it. The reason I ask-I handle [service] for [similar businesses] in [area]. 
Most people I talk to are dealing with [pain]. Is that something you're running into?"

**Qualification:**
If they engage, run standard qualification.

**If They Push Back:**
"Hey, I caught you at a bad time-when's better to call back?"
[If they give time, you've converted to a warm callback]
[If they say never, exit gracefully]

"Hey [firstName], this is [Agent] from [Company]. We help [personas] with 
[outcome]. I don't know if that's relevant for you-is it okay if I ask 
a quick question to see?"

**Opening:**
"Hey [firstName], this is [Agent] from [Company]. We talked a few months 
back about [topic]. Wanted to check if anything's changed on your end."

**Situation Check:**
"Last time we spoke, you mentioned [previous objection/situation]. 
Is that still the case, or has anything shifted?"

**Requalification:**
If circumstances changed, re-run qualification:
"Got it. Let me ask-[qualification question]."

**Close or Nurture:**
[If ready now:] Move to close
[If still not ready:] "No problem. When would be a good time to check back?"

interface StaleLeadRule {
  daysInactive: number;
  previousOutcome: string;
  action: string;
}

const reactivationRules: StaleLeadRule[] = [
  { daysInactive: 30, previousOutcome: 'timing_objection', action: 'ai_call' },
  { daysInactive: 60, previousOutcome: 'lost_to_competitor', action: 'email_then_call' },
  { daysInactive: 90, previousOutcome: 'no_response', action: 'email_only' },
  { daysInactive: 180, previousOutcome: 'any', action: 'fresh_sequence' },
];

**Opening (Context-Aware):**
[Based on number placement-see above]

**Intent Discovery:**
"What can I help you with?"

OR if placement provides context:
"You calling about [likely topic]?"

**Classification:**
Quickly determine:
- Are they a prospect? → Qualify and advance
- Are they an existing customer? → Route to service
- Are they confused/wrong number? → Clarify and exit

**Qualification:**
If prospect, run standard qualification.

**Close:**
Based on qualification, route to appropriate next step.

interface PhoneNumberRouting {
  number: string;
  placement: string;
  aiAgentContext: string;
  defaultOpener: string;
}

const numberRouting: PhoneNumberRouting[] = [
  {
    number: '+1-555-001-0001',
    placement: 'cold_email_signature',
    aiAgentContext: 'caller_received_cold_email',
    defaultOpener: "Hey, this is [Agent]-you calling about the email?",
  },
  {
    number: '+1-555-001-0002',
    placement: 'website_contact_page',
    aiAgentContext: 'caller_from_website',
    defaultOpener: "Hey, this is [Agent]-how can I help you?",
  },
  {
    number: '+1-555-001-0003',
    placement: 'google_ads',
    aiAgentContext: 'caller_from_ad',
    defaultOpener: "Hey, this is [Agent]-you calling about [ad topic]?",
  },
];

interface EmailTriggerRule {
  trigger: 'opened' | 'clicked' | 'replied' | 'bounced';
  count?: number;
  delay: number; // milliseconds
  action: 'call' | 'sms' | 'none';
}

const emailTriggers: EmailTriggerRule[] = [
  // Positive reply → call immediately
  { trigger: 'replied', delay: 0, action: 'call' },
  
  // Clicked link → call within 5 minutes
  { trigger: 'clicked', delay: 300000, action: 'call' },
  
  // Opened 3+ times → call
  { trigger: 'opened', count: 3, delay: 0, action: 'call' },
];

Email 1 (Day 1)
Email 2 (Day 4)
Email 3 (Day 9)
AI Call (Day 12) ← For engaged non-responders
Email 4 (Day 15) ← Reference the call attempt

interface CallOutcomeEmail {
  outcome: CallOutcome;
  emailTemplate: string;
  delay: number;
}

const callOutcomeEmails: CallOutcomeEmail[] = [
  // No answer → send "tried to call" email
  { outcome: 'no_answer', emailTemplate: 'voicemail_followup', delay: 0 },
  
  // Sent agreement → send "agreement sent" confirmation
  { outcome: 'agreement_sent', emailTemplate: 'agreement_confirmation', delay: 60000 },
  
  // Interested but not ready → send nurture content
  { outcome: 'interested_not_ready', emailTemplate: 'nurture_content', delay: 86400000 },
];

interface ConversationContext {
  // Email history
  emailsSent: {
    subject: string;
    sentAt: Date;
    opened: boolean;
    clicked: boolean;
    replied: boolean;
  }[];
  
  // Key points from emails
  valuePropsPresented: string[];
  proofsPresented: string[];
  ctasUsed: string[];
  
  // For AI reference
  lastEmailSummary: string;
}

"I sent you an email about [topic from lastEmailSummary]-wanted to follow up."

[Leave 15-second voicemail]

[Immediately send SMS]
"Hey [name]-just left you a voicemail about [topic]. 
[One-line value]. Text me back if interested."

"Hey [name], this is [Agent] from [Company]. Going to give you a 
quick call about [topic] in a few minutes. If now's bad, 
let me know a better time."

"Thanks for chatting, [name]. Just sent the [deliverable] to 
[email]. Let me know if you have questions."

"Hey [name]-tried calling a couple times about [topic]. 
If you prefer, just text me back. [One-line value]."

interface SMSTemplate {
  trigger: string;
  template: string;
  maxLength: 160;
  requiresOptIn: boolean;
}

const smsTemplates: SMSTemplate[] = [
  {
    trigger: 'voicemail_left',
    template: 'Hey {{firstName}}-just left you a voicemail about {{topic}}. {{valueOneLiner}} Text back if interested.',
    maxLength: 160,
    requiresOptIn: false, // Existing business relationship
  },
];

interface InboundLeadContext {
  // Identity
  lead: {
    firstName: string;
    lastName?: string;
    email: string;
    phone: string;
    company?: string;
  };
  
  // Source
  source: {
    type: 'form_fill' | 'cold_email' | 'inbound_call' | 'referral';
    campaign?: string;
    adSet?: string;
    referrer?: string;
  };
  
  // History
  history: {
    previousCalls: CallRecord[];
    emailEngagement: EmailEngagement;
    previousQualification?: QualificationData;
    notes: string[];
  };
  
  // Timing
  timing: {
    leadCreatedAt: Date;
    lastContactAt?: Date;
    timezone: string;
  };
}

interface CallOutcome {
  // Call metadata
  callId: string;
  startTime: Date;
  endTime: Date;
  duration: number;
  
  // Outcome
  outcome: 
    | 'qualified_sent_agreement'
    | 'qualified_meeting_booked'
    | 'qualified_interested_not_ready'
    | 'disqualified_reason'
    | 'no_answer'
    | 'wrong_number'
    | 'callback_requested'
    | 'escalated_to_human';
  
  // Qualification data (if collected)
  qualification?: {
    meetsVolumeThreshold?: boolean;
    inServiceArea?: boolean;
    isDecisionMaker?: boolean;
    timeline?: string;
    currentSituation?: string;
  };
  
  // Contact info (if updated)
  contactUpdates?: {
    email?: string;
    phone?: string;
    company?: string;
    title?: string;
  };
  
  // Follow-up
  followUp?: {
    type: 'callback' | 'email' | 'human_handoff' | 'nurture';
    scheduledFor?: Date;
    notes: string;
  };
  
  // Transcript
  transcript: string;
  summary: string;
}

interface OutcomeAction {
  outcome: string;
  actions: Action[];
}

const outcomeActions: OutcomeAction[] = [
  {
    outcome: 'qualified_sent_agreement',
    actions: [
      { type: 'update_lead_status', status: 'agreement_sent' },
      { type: 'send_email', template: 'agreement_confirmation' },
      { type: 'create_task', task: 'follow_up_in_48h' },
      { type: 'notify_ae', message: 'Agreement sent to {{name}}' },
    ],
  },
  {
    outcome: 'callback_requested',
    actions: [
      { type: 'schedule_callback', time: '{{requestedTime}}' },
      { type: 'update_lead_status', status: 'callback_scheduled' },
    ],
  },
  {
    outcome: 'escalated_to_human',
    actions: [
      { type: 'create_urgent_task', assignee: 'sales_team' },
      { type: 'update_lead_status', status: 'needs_human_attention' },
      { type: 'notify_slack', channel: 'sales_escalations' },
    ],
  },
];

interface EscalationPackage {
  // Who
  prospect: {
    name: string;
    phone: string;
    email?: string;
    company?: string;
  };
  
  // What happened
  conversationSummary: string;
  escalationReason: string;
  prospectRequest?: string;
  
  // What we know
  qualificationData: Partial<QualificationData>;
  objectionsSurfaced: string[];
  
  // What they need
  prospectNeeds: string;
  suggestedNextStep: string;
  
  // Context
  callTranscript: string;
  callRecording?: string;
  
  // Urgency
  priority: 'urgent' | 'normal' | 'low';
  callbackTimeRequested?: Date;
}

**Acknowledge the request:**
"Absolutely-let me get you to someone who can help with that."

**Collect callback info:**
"What's the best number to reach you?"
"And when's a good time for them to call?"

**Set expectations:**
"Someone will call you back within [timeframe]."

**Summarize for human:**
[Internal: Log escalation package with all context]

**Close:**
"Is there anything else I can note for them before we hang up?"

interface HandoffMethod {
  type: 'warm_transfer' | 'callback';
  availability: 'business_hours' | '24_7';
  maxWaitTime?: number; // for warm transfer queue
  callbackSLA: string; // "within 2 hours"
}

**Universal Recovery Pattern:**

"You know what-I want to make sure I get this right. Let me have someone 
follow up with you on that specific question. What's the best number to 
reach you?"

[This works for almost any failure-you're not pretending to know, and 
you're ensuring the prospect gets help.]

**Detection:** Keywords "robot," "AI," "real person," "automated," "bot"

**Response (Honest + Competent):**
"Yeah, I'm an AI assistant. But I can answer your questions and get you 
set up. What did you want to know?"

**If They Demand Human:**
"No problem-let me get your info and have someone call you back. What's 
your name and the best number?"

**Don't:**
- Lie ("No, I'm a real person")
- Be defensive
- Over-explain AI capabilities

**Detection:** "This isn't [name]" / "Who?" / "Wrong number"

**Response (Polite Routing):**
"Oh, sorry about that. I'm trying to reach whoever handles [responsibility]. 
Is that you, or is there someone else I should talk to?"

**If They Route You:**
"Great-what's their name and the best number or extension?"

**If Dead End:**
"No problem. Appreciate your time."

**Detection:** Mentions of service issues, problems, complaints, existing account

**Response (Route to Service):**
"Got it-sounds like a service issue. Let me get your info and I'll have 
someone from our operations team call you right away. What's the restaurant 
name and the address?"

**Don't:**
- Try to solve the service issue
- Treat them like a new lead
- Leave them without a clear next step

**Do:**
- Collect info needed to identify their account
- Set expectation for callback timing
- Log urgency appropriately

**Detection:** Profanity, yelling, personal attacks, aggressive tone

**Response (De-escalate, then Exit):**

Level 1 (Frustrated):
"I understand you're frustrated. Let me see what I can do to help."

Level 2 (Angry):
"I hear you. This doesn't seem like a good time. I can have someone 
call you back when things calm down."

Level 3 (Abusive):
"I'm going to let you go for now. If you'd like to discuss this later, 
you can call back."

**Rule:** AI should never engage with abuse. Exit quickly and cleanly.

**Detection:** Questions about pricing lists, client lists, proprietary processes

**Response (Deflect Gracefully):**
"I can send you our standard materials that cover how things work. 
What's the best email?"

**If They Press:**
"The details are in the agreement. If you're interested in service, 
I can get that sent over."

**Don't:**
- Reveal client names not in public materials
- Quote specific internal pricing
- Discuss proprietary processes in detail

**Detection:** Requests for another language, ASR failures, limited vocabulary

**Response (Accommodate if Possible):**

If AI supports the language:
"Claro, puedo hablar español. ¿Cómo puedo ayudarle?"

If not:
"I'm sorry, I only speak English. Is there someone there who can translate, 
or would you prefer I send information by email?"

**Alternative:**
"Let me have someone who speaks [language] call you back. What's the 
best number?"

interface ErrorLog {
  // Context
  callId: string;
  timestamp: Date;
  conversationState: string;
  
  // Error details
  errorType: 'connection' | 'comprehension' | 'intent' | 'script' | 'data';
  errorSubtype: string;
  errorMessage: string;
  
  // What happened
  prospectUtterance?: string;
  aiResponse: string;
  recoveryAttempted: boolean;
  recoverySuccessful?: boolean;
  
  // Outcome
  callContinued: boolean;
  finalOutcome: string;
  
  // For analysis
  transcript: string;
  audioClip?: string;
}

interface ErrorAnalysis {
  // Frequency
  errorType: string;
  occurrences: number;
  percentageOfCalls: number;
  
  // Impact
  callDropRate: number; // How often this error kills the call
  recoveryRate: number; // How often we recover from it
  
  // Patterns
  commonTriggers: string[];
  commonProspectPhrases: string[];
  
  // Action
  suggestedPromptChange?: string;
  suggestedNewHandler?: string;
  priority: 'critical' | 'high' | 'medium' | 'low';
}

┌────────────────────────────────────────────┐
│           CALLS ATTEMPTED                   │
└────────────────────────────────────────────┘
                    │
                    ▼ Connection Rate
┌────────────────────────────────────────────┐
│           CALLS CONNECTED                   │
└────────────────────────────────────────────┘
                    │
                    ▼ Completion Rate
┌────────────────────────────────────────────┐
│         CONVERSATIONS COMPLETED             │
└────────────────────────────────────────────┘
                    │
                    ▼ Qualification Rate
┌────────────────────────────────────────────┐
│           LEADS QUALIFIED                   │
└────────────────────────────────────────────┘
                    │
                    ▼ Conversion Rate
┌────────────────────────────────────────────┐
│         NEXT STEP COMPLETED                 │
│   (Agreement sent, meeting booked, etc.)    │
└────────────────────────────────────────────┘

interface AIVoiceMetrics {
  // Volume
  callsAttempted: number;
  callsConnected: number;
  conversationsCompleted: number;
  
  // Rates
  connectionRate: number;      // connected / attempted
  completionRate: number;      // completed / connected
  qualificationRate: number;   // qualified / completed
  conversionRate: number;      // converted / qualified
  
  // Efficiency
  averageHandleTime: number;   // seconds
  averageCostPerCall: number;  // dollars
  averageCostPerConversion: number;
  
  // Quality
  dropOffByStage: Record<string, number>;
  objectionFrequency: Record<string, number>;
  errorRate: number;
  escalationRate: number;
}

interface StageMetrics {
  stageName: string;
  entryCount: number;
  exitCount: number;
  dropOffCount: number;
  dropOffRate: number;
  averageTimeInStage: number;
  commonDropOffReasons: string[];
}

// Example output:
// Opening:      1000 entry, 950 exit, 5% drop (hang up immediately)
// Qualification: 950 entry, 800 exit, 16% drop (disqualified or quit)
// Collection:    800 entry, 780 exit, 2.5% drop (refused to give email)
// Close:         780 entry, 750 exit, 4% drop (changed mind at end)

interface CohortMetrics {
  cohortDefinition: string;
  sampleSize: number;
  connectionRate: number;
  qualificationRate: number;
  conversionRate: number;
  significanceVsBaseline: number; // statistical significance
}

interface TranscriptAnnotation {
  transcriptId: string;
  timestamp: number; // seconds into call
  annotationType: 
    | 'script_issue'      // Script didn't handle well
    | 'ai_error'          // AI misunderstood or responded poorly
    | 'prospect_signal'   // Interesting prospect behavior
    | 'win_moment'        // What caused success
    | 'loss_moment'       // What caused failure
    | 'improvement_idea'; // Suggestion for improvement
  note: string;
  suggestedChange?: string;
  priority: 'high' | 'medium' | 'low';
}

interface PromptChangeLog {
  changeId: string;
  date: Date;
  triggeredBy: string; // annotation IDs
  section: string; // which part of prompt
  previousVersion: string;
  newVersion: string;
  rationale: string;
  expectedImpact: string;
  actualImpact?: string; // filled after A/B test
}

interface PromptABTest {
  testId: string;
  hypothesis: string;
  controlVersion: string;
  testVersion: string;
  trafficSplit: number; // 0.5 = 50/50
  minimumSampleSize: number;
  primaryMetric: string;
  secondaryMetrics: string[];
  startDate: Date;
  endDate?: Date;
  status: 'running' | 'completed' | 'stopped';
  winner?: 'control' | 'test' | 'no_difference';
  liftObserved?: number;
  confidence?: number;
}

function calculateSampleSize(
  baselineRate: number,
  minimumDetectableLift: number,
  power: number = 0.8,
  confidence: number = 0.95
): number {
  // Simplified formula
  const alpha = 1 - confidence;
  const beta = 1 - power;
  const p1 = baselineRate;
  const p2 = baselineRate * (1 + minimumDetectableLift);
  
  // Using approximation
  const n = (
    (Math.pow(1.96 + 0.84, 2) * (p1 * (1 - p1) + p2 * (1 - p2))) /
    Math.pow(p2 - p1, 2)
  );
  
  return Math.ceil(n);
}

// Example: 30% baseline conversion, 10% lift detection
// calculateSampleSize(0.3, 0.1) → ~1,000 per variant