Meeting Prep Architecture

Step-by-Step User Flow

Here is exactly what the user sees and what happens at each step. These are live screenshots from Robert's account (Mark Pederson populated the contact and meeting data used here).

Step 1: Landing — Today's Meetings on Canvas

Three-panel layout: sidebar (left), canvas (center), context panel (right)

When you open Meeting Prep (/network?active-view=meeting-prep), the canvas shows today's meetings as rich cards. The sidebar shows all upcoming meetings grouped by day (Today, Tomorrow, Fri Apr 17, etc.). Each sidebar item shows the first participating company's logo. The right panel is empty until you select a meeting.

Step 2: Select a Meeting — See Classified Attendees

Mark/Robert Sync selected — canvas shows prep card, right panel shows classified attendees

Clicking a sidebar meeting shows a MeetingCard on the canvas with:

• Header: meeting title, time, duration, relative time ("in 19h")
• Participants: classified by company — "Orbiter.io" label with Mark Pederson
• Outcome input: "What is the ideal outcome of this meeting?"
• "Prep this meeting" green button (the gate to CrayonChat)

The right context panel shows: meeting title, date, time, duration, video call indicator, and the full classified attendee list with titles.

Step 3: Multi-Participant Meeting

HAPPY FRIDAY RETURNS — showing external participants Mario and Rene Castillo

Meetings with multiple external participants are classified into groups. Here, Mario and Rene Castillo show under the "PARTICIPANTS" section. The backend classify-participants function sorts these by company domain — same domain = grouped under one company logo.

Step 4: Meeting with Description

Jordan Cameron - Project Session — right panel shows meeting description

When a meeting has a description, it appears in the context panel below the attendees. Here: "Working session on mortgage CRM platform (Xano + Next.js)". This description is also included in the enriched prompt sent to the AI.

Step 5: Click "Prep this meeting" — CrayonChat Opens

After clicking "Prep this meeting" — CrayonChat loads with conversation starter

Clicking the green button flips prepStarted to true. The canvas switches from the MeetingCard to CrayonChat — a full SSE-streaming AI chat interface. The conversation starter button (Prep for "Block") contains a rich auto-generated prompt with all meeting context.

Step 6: AI Response — No In-Network Attendees

When no attendees are in the user's network, the AI asks for clarification

If no meeting participants are in the user's network (no master_person_id), the system falls back to POST /chat with mode=meeting. The AI asks "Who are you meeting with?" with interactive options: "I'll tell you the name", "Multiple people", "Not sure yet".

Step 7: In-Network Attendee — Meeting Goal Card

Mark Pederson is in-network — "Prep this meeting" triggers the meeting-prep endpoint

When a participant IS in the user's network (has a master_person_id), clicking prep sends POST /meeting-prep with that person's ID. If no user_goal is provided, the backend returns a MeetingGoalCard with 6 suggested goals:

1. Close a deal or partnership
2. Get an introduction to someone in their network
3. Pitch my product or idea
4. Build the relationship
5. Follow up on a previous conversation
6. Ask for advice or mentorship

After selecting a goal, the backend calls Claude Sonnet 4 with the full person context and returns a MeetingPrepCard with talking points, openers, landmines, and shared context.

Sidebar — Full Calendar View

Sidebar with meetings grouped by day — scrolled to show Tomorrow and Friday

What Meeting Prep Does

Meeting Prep analyzes calendar events, classifies attendees by company and relationship, and generates contextual talking points, openers, landmines, and shared context for each meeting. It spans 2 API groups, 4 core Xano functions, 15+ database tables, and 3 external services (Nylas, OpenRouter/Claude, Cloud Run).

Current State

End-to-End Data Flow

Google Calendar (user's events)
     |
     v
Nylas v3 API  (per grant_id, paginated, 200/page)
     |
     v
+------------------------------------------------------+
|  GET /calendar-events  (V2 Calendar Events, #4329)   |
|                                                       |
|  1. user table -> get working_timezone                |
|  2. calendar table -> get active calendars            |
|  3. utc-timestamps_v2 -> compute 14-day UTC range     |
|  4. FOR EACH calendar:                                |
|     +- fetch-calendar-events -> Nylas API (paginated) |
|  5. Lambda -> extract unique participant emails        |
|  6. Bulk query: master_email + master_person           |
|  7. Query my_person -> "New to Network" badges         |
|  8. nylas_grant -> email_account per grant_id          |
|  9. FOR EACH event:                                   |
|     +- classify-participants -> my_team / companies /  |
|        personal (email_provider, master_company)       |
|  10. Embed meeting_prep into each event                |
+------------------------+-----------------------------+
                         |
                         v
            Frontend: useCalendarEvents()
            +- Filters out past events
            +- Sorts by start_time
            +- Re-filters every 60 seconds
                         |
           +-------------+-------------+
           v                           v
     MeetingPrepList             MeetingPrepCanvas
     (sidebar, all days)         (today's events only)
           |                           |
           | click                     | "Prep this meeting"
           v                           v
     MeetingCard ----------------> setPrepStarted(true)
     (preview mode)                    |
                                       v
                              CrayonChat (SSE)
                                       |
                     +-----------------+
                     v                 v
          POST /meeting-prep    POST /chat (mode=meeting)
          (in-network person)   (no in-network person)
                     |
          +----------+-----------+
          v                      v
   No user_goal:          Has user_goal:
   -> MeetingGoalCard     -> get-person-context
   -> 6 suggested goals   -> build-memory-context
                          -> GET /calendar/events
                          -> Claude Sonnet 4 (OpenRouter)
                          -> MeetingPrepCard

GET /calendar-events — The Main Data Source

10-step processing chain: Google Calendar → Nylas → enrich → classify → Sidebar + Canvas

Processing Chain (10 Steps)

classify-participants Algorithm

Emails sorted into My Team (green), Participating Companies (purple), Personal Participants (amber)

Algorithm

Pass 1 — Classify each email by domain:

1. Extract domain from each participant email
2. If domain matches user's domain → my_team (same company)
3. Else, check email_provider table (gmail, yahoo, hotmail, etc.):
   • If personal domain → personal_participants
   • If corporate domain → add to companyDomains list for Pass 2
4. For each classified person, resolve master_email → master_person to get name, avatar, title

Build my_team: Query master_company by user's domain for company name + logo. Fall back to logo.dev if not in DB.

Pass 2 — Build participating_companies:

1. For each unique corporate domain, look up master_company by company_domain
2. Collect all participant emails with that domain
3. Resolve each to master_person via master_email
4. Fall back to logo.dev for missing company logos: https://img.logo.dev/{domain}?token=pk_...

Output Structure

{
  "my_team": {
    "master_company_id": 10,
    "name": "Orbiter",
    "logo": "https://...",
    "members": [
      { "master_person_id": 12, "name": "Mark Pederson", "avatar": "...", "title": "CEO" }
    ]
  },
  "participating_companies": [
    {
      "master_company_id": 20, "name": "JP Morgan", "logo": "...",
      "members": [{ "master_person_id": 530, "name": "Susan", "title": "VP" }]
    }
  ],
  "personal_participants": [
    { "master_person_id": 540, "name": "Bob", "title": "Consultant" }
  ]
}

POST /meeting-prep — The Intelligence Engine

Phase 1: ask for goal → Phase 2: gather context + Claude Sonnet 4 → MeetingPrepCard

Inputs

Phase 1: Ask-First (no user_goal)

If user_goal is empty, the endpoint returns immediately with suggested goals:

{
  "success": true,
  "needs_user_goal": true,
  "master_person_id": 520,
  "person": { "name": "Ray Deck", "title": "CEO", "avatar": "..." },
  "suggested_goals": [
    "Close a deal or partnership",
    "Get an introduction to someone in their network",
    "Pitch my product or idea",
    "Build the relationship",
    "Follow up on a previous conversation",
    "Ask for advice or mentorship"
  ]
}

Phase 2: Context Gathering (user_goal provided)

When a goal is provided, the endpoint gathers context from 4 sources:

1. Person context — calls get-person-context (#12570): work history, education, skills, roles, location. Returns YAML string.
2. User memories — calls build-memory-context (#12665): active memories from copilot_memory table, formatted as [USER MEMORY]...[/USER MEMORY] tags.
3. Requesting user info — fetches the authenticated user's name/title from user table with master_person addon.
4. Calendar events — creates a temp auth token and calls its own GET /calendar/events (#8125) for 14 days ahead, limited to 10 events.

Phase 3: LLM Call

Phase 4: Response

{
  "success": true,
  "master_person_id": 520,
  "person": { "name": "Ray Deck", "title": "CEO", "avatar": "..." },
  "prep": {
    "person_summary": "Ray is the CEO of StateChange, a Series A startup...",
    "talking_points": [
      {
        "topic": "Recent funding round",
        "opener": "I saw StateChange just closed their Series A...",
        "why_they_care": "They're scaling the team and looking for partnerships"
      }
    ],
    "suggested_openers": ["Congrats on the funding...", "How's the team scaling going?"],
    "listen_for": ["Signs of budget constraints", "Hiring challenges"],
    "landmines": ["Don't mention competitor X", "Avoid pricing discussions"]
  },
  "model": "anthropic/claude-sonnet-4"
}

POST /chat — Meeting Mode Fallback

Meeting Mode Differences

• System prompt: loaded from copilot_config table (name: "meeting") — instructs AI to provide briefings with TALKING POINTS, SUGGESTED OPENERS, WATCH OUT FOR sections
• Memory injection: build-memory-context appended to system prompt
• Person context: wrapped in [ACTIVE PERSON CONTEXT]...[/ACTIVE PERSON CONTEXT] tags
• Temperature: 0.7 (higher than meeting-prep's 0.4 for conversational flow)
• History: last 10 messages from conversation
• No dispatch: meeting mode is informational only (no dispatch_confirmation)

React Component Map & State Machine

File Inventory

Canvas State Machine (3 modes + context persistence)

No meeting selected         Meeting selected            Prep started
(prepStarted=false)         (prepStarted=false)         (prepStarted=true)
-----------------          -----------------           -----------------
Show today's meetings       Show single MeetingCard     Show CrayonChat
as rich cards               with classified attendees   with SSE streaming

     |                           |                          |
     | click sidebar item        | click "Prep this         | processMessage()
     +-------------------------->|  meeting" button         | handles:
                                 |                          | 1. getMeetingPrep()
                                 v                          | 2. [MEETING_GOAL] prefix
                          prepInitiatedRef = true           | 3. chat(mode=meeting)
                          createMeetingPrepContext()
                          triggerResearch() (fire & forget)
                          fetchEmailThreads() (fire & forget)
                          fetchPriorMeetings() (fire & forget)
                                 |
                                 +------------------------>|
                                                            |
On revisit: useEffect loads persisted context from
getMeetingPrepContext(eventId) — skips re-gathering

Enriched Prompt (auto-generated)

When CrayonChat opens, the conversation starter contains an auto-generated prompt built from the selected event:

1. Help me prepare for my meeting "[Title]"
2. Time + duration + relative time ("in 45 minutes")
3. Attendees list with network status + master_person_ids
4. Team members on call
5. "Pull full context on [network attendees] from my network"
6. Meeting description (first 500 chars)
7. Location / video call URL
8. Desired outcome (if user typed one before clicking "Prep this meeting") NEW
9. "Give me talking points, key context, and anything I should be prepared for"

URL State

Key Logic

Complete Table Map

Calendar & Events

Person & Company Identity

Context & Intelligence

Meeting Prep Context NEW

Copilot Chat

Supporting

Cloud Run → Webhook Pipeline

Xano → Cloud Run (async) → Webhook → deep_bio + bio_100/300/500 + knowledge graph

Xano: deep-research-person-or-company (#12747)
  |
  +- Inputs: master_person_id OR master_company_id
  |          model, temperature, max_tokens, request_type
  |          system_prompt, user_prompt, provider_order
  |
  +- Fetches person/company record from DB
  +- Builds OpenRouter-compatible payload (Lambda)
  |   +- Perplexity models: collapse system+user into single message
  |
  v
POST https://orbiter-enrich-20506320032.us-east4.run.app/enrich
  |  Query params: master_person_id or master_company_id
  |  Body: { webhook_url, payload: { model, messages, max_tokens } }
  |  Auth: X-API-Key header ($env.deep_research_api_key)
  |
  +- Creates profile_enrichment_job record (job_id, request_type, model)
  |
  v  (async — minutes of processing on Cloud Run)
  |
Webhook: POST /enrich-profile (#8303, webhooks group)
  |
  +- On success:
  |  +- Update profile_enrichment_job: llm_response, processing=false
  |  +- Write deep_bio to master_person record
  |  +- Run create-llm-person-bios -> generates bio_100, bio_300, bio_500
  |  +- Run update-person-node -> sync knowledge graph
  |
  +- On error:
     +- Update profile_enrichment_job: error, processing=false

Integration Map

Phase 1 Fixes — Frontend Only (No Backend Dependency)

Verified by Curl & Browser

Commit: 281900d on feat/meeting-prep-ui-overhaul

Context Persistence Pipeline (Phase 2 & 3)

Context persistence pipeline — gather once, persist forever, load instantly on revisit

The context persistence pipeline was built on April 15 — 8 Xano endpoints, 2 new tables, and full frontend integration. When a user clicks "Prep this meeting", the system:

1. Creates or loads a meeting_prep_context record (idempotent — POST returns existing if already created)
2. Triggers deep research for each in-network attendee (fire-and-forget to Cloud Run)
3. Fetches email threads from Nylas for participant emails (fire-and-forget)
4. Finds prior meetings with the same participants in the last 90 days (fire-and-forget)
5. Launches CrayonChat immediately — all background gathering runs in parallel

New API Endpoints (Robert API)

Meeting Transcriptions API

Frontend Integration

The canvas component (meeting-prep-canvas.tsx, now 1,247 LOC) integrates the context pipeline with a ref-guarded state machine:

const prepInitiatedRef = useRef(false);

// In onPrepMeeting handler:
prepInitiatedRef.current = true;   // Guard before state change
setSelectedId(id);                  // Triggers useEffect
setPrepStarted(true);               // Would be reset without guard

// In useEffect:
if (prepInitiatedRef.current) {
  prepInitiatedRef.current = false; // Consume the guard
  return;                           // Skip reset
}
setPrepStarted(false);              // Normal reset on navigation

XanoScript Fixes (Runtime-Discovered)

Full Flow Verified — April 15, 2026

Complete end-to-end testing: curl verified all 11 backend endpoints, then browser-tested the full meeting prep flow with live WorkOS auth and real Xano data.

Step 1: Select Meeting & Type Desired Outcome

User types "Close the partnership deal" — this persists to meeting_prep_context.desired_outcome

Step 2: CrayonChat Launches with Context Saved

CrayonChat launches — context persisted in Xano, deep research + email threads + prior meetings triggered in background

Step 3: AI Generates Full Meeting Prep

Full AI prep — market expansion strategy, talking points, and "Copy Brief" button

Step 4: Landmines & Follow-up

LANDMINES section warns about pitfalls — actionable intelligence for the meeting

Step 5: Continued Conversation

Follow-up conversation — AI suggests personal connection topics, planning strategies, and conversation recovery

Backend Curl Test Results

Commits: 1bd230f (context pipeline) + 4ed33e8 (race condition fix) on feat/meeting-prep-ui-overhaul

Remaining Work & Roadmap

Context Checklist (Gather Once, Persist)

Implementation Phases

Architecture Observations & Key Insights

What Changed

The meeting prep context pipeline was gathering data but never using it. Deep research bios, email threads, and prior meetings were stored in the meeting_prep_context table on Xano — but the LLM prompt never included them. Three fixes shipped today:

1. Context Injection into LLM Prompt

Before each getMeetingPrep() or chat() call, the system now re-fetches the latest context from Xano and builds a structured context string with three sections:

• Deep Research on Attendees — bios, titles, companies from deep research pipeline
• Recent Email Threads — subject lines, snippets, and participant emails from Nylas
• Previous Q&A — prior prep session questions and answers

This context is passed via the existing context parameter — no API changes needed.

2. Auto-Send on “Prep this meeting”

Previously, clicking “Prep this meeting” opened CrayonChat and showed a starter chip that the user had to click again. Now the message fires automatically — one click, prep starts immediately.

3. Informative Status Banner

The status banner was opaque — just “Gathering context...” then “Context ready” with no visibility into what was gathered. Now it shows specific items:

• While gathering: “Gathering context — found 10 email threads...”
• When ready: “Context ready — 2 bios, 10 emails, 3 prior Q&A”

4. Fire-and-Forget Fix

Three async calls (triggerMeetingPrepResearch, fetchMeetingPrepEmailThreads, fetchPriorMeetings) were discarding their results with .catch(console.warn). Now they re-fetch the context after completing, so subsequent LLM calls have the latest data.

All 8 meeting prep API endpoints curl-tested against live data (Mark/Robert Sync event):

4 Issues Found & Fixed During Browser Testing

Live E2E testing revealed four UX issues that were invisible during build-time verification. All four were found, fixed, and re-verified in a single session.

1. Auto-Send — Eliminate Double-Click Flow

2. Informative Status Banner

Before: meeting card with attendees

After: banner shows “found 10 email threads”

3. needs_user_goal Value Check CRITICAL

Before: wall of unformatted text

After: structured MeetingPrepCard

// BEFORE (broken — checks key existence):
if (!("needs_user_goal" in result)) { /* render meeting_prep_card */ }

// AFTER (correct — checks actual boolean value):
if (!(result as Record<string, unknown>).needs_user_goal) { /* render meeting_prep_card */ }

4. Clean Goal Message

// BEFORE (meeting-goal-card.tsx):
message: `[MEETING_GOAL] ${goal}`

// AFTER:
message: goal

// Detection moved from prefix matching to ref-based state machine:
// if (prompt.startsWith(MEETING_GOAL_PREFIX))  →  if (meetingGoalPendingRef.current)