@coldiq/mcp 0.1.0

package/tests/client.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient, callApi } from '../src/client.js'
+
+describe('client', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('throws if COLDIQ_API_KEY is empty', () => {
+    expect(() => initClient('http://localhost', '')).toThrow('COLDIQ_API_KEY is required')
+  })
+
+  it('prefixes paths with /v1', async () => {
+    let capturedUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      capturedUrl = url.toString()
+      return new Response(JSON.stringify({ ok: true }), { status: 200 })
+    }) as typeof fetch
+
+    await callApi('POST', '/companyenrich/companies/search', { pageSize: 10 })
+
+    expect(capturedUrl).toBe('http://test-api.local/v1/companyenrich/companies/search')
+  })
+
+  it('sets Authorization header with Bearer token', async () => {
+    let capturedHeaders: Record<string, string> = {}
+    globalThis.fetch = vi.fn(async (_url: string | URL | Request, init?: RequestInit) => {
+      capturedHeaders = Object.fromEntries(Object.entries(init?.headers ?? {}))
+      return new Response(JSON.stringify({}), { status: 200 })
+    }) as typeof fetch
+
+    await callApi('POST', '/test', { foo: 'bar' })
+
+    expect(capturedHeaders['Authorization']).toBe('Bearer test-key-123')
+    expect(capturedHeaders['Content-Type']).toBe('application/json')
+  })
+
+  it('appends query params for GET requests', async () => {
+    let capturedUrl = ''
+    globalThis.fetch = vi.fn(async (url: string | URL | Request) => {
+      capturedUrl = url.toString()
+      return new Response(JSON.stringify({}), { status: 200 })
+    }) as typeof fetch
+
+    await callApi('GET', '/companies/enrich', undefined, { domain: 'stripe.com' })
+
+    expect(capturedUrl).toContain('domain=stripe.com')
+  })
+
+  it('returns ok: false on network error', async () => {
+    globalThis.fetch = vi.fn(async () => {
+      throw new Error('Network timeout')
+    }) as typeof fetch
+
+    const result = await callApi('POST', '/test', {})
+
+    expect(result.ok).toBe(false)
+    expect(result.status).toBe(0)
+    expect((result.data as Record<string, unknown>).error).toBe('Network timeout')
+  })
+
+  it('returns parsed JSON on success', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ companies: [{ name: 'ColdIQ' }] }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await callApi('POST', '/test', {})
+
+    expect(result.ok).toBe(true)
+    expect(result.status).toBe(200)
+    expect((result.data as Record<string, unknown>).companies).toEqual([{ name: 'ColdIQ' }])
+  })
+
+  it('returns ok: false for 4xx/5xx responses', async () => {
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ error: 'Not found' }), { status: 404 })
+    ) as typeof fetch
+
+    const result = await callApi('GET', '/test')
+
+    expect(result.ok).toBe(false)
+    expect(result.status).toBe(404)
+  })
+})

package/tests/executor.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { initClient } from '../src/client.js'
+import { executeWithFallback } from '../src/executor.js'
+
+describe('executor postFilter integration', () => {
+  const originalFetch = globalThis.fetch
+
+  beforeEach(() => {
+    initClient('http://test-api.local', 'test-key-123')
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('invokes Apollo postFilter — strips accounts and drops wrong-country orgs → falls through to error', async () => {
+    // Apollo is at priority 7. Mock all higher-priority providers to return empty so Apollo is reached.
+    // Apollo returns orgs with wrong country + accounts key.
+    // postFilter should: strip accounts, drop German org, keep no French orgs → hasResult false → error.
+    let callCount = 0
+    globalThis.fetch = vi.fn(async () => {
+      callCount++
+      if (callCount <= 5) {
+        // companyenrich, fullenrich, pdl, blitzapi, signalbase — all return empty
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      if (callCount === 6) {
+        // theirstack — gated (no keywords in input), but if reached, return empty
+        return new Response(JSON.stringify({}), { status: 200 })
+      }
+      // Apollo (call 7 or beyond): returns organizations with wrong country + CRM accounts
+      return new Response(
+        JSON.stringify({
+          organizations: [{ name: 'GermanCo', country: 'Germany', estimated_num_employees: 100 }],
+          accounts: [{ id: 1, name: 'CRM leak' }],
+        }),
+        { status: 200 },
+      )
+    }) as typeof fetch
+
+    // No keywords → TheirStack skipped; no min_founded_year → Apollo eligible
+    const result = await executeWithFallback('search_companies', {
+      countries: ['FR'],
+      min_employees: 50,
+      max_employees: 200,
+      limit: 5,
+    })
+
+    // Apollo's postFilter should drop GermanCo (wrong country) → hasResult false → falls through
+    expect('error' in result).toBe(true)
+    expect(callCount).toBeGreaterThan(6)
+  })
+
+  it('passes raw data through unchanged when postFilter is not set (enrich_company)', async () => {
+    // enrich_company providers (companyenrich, apollo, pdl) have no postFilter.
+    // Verify a successful response is returned as-is.
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ name: 'ColdIQ', domain: 'coldiq.com' }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await executeWithFallback('enrich_company', { domain: 'coldiq.com' })
+
+    expect('data' in result).toBe(true)
+    if ('data' in result) {
+      expect((result.data as Record<string, unknown>).domain).toBe('coldiq.com')
+    }
+  })
+
+  it('passes raw data through when postFilter is set but no strict filters requested', async () => {
+    // search_companies with no year/employee/country filter → postFilter is a no-op.
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ data: [{ name: 'ColdIQ' }] }), { status: 200 })
+    ) as typeof fetch
+
+    const result = await executeWithFallback('search_companies', { keywords: ['SaaS'], limit: 5 })
+
+    expect('data' in result).toBe(true)
+    if ('data' in result) {
+      const orgs = (result.data as Record<string, unknown>).data as unknown[]
+      expect(orgs.length).toBe(1)
+    }
+  })
+})

package/tests/gtm/01-icp-to-emails.test.ts

@@ -0,0 +1,43 @@
+/**
+ * GTM-01: Full classical ICP → email sequence (CSV-style)
+ *
+ * Prompt: GTM engineer builds a single-row lead list from scratch.
+ * Expected flow: search_companies → find_people → find_email → verify_email
+ * Forbidden:     search_web (must use structured tools, not fallback to web)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-01: ICP → verified emails (CSV-style)', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('routes through search → people → email → verify in order', async () => {
+    const result = await runAgent({
+      prompt:
+        "I'm building a lead CSV. Do this step by step: " +
+        '1) Find 1 B2B SaaS company in France with under 200 employees. ' +
+        '2) Find the CEO at that company (limit 1). ' +
+        '3) Get their professional email address. ' +
+        '4) Verify the email is deliverable. ' +
+        'Give me the final result as: Company | CEO name | Email | Deliverable (yes/no).',
+      maxToolCalls: 10,
+    })
+
+    expectTool(result.transcript, 'search_companies')
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_email')
+    expectTool(result.transcript, 'verify_email')
+    expectOrder(result.transcript, ['search_companies', 'find_people', 'find_email', 'verify_email'])
+    expectNoTool(result.transcript, 'search_web')
+
+    writeArtifact('01-icp-to-emails', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/02-icp-bulk-emails.test.ts

@@ -0,0 +1,38 @@
+/**
+ * GTM-02: Multi-company bulk email lookup
+ *
+ * Prompt: GTM engineer has 3 known target companies, wants emails in one batch.
+ * Expected flow: find_people → find_emails (batch, NOT per-person find_email loop)
+ * Forbidden:     find_email (singular per person), search_companies (companies already known)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-02: multi-company bulk email lookup', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('uses find_emails (batch) instead of individual find_email calls', async () => {
+    const result = await runAgent({
+      prompt:
+        'I have 3 target companies: Stripe (stripe.com), Notion (notion.so), and Vercel (vercel.com). ' +
+        'Find 1 Head of Sales, VP Sales, or CRO at each company (limit 1 per company). ' +
+        'Then use the bulk email finder to get all their professional emails in one batch — do NOT look them up one by one. ' +
+        'Return a table: Name | Company | Email.',
+      maxToolCalls: 8,
+    })
+
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_emails')
+    expectNoTool(result.transcript, 'search_companies')
+
+    writeArtifact('02-icp-bulk-emails', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/03-icp-to-phones.test.ts

@@ -0,0 +1,39 @@
+/**
+ * GTM-03: Person → phone number (cold call enrichment)
+ *
+ * Prompt: GTM engineer needs a phone number for a known target person.
+ * Expected flow: find_people → find_phone
+ * Forbidden:     enrich_person (they don't have a LinkedIn URL, not a full enrichment), search_web
+ * Est. credits:  ~3
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-03: find person then phone number', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('finds CEO at ColdIQ then retrieves their phone number', async () => {
+    const result = await runAgent({
+      prompt:
+        "I need to cold call the CEO of ColdIQ (domain: coldiq.com). " +
+        'First find the CEO there (limit 1 result), then get their phone number using their LinkedIn profile URL from the search result. ' +
+        "If no phone is found, say so — that's fine.",
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_phone')
+    expectOrder(result.transcript, ['find_people', 'find_phone'])
+    expectNoTool(result.transcript, 'enrich_person')
+    expectNoTool(result.transcript, 'search_web')
+
+    writeArtifact('03-icp-to-phones', result)
+  }, 5 * 60_000)
+})

package/tests/gtm/04-funding-signal-outreach.test.ts

@@ -0,0 +1,42 @@
+/**
+ * GTM-04: Funding signal → decision-maker → email
+ *
+ * Prompt: GTM engineer targets companies that just raised money.
+ * Expected flow: find_signals (funding) → find_people → find_email
+ * Forbidden:     search_companies (signals, not firmographic search)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, expectParam, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-04: funding signal → outreach contact', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('routes through signals (funding) → people → email', async () => {
+    const result = await runAgent({
+      prompt:
+        'I target companies right after they raise money. ' +
+        'Find 1 company that recently received Series A funding in France. ' +
+        'Then find their CEO or Founder (limit 1). ' +
+        'Then get the CEO/Founder email. ' +
+        'Return: Company | CEO name | Email.',
+      maxToolCalls: 8,
+    })
+
+    expectTool(result.transcript, 'find_signals')
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_email')
+    expectOrder(result.transcript, ['find_signals', 'find_people', 'find_email'])
+    expectNoTool(result.transcript, 'search_companies')
+    expectParam(result.transcript, 'find_signals', 'signal_type', (v) => String(v) === 'funding')
+
+    writeArtifact('04-funding-signal-outreach', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/05-hiring-signal-decisionmakers.test.ts

@@ -0,0 +1,41 @@
+/**
+ * GTM-05: Job posting signal → decision-maker lookup
+ *
+ * Prompt: "Companies hiring SDRs in NYC" should use live job postings (search_jobs),
+ *         NOT the company-level hiring signal (find_signals). This is the key boundary pair.
+ *         Then find VP Sales at the hiring company.
+ * Expected flow: search_jobs → find_people
+ * Forbidden:     find_signals (wrong tool for individual job postings)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-05: job postings → decision-maker', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('uses search_jobs (not find_signals) to find hiring companies, then finds VP Sales', async () => {
+    const result = await runAgent({
+      prompt:
+        'Find companies in New York that are actively posting SDR or Business Development Rep job openings right now. ' +
+        'Use the job postings tool to find actual live listings (use the minimum allowed limit). ' +
+        'Pick the first company from the results, then find the VP of Sales or Head of Sales at that company (limit 1 person). ' +
+        'Return: Company | Job title of decision-maker | LinkedIn URL.',
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'search_jobs')
+    expectTool(result.transcript, 'find_people')
+    expectOrder(result.transcript, ['search_jobs', 'find_people'])
+    expectNoTool(result.transcript, 'find_signals')
+
+    writeArtifact('05-hiring-signal-decisionmakers', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/06-intent-signal-outreach.test.ts

@@ -0,0 +1,44 @@
+/**
+ * GTM-06: Buying intent signal → outreach contact
+ *
+ * Prompt: GTM engineer validates a known target company's buying signals before outreach.
+ * find_signals(intent) returns what topics a company is actively evaluating (based on job signals).
+ * Expected flow: find_signals (intent) → find_people → find_email
+ * Forbidden:     search_companies (we already know the target company)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, expectParam, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-06: buying intent signal → outreach', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('routes through find_signals(intent) → find_people → find_email', async () => {
+    const result = await runAgent({
+      prompt:
+        'I want to personalize my outreach to ColdIQ before contacting them. ' +
+        'First, check their buying intent signals to understand what technologies they are actively evaluating (limit 1 signal). ' +
+        'Use the intent signal tool — not a company search. ' +
+        'Then find their CEO or VP Sales (limit 1 person). ' +
+        'Then get that person\'s professional email. ' +
+        'Return: Company | Top buying intent topic | Contact name | Email.',
+      maxToolCalls: 8,
+    })
+
+    expectTool(result.transcript, 'find_signals')
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_email')
+    expectOrder(result.transcript, ['find_signals', 'find_people', 'find_email'])
+    expectNoTool(result.transcript, 'search_companies')
+    expectParam(result.transcript, 'find_signals', 'signal_type', (v) => String(v) === 'intent')
+
+    writeArtifact('06-intent-signal-outreach', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/07-places-to-content.test.ts

@@ -0,0 +1,50 @@
+/**
+ * GTM-07: Local place search → website content extraction
+ *
+ * Prompt: Local business research — find a place, then read its website.
+ * Expected flow: search_places → fetch_page_content
+ * Forbidden:     search_web (we need structured place data first, not a web search)
+ * Est. credits:  ~3
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-07: place search → website content', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('finds a coffee shop near Times Square then fetches its website content', async () => {
+    const result = await runAgent({
+      prompt:
+        'I am doing local business research. ' +
+        'Find 1 coffee shop near Times Square in New York (limit 1 result). ' +
+        'If the place has a website URL in the result, fetch the content of that website. ' +
+        "If there's no website URL in the result, just report what information you found about the place. " +
+        'Summarize what the place offers.',
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'search_places')
+    expectNoTool(result.transcript, 'search_web')
+
+    const transcript = result.transcript
+    const hasPageFetch = transcript.some((c) => c.tool === 'fetch_page_content')
+    const searchPlacesResult = transcript.find((c) => c.tool === 'search_places')
+    // If search_places returned a website URL, the agent should have fetched it
+    if (hasPageFetch) {
+      expectOrder(transcript, ['search_places', 'fetch_page_content'])
+    } else {
+      // No website URL in result — acceptable, agent should report the place data
+      const hasData = searchPlacesResult && !searchPlacesResult.isError
+      if (!hasData) throw new Error('search_places returned an error and no fetch_page_content was attempted')
+    }
+
+    writeArtifact('07-places-to-content', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/08-domain-to-account.test.ts

@@ -0,0 +1,44 @@
+/**
+ * GTM-08: Domain → full account intelligence
+ *
+ * Prompt: GTM engineer targets a specific known company, wants a full picture.
+ * Expected flow: enrich_company → find_people → find_email
+ * Forbidden:     search_companies (we already know the domain, firmographic search is wasteful)
+ * Est. credits:  ~4
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, expectParam, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-08: domain → account + contact + email', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('enriches company then finds contact then gets email', async () => {
+    const result = await runAgent({
+      prompt:
+        "I want to target ColdIQ for outbound. Their domain is coldiq.com. " +
+        '1) Enrich the company to understand what they do, their size, and industry. ' +
+        '2) Find 1 key decision-maker there — CEO, Founder, or VP Sales. ' +
+        '3) Get their professional email. ' +
+        'Return: a brief company summary + the contact name + email.',
+      maxToolCalls: 8,
+    })
+
+    expectTool(result.transcript, 'enrich_company')
+    expectTool(result.transcript, 'find_people')
+    expectTool(result.transcript, 'find_email')
+    expectOrder(result.transcript, ['enrich_company', 'find_people', 'find_email'])
+    expectNoTool(result.transcript, 'search_companies')
+    expectParam(result.transcript, 'enrich_company', 'domain', (v) =>
+      String(v).toLowerCase().includes('coldiq'),
+    )
+
+    writeArtifact('08-domain-to-account', result)
+  }, 8 * 60_000)
+})

package/tests/gtm/09-linkedin-to-everything.test.ts

@@ -0,0 +1,41 @@
+/**
+ * GTM-09: LinkedIn URL → person enrichment + company enrichment
+ *
+ * Prompt: GTM engineer has a LinkedIn URL, wants full profile and company context.
+ * Expected flow: enrich_person → enrich_company (using domain from person enrichment)
+ * Forbidden:     find_people (we have the URL already, no need to search)
+ * Est. credits:  ~3
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectOrder, expectParam, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-09: LinkedIn URL → person + company enrichment', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('enriches person then enriches their company', async () => {
+    const result = await runAgent({
+      prompt:
+        'Enrich this LinkedIn profile: https://www.linkedin.com/in/michel-lieben. ' +
+        'After getting the person data, also enrich their company using the domain from the person result. ' +
+        'Give me: full name, job title, company name, company size, and company industry.',
+      maxToolCalls: 6,
+    })
+
+    expectTool(result.transcript, 'enrich_person')
+    expectTool(result.transcript, 'enrich_company')
+    expectOrder(result.transcript, ['enrich_person', 'enrich_company'])
+    expectNoTool(result.transcript, 'find_people')
+    expectParam(result.transcript, 'enrich_person', 'linkedin_url', (v) =>
+      String(v).toLowerCase().includes('michel-lieben'),
+    )
+
+    writeArtifact('09-linkedin-to-everything', result)
+  }, 6 * 60_000)
+})

package/tests/gtm/10-jobs-vs-signals-routing.test.ts

@@ -0,0 +1,38 @@
+/**
+ * GTM-10: Boundary pair — search_jobs vs find_signals(hiring)
+ *
+ * "Companies hiring sales reps right now" should route to search_jobs (individual live postings),
+ * NOT find_signals (company-level aggregated hiring surge signal).
+ *
+ * This is a pure routing test — we care about WHICH tool is chosen, not the result.
+ * Expected:   search_jobs
+ * Forbidden:  find_signals
+ * Est. credits: ~2
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-10: routing — search_jobs vs find_signals(hiring)', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('routes to search_jobs, not find_signals, for live job posting queries', async () => {
+    const result = await runAgent({
+      prompt:
+        'What companies in New York are posting job openings for Account Executive or Sales Rep right now? ' +
+        'I want to see the actual job listings — company name, job title, and posting date. Use the minimum allowed limit.',
+      maxToolCalls: 4,
+    })
+
+    expectTool(result.transcript, 'search_jobs')
+    expectNoTool(result.transcript, 'find_signals')
+
+    writeArtifact('10-jobs-vs-signals-routing', result)
+  }, 5 * 60_000)
+})

package/tests/gtm/11-find-vs-enrich-routing.test.ts

@@ -0,0 +1,39 @@
+/**
+ * GTM-11: Boundary pair — find_email vs enrich_person
+ *
+ * "What is X's email at company Y?" should route to find_email (name+domain → email),
+ * NOT enrich_person (which enriches a full profile from a LinkedIn URL or known email).
+ *
+ * Expected:   find_email
+ * Forbidden:  enrich_person
+ * Est. credits: ~1
+ */
+
+import { describe, it, beforeAll } from 'vitest'
+import { initClient } from '../../src/client.js'
+import { runAgent, expectTool, expectNoTool, expectParam, writeArtifact } from './harness.js'
+
+const RUN_LIVE =
+  process.env.LIVE_TESTS === '1' && !!process.env.ANTHROPIC_API_KEY && !!process.env.COLDIQ_API_KEY
+
+describe.runIf(RUN_LIVE)('gtm-11: routing — find_email vs enrich_person', () => {
+  beforeAll(() => {
+    initClient(process.env.COLDIQ_API_URL, process.env.COLDIQ_API_KEY)
+  })
+
+  it('routes to find_email (not enrich_person) for name + domain → email queries', async () => {
+    const result = await runAgent({
+      prompt:
+        "What is Michel Lieben's professional email address? He is the CEO at ColdIQ — their domain is coldiq.com.",
+      maxToolCalls: 4,
+    })
+
+    expectTool(result.transcript, 'find_email')
+    expectNoTool(result.transcript, 'enrich_person')
+    expectParam(result.transcript, 'find_email', 'domain', (v) =>
+      String(v).toLowerCase().includes('coldiq'),
+    )
+
+    writeArtifact('11-find-vs-enrich-routing', result)
+  }, 3 * 60_000)
+})