@coldiq/mcp 0.1.17 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coldiq/mcp",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -13,9 +13,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:gtm": "LIVE_TESTS=1 vitest run tests/gtm",
-    "test:gtm:one": "LIVE_TESTS=1 vitest run",
-    "version": "git add package.json package-lock.json",
-    "postversion": "git commit -m \"chore(mcp): release $npm_package_version\" && git tag mcp-v$npm_package_version && git push && git push --tags"
+    "test:gtm:one": "LIVE_TESTS=1 vitest run"
   },
   "engines": {
     "node": ">=18.18"

package/src/registry.ts

@@ -1032,11 +1032,23 @@ const findPeopleProviders: ProviderEntry[] = [
       }
     },
     hasResult: (data) => {
-      const d = data as Record<string, unknown>
-      return (
-        isNonEmptyArray(d.companies_personas) ||
-        (d.status === 'SUCCESSFUL' && d.nb_jobs_complete != null && (d.nb_jobs_complete as number) > 0)
-      )
+      // Each entry in companies_personas is { company, personas: unknown[][], ... }.
+      // The wrapper array is always populated (one entry per requested domain), so
+      // checking only `isNonEmptyArray(d.companies_personas)` returns true even when
+      // every entry's inner `personas` is empty (no contacts found). Count the
+      // actual contacts so the waterfall falls through to apollo on empty results.
+      const d = data as Record<string, unknown>
+      const groups = d.companies_personas as Array<{ personas?: unknown[][] }> | undefined
+      if (Array.isArray(groups)) {
+        const totalContacts = groups.reduce(
+          (sum, g) => sum + ((g.personas ?? []).flat().length),
+          0,
+        )
+        return totalContacts > 0
+      }
+      // Defensive fallback: if upstream omits companies_personas entirely, trust the
+      // job-completion counter. Not observed in practice; kept for safety.
+      return d.status === 'SUCCESSFUL' && d.nb_jobs_complete != null && (d.nb_jobs_complete as number) > 0
     },
     async: {
       pollEndpoint: (id: string) => `/leadsfactory/contact-finder/searches/${id}`,
@@ -1115,12 +1127,27 @@ const findPeopleProviders: ProviderEntry[] = [
     endpoint: '/pdl/person/search',
     method: 'POST',
     priority: 3,
+    // Refuse fully-unbounded queries: PDL accepts an empty `must` and would return its
+    // entire index — turning the waterfall into a "random 25 humans" generator.
+    isApplicable: (input) =>
+      isNonEmptyArray(input.company_domains) ||
+      isNonEmptyArray(input.company_linkedin_urls) ||
+      isNonEmptyArray(input.job_titles) ||
+      isNonEmptyArray(input.seniorities),
     mapParams: (input) => {
       const must: unknown[] = []
       if (isNonEmptyArray(input.job_titles))
         must.push({ terms: { job_title: input.job_titles } })
       if (isNonEmptyArray(input.company_domains))
         must.push({ terms: { job_company_website: input.company_domains } })
+      if (isNonEmptyArray(input.company_linkedin_urls)) {
+        // PDL indexes LinkedIn URLs in canonical short form (`linkedin.com/company/x`)
+        // and `terms` is exact-match — full URLs from callers silently return 0 hits.
+        const normalized = (input.company_linkedin_urls as string[]).map((u) =>
+          u.toLowerCase().replace(/^https?:\/\//, '').replace(/^www\./, '').replace(/\/+$/, ''),
+        )
+        must.push({ terms: { job_company_linkedin_url: normalized } })
+      }
       if (isNonEmptyArray(input.seniorities))
         must.push({ terms: { job_title_levels: input.seniorities } })
       if (isNonEmptyArray(input.locations))
@@ -1142,10 +1169,16 @@ const findPeopleProviders: ProviderEntry[] = [
     endpoint: '/companyenrich/people/search',
     method: 'POST',
     priority: 4,
+    // Upstream `filters.companies` accepts domains only — no LinkedIn-URL field exists.
+    // Skip when the caller supplied only LinkedIn URLs so we don't fall back to a
+    // titles-only global search that masquerades as company-scoped.
+    isApplicable: (input) =>
+      isNonEmptyArray(input.company_domains) || !isNonEmptyArray(input.company_linkedin_urls),
     mapParams: (input) => ({
       body: {
         filters: {
           jobTitles: input.job_titles,
+          companies: isNonEmptyArray(input.company_domains) ? input.company_domains : undefined,
           countries: input.locations,
         },
         pageSize: (input.limit as number) ?? 25,
@@ -1281,6 +1314,12 @@ const findPeopleProviders: ProviderEntry[] = [
     endpoint: '/fullenrich/people/search',
     method: 'POST',
     priority: 9,
+    // Requires company_domains: the upstream rejects LinkedIn-URL variants as
+    // `error.filters.empty` (despite the schema declaring `current_company_linkedin_urls`,
+    // the live API doesn't honor it). Without any company filter, FullEnrich silently
+    // degrades to a 50k-result titles-only search whose first 25 short-circuit the
+    // waterfall via hasResult.
+    isApplicable: (input) => isNonEmptyArray(input.company_domains),
     mapParams: (input) => ({
       body: {
         current_company_domains: isNonEmptyArray(input.company_domains)

package/src/utils/provider-resolver.ts

@@ -198,6 +198,9 @@ const GATED_DESCRIPTIONS: Partial<Record<Capability, Partial<Record<string, Gate
     'prospeo-search-person': { kind: 'requires',         fields: 'job_titles or company_domains' },
     'ai-ark-people':         { kind: 'requires',         fields: 'job_titles, seniorities, or keywords' },
     'findymail-search-employees': { kind: 'requires',    fields: 'company_domains and job_titles' },
+    'fullenrich-people-search': { kind: 'requires',      fields: 'company_domains (upstream does not accept LinkedIn URL filters)' },
+    pdl:                     { kind: 'requires',         fields: 'company_domains, company_linkedin_urls, job_titles, or seniorities' },
+    companyenrich:           { kind: 'incompatible_with', fields: 'company_linkedin_urls without company_domains (upstream supports domain filters only)' },
   },
   // -------------------------------------------------------------------------
   find_email: {

package/tests/live/fullenrich-upstream-probe.ts

@@ -0,0 +1,55 @@
+// Direct upstream probe — documents what FullEnrich /people/search actually
+// honors as a company filter. The ColdIQ wrapper schema at
+// src/providers/fullenrich/schema.ts declares `current_company_linkedin_urls`,
+// but the live API rejects every shape with `error.filters.empty` (400). Only
+// `current_company_domains` and `current_company_names` actually scope results.
+//
+// This is why the registry mapper for `fullenrich-people-search` is gated
+// behind `company_domains` only — adding the LinkedIn URL field caused the
+// upstream to treat the request as filterless and return a 50k-result global
+// titles-only search, masquerading as company-scoped.
+//
+// Run:  FULLENRICH_API_KEY=… npx tsx mcp/tests/live/fullenrich-upstream-probe.ts
+
+const KEY = process.env.FULLENRICH_API_KEY
+if (!KEY) { console.error('FULLENRICH_API_KEY required'); process.exit(1) }
+const URL = 'https://app.fullenrich.com/api/v2/people/search'
+
+async function call(label: string, body: unknown) {
+  const t0 = Date.now()
+  const res = await fetch(URL, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${KEY}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  const data: any = await res.json().catch(async () => ({ raw: await res.text() }))
+  const total = data.metadata?.total
+  const ok = res.status === 200
+  console.log(`[${ok ? 'OK ' : 'ERR'}] ${label.padEnd(60)} status=${res.status} ms=${Date.now() - t0} total=${total ?? '-'} ${ok ? '' : 'err=' + JSON.stringify(data).slice(0, 120)}`)
+}
+
+async function main() {
+  console.log('=== FullEnrich /people/search filter compatibility probe ===\n')
+
+  console.log('▸ Known-working filters (should all return 200 with total > 0)')
+  await call('current_company_domains', { current_company_domains: [{ value: 'spendesk.com' }], limit: 1 })
+  await call('current_company_names', { current_company_names: [{ value: 'Spendesk' }], limit: 1 })
+
+  console.log('\n▸ LinkedIn URL variants (declared in ColdIQ schema, NOT honored upstream)')
+  for (const [field, value] of [
+    ['current_company_linkedin_urls', 'https://www.linkedin.com/company/spendesk'],
+    ['current_company_linkedin_url', 'https://www.linkedin.com/company/spendesk'],
+    ['current_company_linkedin_urls (short)', 'linkedin.com/company/spendesk'],
+    ['current_company_linkedin_urls (slug)', 'spendesk'],
+    ['current_company_linkedin_ids', 'spendesk'],
+  ] as const) {
+    const key = field.split(' ')[0]
+    await call(field, { [key]: [{ value }], limit: 1 })
+  }
+
+  console.log('\n▸ No-filter baseline (the buggy path: 50k+ titles-only results)')
+  await call('titles-only, no company', { current_position_titles: [{ value: 'CEO' }], limit: 1 })
+  await call('completely empty (sanity)', { limit: 1 })
+}
+
+main().catch((e) => { console.error('FATAL', e); process.exit(1) })

package/tests/live/pdl-upstream-probe.ts

@@ -0,0 +1,83 @@
+// Direct upstream probe — verifies PDL's /person/search accepts
+// `job_company_linkedin_url` as a filterable term, and that the returned people
+// actually work at the company we asked for.
+//
+// PDL's Elasticsearch DSL is permissive: an unknown field name returns 0 hits
+// rather than an error, so a silent miss looks identical to "no data." The
+// probe compares a known-good baseline (job_company_website) against the
+// LinkedIn-URL variant.
+//
+// Run:  PDL_API_KEY=… npx tsx mcp/tests/live/pdl-upstream-probe.ts
+
+const KEY = process.env.PDL_API_KEY
+if (!KEY) { console.error('PDL_API_KEY required'); process.exit(1) }
+const BASE = 'https://api.peopledatalabs.com/v5'
+
+async function search(must: unknown[], size = 3) {
+  const t0 = Date.now()
+  const res = await fetch(`${BASE}/person/search`, {
+    method: 'POST',
+    headers: { 'X-API-Key': KEY!, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query: { bool: { must } }, size }),
+    signal: AbortSignal.timeout(30_000),
+  })
+  let data: any
+  try { data = await res.json() } catch { data = await res.text() }
+  return { ok: res.ok, status: res.status, ms: Date.now() - t0, data }
+}
+
+function summarize(label: string, r: any) {
+  const data = r.data ?? {}
+  const total = data.total ?? '?'
+  const items = (data.data ?? []) as Array<any>
+  console.log(`\n[${label}] status=${r.status} ms=${r.ms} total=${total} returned=${items.length}`)
+  for (const p of items.slice(0, 5)) {
+    console.log(`  - ${p.full_name} | ${p.job_title} | co=${p.job_company_name} | website=${p.job_company_website} | li=${p.job_company_linkedin_url}`)
+  }
+}
+
+async function main() {
+  console.log('=== PDL upstream probe: verify job_company_linkedin_url ===')
+
+  // Use a well-known mid-sized B2B SaaS for the comparison. Aircall is a good fit:
+  // ~700 employees, indexed by both website and LinkedIn URL in PDL.
+  const TARGET_DOMAIN = 'aircall.io'
+  const TARGET_LINKEDIN = 'linkedin.com/company/aircall'
+
+  // Baseline: search by known-working field (job_company_website)
+  console.log(`\n▸ Baseline: search by job_company_website = ${TARGET_DOMAIN}`)
+  const byDomain = await search([{ terms: { job_company_website: [TARGET_DOMAIN] } }])
+  summarize('job_company_website', byDomain)
+
+  // Test: same search but by LinkedIn URL
+  console.log(`\n▸ Test: search by job_company_linkedin_url = ${TARGET_LINKEDIN}`)
+  const byLinkedIn = await search([{ terms: { job_company_linkedin_url: [TARGET_LINKEDIN] } }])
+  summarize('job_company_linkedin_url', byLinkedIn)
+
+  const baselineTotal = byDomain.data?.total ?? 0
+  const linkedinTotal = byLinkedIn.data?.total ?? 0
+
+  console.log(`\n=== Result ===`)
+  console.log(`baseline (by website):        total=${baselineTotal}`)
+  console.log(`test     (by linkedin_url):   total=${linkedinTotal}`)
+
+  if (linkedinTotal > 0 && baselineTotal > 0) {
+    const ratio = linkedinTotal / baselineTotal
+    console.log(`ratio = ${ratio.toFixed(2)} (1.0 = same company, both filters work)`)
+    if (ratio >= 0.5) {
+      console.log('✅ job_company_linkedin_url WORKS — keep the mapping in registry.ts')
+      process.exit(0)
+    } else {
+      console.log('⚠️  linkedin_url returns far fewer matches than website — investigate')
+      process.exit(2)
+    }
+  } else if (linkedinTotal === 0 && baselineTotal > 0) {
+    console.log('❌ job_company_linkedin_url silently returns 0 — REMOVE the mapping clause for pdl in registry.ts and keep gate-only')
+    process.exit(1)
+  } else {
+    console.log('⚠️  Baseline itself returned 0 — pick a different test company')
+    process.exit(2)
+  }
+}
+
+main().catch((e) => { console.error('FATAL', e); process.exit(1) })

package/tests/registry-find-people.test.ts

@@ -229,8 +229,16 @@ describe('ai-ark-people', () => {
 describe('fullenrich-people-search', () => {
   const p = () => get('fullenrich-people-search')
 
-  it('has no isApplicable gate (always runs)', () => {
-    expect(p().isApplicable).toBeUndefined()
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_linkedin_urls (upstream rejects LinkedIn-URL filters)', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'], job_titles: ['CEO'] })).toBe(false)
+  })
+
+  it('isApplicable: false without any company identifier (titles-only would degrade to global search)', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(false)
   })
 
   it('mapParams wraps all fields in {value} objects', () => {
@@ -252,9 +260,8 @@ describe('fullenrich-people-search', () => {
   })
 
   it('mapParams omits undefined fields', () => {
-    const result = p().mapParams({ job_titles: ['CEO'], limit: 5 })
+    const result = p().mapParams({ company_domains: ['coldiq.com'], limit: 5 })
     const body = result.body as Record<string, unknown>
-    expect(body.current_company_domains).toBeUndefined()
     expect(body.current_position_seniority_level).toBeUndefined()
     expect(body.person_locations).toBeUndefined()
   })
@@ -580,23 +587,57 @@ describe('leadsfactory (find_people)', () => {
     expect(body.keywords).toBeUndefined()
   })
 
-  it('hasResult: true when companies_personas is non-empty', () => {
-    expect(p().hasResult({ companies_personas: [{ company: 'ColdIQ' }] })).toBe(true)
+  it('hasResult: true when at least one company has personas with contacts', () => {
+    expect(
+      p().hasResult({
+        companies_personas: [
+          { company: 'ColdIQ', personas: [[{ contact: { name: 'Michel' } }]] },
+        ],
+      }),
+    ).toBe(true)
+  })
+
+  it('hasResult: false when all companies have empty personas arrays', () => {
+    // The bug scenario: leadsfactory returns SUCCESSFUL but every company's
+    // personas: [[]] is empty. Must return false so the waterfall falls
+    // through to apollo.
+    expect(
+      p().hasResult({
+        status: 'SUCCESSFUL',
+        companies_personas: [
+          { company: 'Beamy', personas: [[]] },
+        ],
+      }),
+    ).toBe(false)
+  })
+
+  it('hasResult: true on multi-company partial result (one filled, one empty)', () => {
+    // Until we have per-company fallback, a multi-company query that finds
+    // contacts for any company keeps the leadsfactory result. Per-company
+    // fallback is tracked separately.
+    expect(
+      p().hasResult({
+        companies_personas: [
+          { company: 'ColdIQ', personas: [[{ contact: { name: 'Michel' } }]] },
+          { company: 'Folk', personas: [[]] },
+        ],
+      }),
+    ).toBe(true)
   })
 
   it('hasResult: false when companies_personas is empty array', () => {
     expect(p().hasResult({ companies_personas: [] })).toBe(false)
   })
 
-  it('hasResult: true when SUCCESSFUL + nb_jobs_complete > 0 (no companies_personas in response)', () => {
+  it('hasResult: true on defensive fallback when companies_personas missing and nb_jobs_complete > 0', () => {
     expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: 3 })).toBe(true)
   })
 
-  it('hasResult: false when SUCCESSFUL + nb_jobs_complete is null (no results)', () => {
+  it('hasResult: false on defensive fallback when nb_jobs_complete is null', () => {
     expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: null })).toBe(false)
   })
 
-  it('hasResult: false when SUCCESSFUL + nb_jobs_complete is 0', () => {
+  it('hasResult: false on defensive fallback when nb_jobs_complete is 0', () => {
     expect(p().hasResult({ status: 'SUCCESSFUL', nb_jobs_complete: 0 })).toBe(false)
   })
 
@@ -621,6 +662,162 @@ describe('leadsfactory (find_people)', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// pdl
+// ---------------------------------------------------------------------------
+
+describe('pdl (find_people)', () => {
+  const p = () => get('pdl')
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'] })).toBe(true)
+  })
+
+  it('isApplicable: true with company_linkedin_urls', () => {
+    expect(p().isApplicable!({ company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'] })).toBe(true)
+  })
+
+  it('isApplicable: true with job_titles', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with seniorities', () => {
+    expect(p().isApplicable!({ seniorities: ['c_suite'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only locations (would return entire index)', () => {
+    expect(p().isApplicable!({ locations: ['FR'] })).toBe(false)
+  })
+
+  it('isApplicable: false with no filters', () => {
+    expect(p().isApplicable!({})).toBe(false)
+  })
+
+  it('mapParams maps company_domains to job_company_website term', () => {
+    const result = p().mapParams({ company_domains: ['coldiq.com'], job_titles: ['CEO'], limit: 10 })
+    const body = result.body as { query: { bool: { must: unknown[] } }; size: number }
+    expect(body.query.bool.must).toContainEqual({ terms: { job_company_website: ['coldiq.com'] } })
+    expect(body.query.bool.must).toContainEqual({ terms: { job_title: ['CEO'] } })
+    expect(body.size).toBe(10)
+  })
+
+  it('mapParams normalizes LinkedIn URLs to PDL canonical short form', () => {
+    // PDL indexes URLs as `linkedin.com/company/x` (no protocol, no www, no trailing slash);
+    // its `terms` query is exact-match — full URLs from callers must be stripped first.
+    const result = p().mapParams({
+      company_linkedin_urls: [
+        'https://www.linkedin.com/company/coldiq',
+        'https://linkedin.com/company/microsoft/',
+        'www.linkedin.com/company/aircall',
+      ],
+      job_titles: ['CMO'],
+    })
+    const body = result.body as { query: { bool: { must: unknown[] } } }
+    expect(body.query.bool.must).toContainEqual({
+      terms: {
+        job_company_linkedin_url: [
+          'linkedin.com/company/coldiq',
+          'linkedin.com/company/microsoft',
+          'linkedin.com/company/aircall',
+        ],
+      },
+    })
+  })
+
+  it('mapParams emits both domain and linkedin terms when both provided', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com'],
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })
+    const body = result.body as { query: { bool: { must: unknown[] } } }
+    expect(body.query.bool.must).toContainEqual({ terms: { job_company_website: ['coldiq.com'] } })
+    expect(body.query.bool.must).toContainEqual({
+      terms: { job_company_linkedin_url: ['linkedin.com/company/coldiq'] },
+    })
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ full_name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 3', () => {
+    expect(p().priority).toBe(3)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// companyenrich
+// ---------------------------------------------------------------------------
+
+describe('companyenrich (find_people)', () => {
+  const p = () => get('companyenrich')
+
+  it('isApplicable: true with company_domains', () => {
+    expect(p().isApplicable!({ company_domains: ['coldiq.com'], job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: true with neither company filter (degrades to titles/locations search)', () => {
+    expect(p().isApplicable!({ job_titles: ['CEO'] })).toBe(true)
+  })
+
+  it('isApplicable: false with only company_linkedin_urls (upstream has no LinkedIn-URL filter)', () => {
+    expect(p().isApplicable!({
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })).toBe(false)
+  })
+
+  it('isApplicable: true when both linkedin_urls AND domains are present (domains carry the search)', () => {
+    expect(p().isApplicable!({
+      company_domains: ['coldiq.com'],
+      company_linkedin_urls: ['https://www.linkedin.com/company/coldiq'],
+      job_titles: ['CEO'],
+    })).toBe(true)
+  })
+
+  it('mapParams maps company_domains to filters.companies', () => {
+    const result = p().mapParams({
+      company_domains: ['coldiq.com', 'microsoft.com'],
+      job_titles: ['CEO'],
+      locations: ['FR'],
+      limit: 10,
+    })
+    expect(result).toEqual({
+      body: {
+        filters: {
+          jobTitles: ['CEO'],
+          companies: ['coldiq.com', 'microsoft.com'],
+          countries: ['FR'],
+        },
+        pageSize: 10,
+      },
+    })
+  })
+
+  it('mapParams omits filters.companies when no domains', () => {
+    const result = p().mapParams({ job_titles: ['CEO'], limit: 25 })
+    const body = result.body as { filters: Record<string, unknown> }
+    expect(body.filters.companies).toBeUndefined()
+  })
+
+  it('hasResult: true when data array non-empty', () => {
+    expect(p().hasResult({ data: [{ name: 'Michel Lieben' }] })).toBe(true)
+  })
+
+  it('hasResult: false when data is empty', () => {
+    expect(p().hasResult({ data: [] })).toBe(false)
+  })
+
+  it('priority is 4', () => {
+    expect(p().priority).toBe(4)
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Ordering: find_people providers sorted correctly
 // ---------------------------------------------------------------------------

package/tests/tools/find-people.test.ts

@@ -84,7 +84,9 @@ describe('find_people handler', () => {
           status: 'SUCCESSFUL',
           nb_jobs_total: 1,
           nb_jobs_complete: 1,
-          companies_personas: [{ company: 'ColdIQ', contacts: [{ first_name: 'Michel', last_name: 'Lieben', title: 'CEO' }] }],
+          companies_personas: [
+            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben', title: 'CEO' } }]] },
+          ],
         }), { status: 200 })
       }
 
@@ -124,12 +126,17 @@ describe('find_people handler', () => {
         return new Response(JSON.stringify({ id: 'abc123', search_id: 'abc', nb_jobs_total: 2, progress_percentage: 0 }), { status: 201 })
       }
 
-      // LeadsFactory poll — SUCCESSFUL with one miss
+      // LeadsFactory poll — SUCCESSFUL with one miss.
+      // Real upstream shape: companies_personas[].personas is unknown[][], each
+      // inner item wraps a contact object. The hasResult check counts contacts
+      // across all entries, so mocks must use this nested shape to match prod.
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
         return new Response(JSON.stringify({
           id: 'abc123', search_id: 'abc', status: 'SUCCESSFUL',
           nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [{ company: 'ColdIQ', contacts: [{ first_name: 'Michel', last_name: 'Lieben' }] }],
+          companies_personas: [
+            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel', last_name: 'Lieben' } }]] },
+          ],
           no_results_domains: ['folk.app'],
         }), { status: 200 })
       }
@@ -185,7 +192,9 @@ describe('find_people handler', () => {
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
         return new Response(JSON.stringify({
           id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [{ company: 'ColdIQ', contacts: [{ first_name: 'Michel' }] }],
+          companies_personas: [
+            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
+          ],
           no_results_domains: ['folk.app'],
         }), { status: 200 })
       }
@@ -237,7 +246,9 @@ describe('find_people handler', () => {
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
         return new Response(JSON.stringify({
           id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 2, nb_jobs_complete: 2,
-          companies_personas: [{ company: 'ColdIQ', contacts: [{ first_name: 'Michel' }] }],
+          companies_personas: [
+            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
+          ],
         }), { status: 200 })
       }
 
@@ -283,7 +294,9 @@ describe('find_people handler', () => {
       if (urlStr.includes('/leadsfactory/contact-finder/searches/abc123')) {
         return new Response(JSON.stringify({
           id: 'abc123', status: 'SUCCESSFUL', nb_jobs_total: 1, nb_jobs_complete: 1,
-          companies_personas: [{ company: 'ColdIQ', contacts: [{ first_name: 'Michel' }] }],
+          companies_personas: [
+            { company: 'ColdIQ', personas: [[{ contact: { first_name: 'Michel' } }]] },
+          ],
         }), { status: 200 })
       }