jd-intel 0.9.0 → 0.10.0

package/README.md

@@ -144,8 +144,22 @@ const { jobs, total_matched } = await fetchJobsDetailed({
 });
 ```
 
+The same result says how the company was resolved and which boards answered:
+
+- `match`: `registry` (a known company, one adapter call), `probe` (not in the registry, every adapter asked) or `workday_override` (an explicit Workday config).
+- `company`: `{ key, name }` from the registry row on a registry match, null otherwise.
+- `boards`: one entry per board that answered, `{ ats, slug, name, site, board_url, org_name, org_url, jobs_found, matched, selected, scan }`. `jobs_found` counts the rows the board listed before any filter. Workday and SmartRecruiters filter their list before fetching details, so for them it is the list count, not the rows that came back (a lower bound when the list scan caps). `matched` is the rows left after filters and before `offset` and `limit`, so a board whose rows were all cut from the page still shows up. `board_url` is built from the slug. `org_name` and `org_url` are what the board states about itself, the organization name in the ATS response and the careers or company host its links point at, and they are null where the platform exposes nothing (Lever and Ashby expose neither); nothing is filled in from the slug or the registry name. A `probe` match is a slug match, not a confirmed identity: compare `org_name` and `org_url` with the company you meant, and open `board_url` when they are null, before treating the jobs as that company's.
+- `failed`: adapters that threw during discovery, `{ ats, slug, name, code, message }`, with `code` either `rate_limited` or `ats_unreachable`. When no board answered and a check failed, `fetchJobs` throws that error instead of returning `[]`, so an outage never reads as "not found".
+- `total_before_filters`: the sum of `jobs_found`. Zero matches with a positive `total_before_filters` means the company is hiring and nothing passed the filters, on every ATS.
+
+`detectAtsDetailed(company)` returns `{ boards, failed }`: registry rows first (`source: 'registry'`, never probed), then every live probe that answered (`source: 'probe'`), in platform order; `failed` lists the probes that could not be checked, with the same codes. `detectAts` keeps returning `[{ ats, slug }]`.
+
+A call the library cannot make throws `ArgumentError` (`code: 'invalid_args'`): no company, an unknown `ats`, or a `titleFilter` or `filter` that does not compile as a regex. It is thrown before any request goes out.
+
 CLI usage: `npx jd-intel fetch <company-slug> --title-filter "engineer" --posted-within-days 14`. Full filter reference [below](#filters-quick-reference).
 
+Each ATS request gives the server 10 seconds to start responding. A 429, a 5xx or a network error is retried up to three attempts with backoff (1s, 2s), honoring `Retry-After` when the ATS sends one, and at most 4 requests run at a time per host. A failure that outlasts the retries throws an `AtsError` whose `code` is `rate_limited` or `ats_unreachable`.
+
 Node.js 18+. No API keys. No configuration.
 
 ### Manual install (fallback)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jd-intel",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Fetch and normalize job descriptions across seven major ATS (Greenhouse, Lever, Ashby, Workday, and more), for your AI assistant. No copy-paste.",
   "type": "module",
   "main": "src/index.js",

package/src/adapters/ashby.js

@@ -1,7 +1,7 @@
 import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
 
-const API_URL = 'https://jobs.ashbyhq.com/api/non-user-graphql';
 const BOARD_URL = 'https://api.ashbyhq.com/posting-api/job-board';
 
 /**
@@ -9,23 +9,18 @@ const BOARD_URL = 'https://api.ashbyhq.com/posting-api/job-board';
  * Public API, no auth required.
  * Docs: https://developers.ashbyhq.com/docs/public-job-posting-api
  *
+ * REST only. The GraphQL fallback this adapter once carried never named a
+ * board, so it never returned a job, and it turned every REST 429 or 5xx
+ * into a silent empty result (issue #55).
+ *
  * @param {string} slug - Company slug (e.g., 'notion', 'linear')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { ats, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
-export async function fetchAshby(slug) {
-  // Try the REST API first (simpler, includes compensation)
-  try {
-    const restJobs = await fetchAshbyRest(slug);
-    if (restJobs.length > 0) return restJobs;
-  } catch { /* fall through to GraphQL */ }
-
-  // Fallback: GraphQL API
-  return fetchAshbyGraphQL(slug);
-}
-
-async function fetchAshbyRest(slug) {
+export async function fetchAshby(slug, ctx = {}) {
   const url = `${BOARD_URL}/${slug}?includeCompensation=true`;
-  const resp = await fetch(url);
+  const resp = await atsFetch(url);
 
   if (!resp.ok) {
     if (resp.status === 404) return [];
@@ -35,6 +30,12 @@ async function fetchAshbyRest(slug) {
   const data = await resp.json();
   const jobs = data.jobs || [];
 
+  // The REST response is { jobs, apiVersion }: no organization name, and
+  // every link is on jobs.ashbyhq.com. Both null (issue #58).
+  if (typeof ctx.report === 'function') {
+    ctx.report({ ats: 'ashby', org_name: null, org_url: null });
+  }
+
   return jobs.map(job => {
     const comp = job.compensation || {};
 
@@ -68,58 +69,6 @@ async function fetchAshbyRest(slug) {
   });
 }
 
-async function fetchAshbyGraphQL(slug) {
-  const query = `{
-    jobBoard {
-      title
-      jobPostings {
-        id
-        title
-        locationName
-        employmentType
-        descriptionHtml
-        publishedDate
-        compensationTierSummary
-      }
-    }
-  }`;
-
-  const resp = await fetch(API_URL, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      operationName: 'ApiJobBoardWithTeams',
-      variables: { organizationHostedJobsPageName: slug },
-      query,
-    }),
-  });
-
-  if (!resp.ok) return [];
-
-  const data = await resp.json();
-  const board = data.data?.jobBoard;
-  if (!board) return [];
-
-  const postings = board.jobPostings || [];
-
-  return postings.map(job => normalize({
-    companySlug: slug,
-    company: board.title || slug,
-    title: job.title || '',
-    department: '',
-    location: job.locationName || '',
-    description: job.descriptionHtml || '',
-    url: `https://jobs.ashbyhq.com/${slug}/${job.id}`,
-    postedAt: job.publishedDate || null,
-    salary: null,
-    metadata: {
-      ashbyId: job.id,
-      employmentType: job.employmentType || '',
-      compensationSummary: job.compensationTierSummary || '',
-    },
-  }, 'ashby'));
-}
-
 const WORKPLACE_TYPES = { remote: 'remote', hybrid: 'hybrid', onsite: 'onsite' };
 
 /**
@@ -163,11 +112,10 @@ function parseAshbyCompensation(comp) {
   return parsed ? { ...parsed, source: 'ats' } : null;
 }
 
+/**
+ * Check if a company has an Ashby board. See probeResult for the outcomes.
+ */
 export async function hasAshby(slug) {
-  try {
-    const resp = await fetch(`${BOARD_URL}/${slug}`, { method: 'HEAD' });
-    return resp.ok;
-  } catch {
-    return false;
-  }
+  const resp = await atsFetch(`${BOARD_URL}/${slug}`, { method: 'HEAD' });
+  return probeResult(resp, `Ashby probe for ${slug}`);
 }

package/src/adapters/greenhouse.js

@@ -1,5 +1,6 @@
 import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
 
 const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
 
@@ -9,11 +10,13 @@ const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
  * Docs: https://developers.greenhouse.io/job-board.html
  *
  * @param {string} slug - Company slug (e.g., 'stripe', 'notion')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { ats, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
-export async function fetchGreenhouse(slug) {
+export async function fetchGreenhouse(slug, ctx = {}) {
   const url = `${BASE_URL}/${slug}/jobs?content=true`;
-  const resp = await fetch(url);
+  const resp = await atsFetch(url);
 
   if (!resp.ok) {
     if (resp.status === 404) return []; // Company not found or no jobs
@@ -23,6 +26,17 @@ export async function fetchGreenhouse(slug) {
   const data = await resp.json();
   const jobs = data.jobs || [];
 
+  // The list response has no top-level name, but each row carries the
+  // board's company_name. Its only links are job-boards.greenhouse.io, so
+  // there is no company host to report (issue #58).
+  if (typeof ctx.report === 'function') {
+    ctx.report({
+      ats: 'greenhouse',
+      org_name: jobs.find(j => j.company_name)?.company_name || null,
+      org_url: null,
+    });
+  }
+
   return jobs.map(job => normalize({
     companySlug: slug,
     company: data.name || slug,
@@ -66,13 +80,9 @@ function parseGreenhouseWorkplace(metadata) {
 }
 
 /**
- * Check if a company has a Greenhouse board.
+ * Check if a company has a Greenhouse board. See probeResult for the outcomes.
  */
 export async function hasGreenhouse(slug) {
-  try {
-    const resp = await fetch(`${BASE_URL}/${slug}`, { method: 'HEAD' });
-    return resp.ok;
-  } catch {
-    return false;
-  }
+  const resp = await atsFetch(`${BASE_URL}/${slug}`, { method: 'HEAD' });
+  return probeResult(resp, `Greenhouse probe for ${slug}`);
 }

package/src/adapters/lever.js

@@ -1,5 +1,6 @@
 import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
 
 const BASE_URL = 'https://api.lever.co/v0/postings';
 
@@ -13,11 +14,13 @@ const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
  * Docs: https://github.com/lever/postings-api
  *
  * @param {string} slug - Company slug (e.g., 'stripe', 'figma')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { ats, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
-export async function fetchLever(slug) {
+export async function fetchLever(slug, ctx = {}) {
   const url = `${BASE_URL}/${slug}?mode=json`;
-  const resp = await fetch(url);
+  const resp = await atsFetch(url);
 
   if (!resp.ok) {
     if (resp.status === 404) return [];
@@ -27,6 +30,12 @@ export async function fetchLever(slug) {
   const jobs = await resp.json();
   if (!Array.isArray(jobs)) return [];
 
+  // The postings response is a bare array of jobs: no organization name
+  // anywhere, and every link is on jobs.lever.co. Both null (issue #58).
+  if (typeof ctx.report === 'function') {
+    ctx.report({ ats: 'lever', org_name: null, org_url: null });
+  }
+
   return jobs.map(job => normalize({
     companySlug: slug,
     // Lever's API doesn't return the company name at the board or job level,
@@ -102,11 +111,10 @@ function titleCaseSlug(slug) {
   return slug.charAt(0).toUpperCase() + slug.slice(1);
 }
 
+/**
+ * Check if a company has a Lever board. See probeResult for the outcomes.
+ */
 export async function hasLever(slug) {
-  try {
-    const resp = await fetch(`${BASE_URL}/${slug}?mode=json`, { method: 'HEAD' });
-    return resp.ok;
-  } catch {
-    return false;
-  }
+  const resp = await atsFetch(`${BASE_URL}/${slug}?mode=json`, { method: 'HEAD' });
+  return probeResult(resp, `Lever probe for ${slug}`);
 }

package/src/adapters/recruitee.js

@@ -1,5 +1,7 @@
 import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
+import { orgHost } from '../boards.js';
 
 /**
  * Fetch jobs from a Recruitee career site.
@@ -18,11 +20,13 @@ import { atsErrorFromStatus } from '../errors.js';
  * both are joined before normalize() strips them (issue #65).
  *
  * @param {string} slug - Recruitee company subdomain (e.g., 'vandebron')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { ats, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
-export async function fetchRecruitee(slug) {
+export async function fetchRecruitee(slug, ctx = {}) {
   const url = `https://${slug}.recruitee.com/api/offers/`;
-  const resp = await fetch(url);
+  const resp = await atsFetch(url);
 
   if (!resp.ok) {
     if (resp.status === 404) return []; // No Recruitee site for this slug
@@ -32,6 +36,17 @@ export async function fetchRecruitee(slug) {
   const data = await resp.json();
   const offers = data.offers || [];
 
+  // The response is { offers } only, so the identity lives on the rows:
+  // company_name, and careers_url, which sits on the company's own careers
+  // domain when the site has one and on {slug}.recruitee.com otherwise.
+  if (typeof ctx.report === 'function') {
+    ctx.report({
+      ats: 'recruitee',
+      org_name: offers.find(o => o.company_name)?.company_name || null,
+      org_url: orgHost(offers.find(o => o.careers_url)?.careers_url),
+    });
+  }
+
   return offers.map(offer => {
     const place = [offer.city, offer.country].filter(Boolean).join(', ');
     let location = place;
@@ -111,13 +126,9 @@ function toAmount(value) {
 }
 
 /**
- * Check if a company has a Recruitee career site.
+ * Check if a company has a Recruitee career site. See probeResult for the outcomes.
  */
 export async function hasRecruitee(slug) {
-  try {
-    const resp = await fetch(`https://${slug}.recruitee.com/api/offers/`);
-    return resp.ok;
-  } catch {
-    return false;
-  }
+  const resp = await atsFetch(`https://${slug}.recruitee.com/api/offers/`);
+  return probeResult(resp, `Recruitee probe for ${slug}`);
 }

package/src/adapters/smartrecruiters.js

@@ -1,11 +1,14 @@
 import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
+import { makeLocationMatcher } from '../filters.js';
 
 const BASE_URL = 'https://api.smartrecruiters.com/v1/companies';
 const PAGE_SIZE = 100;
+const MAX_DETAIL_FETCHES = 100;
 
 /**
- * Fetch all postings from a SmartRecruiters company.
+ * Fetch postings from a SmartRecruiters company.
  * Public API, no auth required.
  * Docs: https://developers.smartrecruiters.com/reference/postingsget-1
  *
@@ -14,21 +17,29 @@ const PAGE_SIZE = 100;
  *     and the structured `compensation` block with it.
  *   - jd-intel's contract is "full JD text", so we must fetch each
  *     posting's DETAIL endpoint to get jobAd.sections.
- * Large enterprise tenants with hundreds of openings will therefore be
- * slow against SmartRecruiters specifically. This is the API's shape,
- * not a bug here.
+ *
+ * The list does carry name, location and releasedDate, so the same
+ * pre-filter and detail budget Workday applies run here: list-evaluable
+ * filters narrow the candidates, then at most MAX_DETAIL_FETCHES of them
+ * are hydrated (see the budget note below). Without a filterContext the
+ * cap still holds, so a direct call on a 400-posting tenant reads 100.
  *
  * @param {string} slug - SmartRecruiters company identifier (e.g., 'Visa')
+ * @param {object} [ctx] - { filterContext, report }; report is called once
+ *   with { ats, listed, prefiltered, hydrated, capped, org_name, org_url }
+ *   when given
  * @returns {Promise<Array>} Normalized job objects
  */
-export async function fetchSmartrecruiters(slug) {
+export async function fetchSmartrecruiters(slug, ctx = {}) {
+  const fc = ctx.filterContext || {};
+
   // 1. Page through the postings list.
   const postings = [];
   let offset = 0;
 
   while (true) {
     const listUrl = `${BASE_URL}/${slug}/postings?limit=${PAGE_SIZE}&offset=${offset}`;
-    const resp = await fetch(listUrl);
+    const resp = await atsFetch(listUrl);
 
     if (!resp.ok) {
       if (resp.status === 404) return []; // Company not found
@@ -43,14 +54,80 @@ export async function fetchSmartrecruiters(slug) {
     if (content.length === 0 || offset >= (data.totalFound || 0)) break;
   }
 
-  // 2. Fetch detail per posting for the description.
-  const jobs = await Promise.all(postings.map(async (p) => {
+  // 2. Filter-aware candidate selection BEFORE the N+1 detail cost.
+  //    The list row carries name, location and releasedDate, and the
+  //    library re-applies every filter after this returns, so a keep here
+  //    is never final. The detail adds no location (unlike Workday's
+  //    additionalLocations), so a row with none follows the library's
+  //    rule now: out under includes, kept under excludes.
+  let candidates = postings;
+
+  if (fc.titleFilter) {
+    const re = new RegExp(fc.titleFilter, 'i');
+    candidates = candidates.filter(p => re.test(p.name || ''));
+  }
+  if (Array.isArray(fc.locationIncludes) && fc.locationIncludes.length > 0) {
+    const matchers = fc.locationIncludes.map(makeLocationMatcher);
+    candidates = candidates.filter(p => {
+      const loc = listLocation(p).location.toLowerCase();
+      return matchers.some(m => m(loc));
+    });
+  }
+  if (Array.isArray(fc.locationExcludes) && fc.locationExcludes.length > 0) {
+    const matchers = fc.locationExcludes.map(makeLocationMatcher);
+    candidates = candidates.filter(p => {
+      const loc = listLocation(p).location.toLowerCase();
+      return !loc || !matchers.some(m => m(loc));
+    });
+  }
+  if (typeof fc.postedWithinDays === 'number') {
+    // postedAt comes from releasedDate alone, so the library's rule can
+    // run here in full: a missing or unparseable date is out either way.
+    const cutoff = Date.now() - fc.postedWithinDays * 86400000;
+    candidates = candidates.filter(p => {
+      const released = new Date(p.releasedDate || '').getTime();
+      return Number.isFinite(released) && released >= cutoff;
+    });
+  }
+
+  // 3. Bound the detail-fetch set, Workday's reasoning verbatim: a
+  //    description `filter` is applied by the library AFTER this returns,
+  //    so that case keeps the full backstop instead of truncating to
+  //    `limit` (which could hydrate jobs that all fail the regex while
+  //    better matches go unscanned). The library pages with `offset`
+  //    after this returns, so the budget covers the page plus what
+  //    precedes it. Candidates keep list order.
+  const limit = typeof fc.limit === 'number' && fc.limit > 0 ? fc.limit : 100;
+  const skip = typeof fc.offset === 'number' && fc.offset > 0 ? fc.offset : 0;
+  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(skip + limit, MAX_DETAIL_FETCHES);
+  const hydrate = candidates.slice(0, cap);
+
+  // Every list row carries company { identifier, name }. Neither the list
+  // nor the detail has a company website, and postingUrl is always on
+  // jobs.smartrecruiters.com, so org_url stays null (issue #58).
+  if (typeof ctx.report === 'function') {
+    ctx.report({
+      ats: 'smartrecruiters',
+      listed: postings.length,
+      prefiltered: candidates.length,
+      hydrated: hydrate.length,
+      capped: hydrate.length < candidates.length,
+      org_name: postings.find(p => p.company?.name)?.company.name || null,
+      org_url: null,
+    });
+  }
+
+  // 4. Fetch detail per candidate for the description. atsFetch's per-host
+  //    queue keeps this fan-out to 4 requests at a time (a 412-posting
+  //    tenant measured 53s unbounded), so the cap also holds the detail
+  //    step to roughly 13s.
+  const jobs = await Promise.all(hydrate.map(async (p) => {
     let sections = {};
     let postingUrl = '';
     let salary = null;
 
     try {
-      const detailResp = await fetch(`${BASE_URL}/${slug}/postings/${p.id}`);
+      const detailResp = await atsFetch(`${BASE_URL}/${slug}/postings/${p.id}`);
       if (detailResp.ok) {
         const detail = await detailResp.json();
         sections = detail.jobAd?.sections || {};
@@ -58,7 +135,8 @@ export async function fetchSmartrecruiters(slug) {
         salary = parseCompensation(detail.compensation);
       }
     } catch {
-      // Detail fetch failed: fall back to list-only fields (no description).
+      // Detail fetch failed, retries included: fall back to list-only
+      // fields (no description). Reporting this is #85.
     }
 
     const description = [
@@ -67,18 +145,7 @@ export async function fetchSmartrecruiters(slug) {
       sections.additionalInformation?.text,
     ].filter(Boolean).join('\n\n');
 
-    const loc = p.location || {};
-    const place = loc.fullLocation
-      || [loc.city, loc.region, loc.country].filter(Boolean).join(', ');
-    let location = place;
-    let workplace = null;
-    if (loc.remote) {
-      location = `Remote - ${place}`.replace(/ - $/, ' ');
-      workplace = 'remote';
-    } else if (loc.hybrid) {
-      location = `Hybrid - ${place}`.replace(/ - $/, ' ');
-      workplace = 'hybrid';
-    }
+    const { location, workplace } = listLocation(p);
 
     return normalize({
       companySlug: slug,
@@ -104,6 +171,20 @@ export async function fetchSmartrecruiters(slug) {
   return jobs;
 }
 
+/**
+ * The location string and workplace type a list row yields. Built once
+ * here so the pre-filter matches exactly what the normalized job carries,
+ * "Remote - " and "Hybrid - " prefixes included.
+ */
+function listLocation(p) {
+  const loc = p.location || {};
+  const place = loc.fullLocation
+    || [loc.city, loc.region, loc.country].filter(Boolean).join(', ');
+  if (loc.remote) return { location: `Remote - ${place}`.replace(/ - $/, ' '), workplace: 'remote' };
+  if (loc.hybrid) return { location: `Hybrid - ${place}`.replace(/ - $/, ' '), workplace: 'hybrid' };
+  return { location: place, workplace: null };
+}
+
 const PERIODS = { YEARLY: 'year', MONTHLY: 'month', HOURLY: 'hour' };
 
 /**
@@ -130,20 +211,16 @@ function parseCompensation(comp) {
 }
 
 /**
- * Check if a company exists on SmartRecruiters.
- * (HEAD isn't reliably supported on the postings endpoint, so use a
- * minimal GET.)
+ * Check if a company exists on SmartRecruiters. See probeResult for the
+ * outcomes. (HEAD isn't reliably supported on the postings endpoint, so
+ * use a minimal GET.)
  */
 export async function hasSmartrecruiters(slug) {
-  try {
-    const resp = await fetch(`${BASE_URL}/${slug}/postings?limit=1`);
-    if (!resp.ok) return false;
-    // SmartRecruiters returns 200 with an empty page (not 404) for unknown
-    // companies, so resp.ok alone false-positives on any slug. Confirm at
-    // least one real posting exists before claiming a match.
-    const data = await resp.json();
-    return (data.totalFound || 0) > 0 || (data.content || []).length > 0;
-  } catch {
-    return false;
-  }
+  const resp = await atsFetch(`${BASE_URL}/${slug}/postings?limit=1`);
+  if (!probeResult(resp, `SmartRecruiters probe for ${slug}`)) return false;
+  // SmartRecruiters returns 200 with an empty page (not 404) for unknown
+  // companies, so resp.ok alone false-positives on any slug. Confirm at
+  // least one real posting exists before claiming a match.
+  const data = await resp.json();
+  return (data.totalFound || 0) > 0 || (data.content || []).length > 0;
 }

package/src/adapters/teamtailor.js

@@ -1,5 +1,7 @@
 import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch } from '../http.js';
+import { orgHost } from '../boards.js';
 
 /**
  * Fetch jobs from a TeamTailor career site via its public RSS feed.
@@ -23,26 +25,33 @@ import { atsErrorFromStatus } from '../errors.js';
  * collapse by one layer per pass.
  *
  * @param {string} slug - TeamTailor career-site slug (e.g., 'tibber')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { ats, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
 // Most sites are {slug}.teamtailor.com, but some sit on a regional
-// segment, e.g. crunchbase.na.teamtailor.com. '' is the base host.
-const TT_REGIONS = ['', 'na', 'eu'];
+// segment, e.g. crunchbase.na.teamtailor.com. '' is the base host. There
+// is no reachable eu segment: {slug}.eu.teamtailor.com fails TLS for every
+// slug, known or not, because the wildcard certificate covers one label
+// only (live check 2026-09-27). Probing it was a guaranteed failure that
+// the has() contract would now report as an outage.
+const TT_REGIONS = ['', 'na'];
 
 // Feeds send `none`, `hybrid`, `fully` or `onsite`. `none` is no signal.
 const REMOTE_STATUS = { hybrid: 'hybrid', fully: 'remote', onsite: 'onsite' };
 
 /**
  * Resolve which TeamTailor host actually serves this slug's feed.
- * Returns the first 200 Response, throws on a non-404 error, or
- * returns null if no region has a feed.
+ * Returns the first 200 Response, throws on a non-404 error (atsFetch
+ * throws the 429, 5xx and network cases itself), or returns null if no
+ * region has a feed.
  */
 async function resolveFeed(slug, method = 'GET') {
   for (const region of TT_REGIONS) {
     const host = region
       ? `${slug}.${region}.teamtailor.com`
       : `${slug}.teamtailor.com`;
-    const resp = await fetch(`https://${host}/jobs.rss`, {
+    const resp = await atsFetch(`https://${host}/jobs.rss`, {
       method,
       redirect: 'follow',
     });
@@ -55,18 +64,33 @@ async function resolveFeed(slug, method = 'GET') {
   return null;
 }
 
-export async function fetchTeamtailor(slug) {
+export async function fetchTeamtailor(slug, ctx = {}) {
   const resp = await resolveFeed(slug, 'GET');
   if (!resp) return []; // No TeamTailor site in any known region
 
   const xml = await resp.text();
 
-  const company = (
-    xml.match(/<channel>[\s\S]*?<title>([\s\S]*?)<\/title>/)?.[1] || slug
-  ).trim();
+  const channelTitle = (xml.match(/<channel>[\s\S]*?<title>([\s\S]*?)<\/title>/)?.[1] || '').trim();
+  const company = channelTitle || slug;
 
   const items = [...xml.matchAll(/<item>([\s\S]*?)<\/item>/g)].map(m => m[1]);
 
+  // The channel title is the company as the site names itself. The channel
+  // <link> always sits on {slug}.teamtailor.com, but item links follow the
+  // site's custom domain when it has one (jobs.tibber.com on a feed served
+  // from tibber.teamtailor.com), so the first item's link is the host that
+  // can say something; the channel link is the fallback for an empty feed.
+  if (typeof ctx.report === 'function') {
+    const link = items[0]?.match(/<link>([\s\S]*?)<\/link>/)?.[1]
+      || xml.match(/<channel>[\s\S]*?<link>([\s\S]*?)<\/link>/)?.[1]
+      || '';
+    ctx.report({
+      ats: 'teamtailor',
+      org_name: decodeEntities(channelTitle) || null,
+      org_url: orgHost(link.trim()),
+    });
+  }
+
   return items.map(item => {
     const pick = (tag, src = item) => {
       const m = src.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
@@ -120,12 +144,10 @@ export async function fetchTeamtailor(slug) {
 }
 
 /**
- * Check if a company has a TeamTailor career site.
+ * Check if a company has a TeamTailor career site: true when a regional
+ * host serves the feed, false when every host answers 404, and the
+ * AtsError from resolveFeed for anything else.
  */
 export async function hasTeamtailor(slug) {
-  try {
-    return (await resolveFeed(slug, 'HEAD')) !== null;
-  } catch {
-    return false;
-  }
+  return (await resolveFeed(slug, 'HEAD')) !== null;
 }