investor-call-prep

# Investor Call Prep

## Setup

Read your credentials from ~/.gooseworks/credentials.json:
```bash
export GOOSEWORKS_API_KEY=$(python3 -c "import json;print(json.load(open('$HOME/.gooseworks/credentials.json'))['api_key'])")
export GOOSEWORKS_API_BASE=$(python3 -c "import json;print(json.load(open('$HOME/.gooseworks/credentials.json')).get('api_base','https://api.gooseworks.ai'))")
```

If ~/.gooseworks/credentials.json does not exist, tell the user to run: `npx gooseworks login`

All endpoints use Bearer auth: `-H "Authorization: Bearer $GOOSEWORKS_API_KEY"`


Pull investor meetings from Google Calendar, deep-research each firm (scrape their website, analyze portfolio, extract thesis), and output an honest prep sheet that says which investors are a real fit and which aren't.

**Read-only calendar access. Never creates, modifies, or deletes events.**

## Input

- **domain** (required) — user's company website (provided in the prompt, e.g. "prep my investor calls for orthogonal.com")
- **competitors** (optional) — auto-detected if not provided

Always export to Google Sheets at the end — it's free and takes seconds.

## Step 1: Pull Investor Meetings

Pull from today through Demo Day (March 24, 2026). All W26 companies are fundraising now through Demo Day. Make multiple calls if needed to avoid truncation — e.g. split into week 1 and week 2.

```bash
# Adjust timeMin to today's date
curl -s -X POST $GOOSEWORKS_API_BASE/v1/proxy/orthogonal/run \
  -H "Authorization: Bearer $GOOSEWORKS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"api":"google-calendar","path":"/list-events"}'
  "calendarId": "primary",
  "timeMin": "{today}T00:00:00Z",
  "timeMax": "{midpoint}T23:59:59Z",
  "maxResults": 100,
  "singleEvents": true,
  "orderBy": "startTime"
}'

curl -s -X POST $GOOSEWORKS_API_BASE/v1/proxy/orthogonal/run \
  -H "Authorization: Bearer $GOOSEWORKS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"api":"google-calendar","path":"/list-events"}'
  "calendarId": "primary",
  "timeMin": "{midpoint+1}T00:00:00Z",
  "timeMax": "2026-03-24T23:59:59Z",
  "maxResults": 100,
  "singleEvents": true,
  "orderBy": "startTime"
}'
```

### Filtering — be precise, not greedy

The keyword approach catches false positives (personal meetings, mock pitches, etc.). Use this priority order:

1. **Strong signal (auto-include):** Title starts with "Investors between" — this is the standard Cal.com booking format for investor meetings.
2. **Medium signal (auto-include):** Attendee email domain is a known VC domain (e.g. `@moonfire.com`, `@a16z.com`, `@accel.com`) OR the event description contains VC firm names.
3. **Weak signal (requires confirmation):** Title contains keywords like `invest`, `vc`, `fund`, `capital`, `ventures`, `angel`, `seed`, `series` — BUT does NOT match pattern #1. These need manual review.
4. **Exclude:** Events with "mock" or "practice" in title/description (these are rehearsals, not real meetings). Also exclude batch/group events with no attendees (e.g. "Fundraising Open Mic", "Demo Day") — these are YC events, not 1:1 investor calls.

Extract: title, date/time, attendee emails (non-company = investor contacts), description (often has investor names/emails even when attendee list doesn't).

**Present filtered list to user for confirmation before proceeding.**

### Create the Google Sheet immediately after confirmation

Before starting any research, create the spreadsheet and populate it with all confirmed investor rows (date/time, firm name, investor name, firm website — leave research columns blank). Share the link with the user so they can watch results fill in live as each investor is researched. This is much better UX than waiting for all research to complete.

## Step 2: Research the User's Company

**Ask the user to describe their company in 1-2 sentences** rather than relying on Perplexity, which often confuses companies with similar names (e.g. orthogonal.com vs orthogonal.io). The user's own description is always more accurate than a web search for early-stage startups.

Then auto-detect competitors:

```bash
# Auto-detect competitors (skip if user provided)
curl -s -X POST $GOOSEWORKS_API_BASE/v1/proxy/orthogonal/run \
  -H "Authorization: Bearer $GOOSEWORKS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"api":"perplexity","path":"/chat/completions"}'
  "model": "sonar",
  "messages": [{"role": "user", "content": "Top 5-10 competitors of {company_name} ({domain})? {user_provided_description}. Company names and domains only."}]
}'
```

**Verify the competitor list with the user** before proceeding. Perplexity often returns enterprise incumbents (MuleSoft, Workato) rather than actual startup competitors. The user knows their competitive landscape better.

Save the company description and confirmed competitor list — use them for every investor assessment.

### Step 2b: Reverse-lookup competitor investors (one-time, cheap)

Instead of asking each investor "have you invested in X?" (unreliable), do a single reverse lookup for each competitor. This is 1 Perplexity call per competitor — not per investor.

```bash
# Run one call per competitor (e.g. 5 competitors = 5 calls total)
curl -s -X POST $GOOSEWORKS_API_BASE/v1/proxy/orthogonal/run \
  -H "Authorization: Bearer $GOOSEWORKS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"api":"perplexity","path":"/chat/completions"}'
  "model": "sonar",
  "messages": [{"role": "user", "content": "Who are the investors in {competitor_name} ({competitor_domain})? List all known venture capital firms and angel investors who have invested in them, with round details if available."}]
}'
```

Build a lookup table: `{investor_firm -> [competitors they backed]}`. Cross-reference this against the meeting list. This catches conflicts that per-investor Perplexity queries miss, at a fraction of the cost.

## Step 3: Research Each Investor

Run ALL of these in parallel per investor. Every source adds unique data.

###