jd-intel 0.4.1 → 0.6.0

package/README.md

@@ -3,7 +3,8 @@
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node.js 18+](https://img.shields.io/badge/node-18%2B-green.svg)](https://nodejs.org)
 [![npm](https://img.shields.io/npm/v/jd-intel.svg)](https://www.npmjs.com/package/jd-intel)
-[![npm downloads](https://img.shields.io/npm/dt/jd-intel-mcp.svg)](https://www.npmjs.com/package/jd-intel-mcp)
+[![jd-intel downloads](https://badgen.net/npm/dt/jd-intel?label=jd-intel)](https://www.npmjs.com/package/jd-intel)
+[![jd-intel-mcp downloads](https://badgen.net/npm/dt/jd-intel-mcp?label=jd-intel-mcp)](https://www.npmjs.com/package/jd-intel-mcp)
 [![GitHub stars](https://img.shields.io/github/stars/prPMDev/jd-intel.svg?style=flat)](https://github.com/prPMDev/jd-intel/stargazers)
 
 > **Stop pasting job descriptions into AI assistants. Let your AI fetch them directly.**
@@ -41,7 +42,7 @@ Because scraping breaks where jd-intel doesn't:
 - **Full JDs when browsing fails.** SPA-rendered boards, slow loads, auth walls, and geo-restrictions block a browser. They don't block a public API call.
 - **Structured data, not HTML soup.** Salary, location type, department, and clean markdown, normalized across every ATS.
 - **No keys, no browser.** Public APIs only. Runs anywhere your AI does.
-- **One schema, every platform.** Greenhouse, Lever, Ashby, SmartRecruiters, TeamTailor, Recruitee return the same shape.
+- **One schema, every platform.** Greenhouse, Lever, Ashby, SmartRecruiters, TeamTailor, Recruitee, Workday return the same shape.
 
 ---
 
@@ -209,8 +210,8 @@ No custom parsing per company.
 | SmartRecruiters | Shipped | Enterprise and mid-market |
 | TeamTailor | Shipped | European startups and scale-ups |
 | Recruitee | Shipped | Dutch / EU SMBs and scale-ups |
+| Workday | Shipped | Large enterprises (registry-keyed) |
 | Personio | Planned | German / EU mid-market |
-| Workday | Planned | Large enterprises (scoped scraper) |
 
 Adding a new ATS is a single adapter file. See [Contributing](#contributing).
 
@@ -235,10 +236,10 @@ All filters AND together. Deep dive on patterns and gotchas: [docs/filters.md](d
 
 **Shipped**
 - Library, CLI, and MCP server (three surfaces of one toolkit)
-- Greenhouse, Ashby, Lever, SmartRecruiters, TeamTailor, Recruitee adapters
+- Greenhouse, Ashby, Lever, SmartRecruiters, TeamTailor, Recruitee, Workday adapters
 - Title, topic, location, and date filters
 - Salary extraction from JD text
-- Verified company registry (155+ companies)
+- Verified company registry (160+ companies)
 
 **Next**
 - Personio adapter (German / EU mid-market)
@@ -246,7 +247,6 @@ All filters AND together. Deep dive on patterns and gotchas: [docs/filters.md](d
 
 **Planned**
 - Workable adapter (parked — needs SPA shortcode resolution)
-- Workday support (scoped scraper — large enterprise universe)
 - Temporal tracking (when roles open, close, reopen)
 - Change detection
 - Resume-aware fit scoring
@@ -257,7 +257,7 @@ All filters AND together. Deep dive on patterns and gotchas: [docs/filters.md](d
 
 **Add a company to the registry:** submit a PR to the appropriate file in `registry/`.
 
-**Add an ATS adapter:** new file in `src/adapters/`. One adapter, one file. Follow the pattern of the existing three.
+**Add an ATS adapter:** new file in `src/adapters/`. One adapter, one file. Follow the pattern of the existing adapters.
 
 **Request a company:** [open an issue](https://github.com/prPMDev/jd-intel/issues/new). Tell me who's missing.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jd-intel",
-  "version": "0.4.1",
-  "description": "Fetch and normalize job descriptions across every major ATS (Greenhouse, Lever, Ashby) — for your AI assistant, no copy-paste.",
+  "version": "0.6.0",
+  "description": "Fetch and normalize job descriptions across every major ATS (Greenhouse, Lever, Ashby, Workday, and more) — for your AI assistant, no copy-paste.",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/registry/workday.json

@@ -0,0 +1,8 @@
+[
+  {"slug": "cisco",         "name": "Cisco",           "sector": "networking",        "config": {"tenant": "cisco",        "env": "wd5",  "site": "Cisco_Careers"}},
+  {"slug": "salesforce",    "name": "Salesforce",      "sector": "crm / saas",        "config": {"tenant": "salesforce",   "env": "wd12", "site": "External_Career_Site"}},
+  {"slug": "bankofamerica", "name": "Bank of America", "sector": "banking",           "config": {"tenant": "ghr",          "env": "wd1",  "site": "Lateral-US"}},
+  {"slug": "adobe",         "name": "Adobe",           "sector": "creative software", "config": {"tenant": "adobe",        "env": "wd5",  "site": "external_experienced"}},
+  {"slug": "nvidia",        "name": "Nvidia",          "sector": "semiconductors",    "config": {"tenant": "nvidia",       "env": "wd5",  "site": "NVIDIAExternalCareerSite"}},
+  {"slug": "servicetitan",  "name": "ServiceTitan",    "sector": "vertical saas",     "config": {"tenant": "servicetitan", "env": "wd1",  "site": "ServiceTitan"}}
+]

package/src/adapters/index.js

@@ -4,6 +4,7 @@ export { fetchAshby, hasAshby } from './ashby.js';
 export { fetchSmartrecruiters, hasSmartrecruiters } from './smartrecruiters.js';
 export { fetchTeamtailor, hasTeamtailor } from './teamtailor.js';
 export { fetchRecruitee, hasRecruitee } from './recruitee.js';
+export { fetchWorkday, hasWorkday } from './workday.js';
 
 export const ADAPTERS = {
   greenhouse: { fetch: (...args) => import('./greenhouse.js').then(m => m.fetchGreenhouse(...args)), has: (...args) => import('./greenhouse.js').then(m => m.hasGreenhouse(...args)) },
@@ -12,6 +13,7 @@ export const ADAPTERS = {
   smartrecruiters: { fetch: (...args) => import('./smartrecruiters.js').then(m => m.fetchSmartrecruiters(...args)), has: (...args) => import('./smartrecruiters.js').then(m => m.hasSmartrecruiters(...args)) },
   teamtailor: { fetch: (...args) => import('./teamtailor.js').then(m => m.fetchTeamtailor(...args)), has: (...args) => import('./teamtailor.js').then(m => m.hasTeamtailor(...args)) },
   recruitee: { fetch: (...args) => import('./recruitee.js').then(m => m.fetchRecruitee(...args)), has: (...args) => import('./recruitee.js').then(m => m.hasRecruitee(...args)) },
+  workday: { fetch: (...args) => import('./workday.js').then(m => m.fetchWorkday(...args)), has: (...args) => import('./workday.js').then(m => m.hasWorkday(...args)) },
 };
 
 export const ATS_NAMES = Object.keys(ADAPTERS);

package/src/adapters/workday.js

@@ -0,0 +1,198 @@
+import { normalize, stripHtml } from '../normalizer.js';
+
+const MAX_DETAIL_FETCHES = 100;
+const LIST_PAGE_SIZE = 20;
+const LIST_PAGE_HARD_CAP = 100; // <= 2000 list items scanned per request
+
+/**
+ * Fetch jobs from a Workday tenant via the public "CXS" JSON API.
+ *
+ * Workday's career-site SPA calls an unauthenticated JSON API. No
+ * official docs, but it's stable and has no anti-bot at modest volume.
+ *
+ * REGISTRY-ONLY. Workday is keyed by an opaque {tenant, env, site}
+ * triple that is NOT derivable from the company name (Bank of America's
+ * tenant is `ghr`). So this adapter only works when called with
+ * ctx.config from a registry entry; discovery-mode probing (no config)
+ * bails instantly with zero network — see the guard below and
+ * hasWorkday().
+ *
+ * Two-step like SmartRecruiters: a list endpoint (title/location/
+ * postedOn, NO descriptions) plus a per-posting detail endpoint for
+ * the full JD. Enterprise tenants are huge (Salesforce ~1398 jobs), so
+ * we apply list-evaluable filters BEFORE detail-hydrating and cap the
+ * detail set.
+ *
+ * @param {string} slug - normalized company slug (registry routing key)
+ * @param {object} [ctx] - { config:{tenant,env,site}, companyName, filterContext }
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchWorkday(slug, ctx = {}) {
+  const cfg = ctx.config;
+  if (!cfg || !cfg.tenant || !cfg.env || !cfg.site) return []; // registry-only guard
+
+  const { tenant, env, site } = cfg;
+  const base = `https://${tenant}.${env}.myworkdayjobs.com/wday/cxs/${tenant}/${site}`;
+  const fc = ctx.filterContext || {};
+
+  // 1. Page the cheap list (no descriptions in list responses).
+  const postings = [];
+  let offset = 0;
+  let pages = 0;
+  while (pages < LIST_PAGE_HARD_CAP) {
+    const resp = await fetch(`${base}/jobs`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ appliedFacets: {}, limit: LIST_PAGE_SIZE, offset, searchText: '' }),
+    });
+
+    if (!resp.ok) {
+      if (resp.status === 404) return []; // wrong site / no such board
+      if (offset === 0) {
+        throw new Error(`Workday API error for ${slug} (${tenant}/${env}/${site}): ${resp.status}`);
+      }
+      break; // mid-paging failure: keep what we have
+    }
+
+    const data = await resp.json();
+    const page = data.jobPostings || [];
+    postings.push(...page);
+    pages += 1;
+    offset += LIST_PAGE_SIZE;
+    if (page.length === 0 || offset >= (data.total || 0)) break;
+  }
+
+  // 2. Filter-aware candidate selection BEFORE the N+1 detail cost.
+  //    The list carries title/locationsText/postedOn — enough to apply
+  //    titleFilter, location, and recency without descriptions.
+  let candidates = postings;
+
+  if (fc.titleFilter) {
+    const re = new RegExp(fc.titleFilter, 'i');
+    candidates = candidates.filter(p => re.test(p.title || ''));
+  }
+  if (Array.isArray(fc.locationIncludes) && fc.locationIncludes.length > 0) {
+    const inc = fc.locationIncludes.map(s => String(s).toLowerCase());
+    candidates = candidates.filter(p => {
+      const loc = (p.locationsText || '').toLowerCase();
+      return inc.some(s => loc.includes(s));
+    });
+  }
+  if (Array.isArray(fc.locationExcludes) && fc.locationExcludes.length > 0) {
+    const exc = fc.locationExcludes.map(s => String(s).toLowerCase());
+    candidates = candidates.filter(p => {
+      const loc = (p.locationsText || '').toLowerCase();
+      return !exc.some(s => loc.includes(s));
+    });
+  }
+  if (typeof fc.postedWithinDays === 'number') {
+    candidates = candidates.filter(p => withinDays(p.postedOn, fc.postedWithinDays));
+  }
+
+  // 3. Bound the detail-fetch set.
+  //    NOTE: huge-tenant coverage is intentionally capped for v1
+  //    (Salesforce ~1398 postings). A description `filter` is applied
+  //    by the library AFTER this returns, so for that case we keep the
+  //    full backstop instead of truncating tightly to `limit` (which
+  //    could hydrate jobs that all fail the regex while better matches
+  //    go unscanned). Proper fix (smart pagination / rate-limited
+  //    concurrency / surfaced truncation) is tracked in #26, to be
+  //    designed alongside retry/rate-limit work (#7).
+  const limit = typeof fc.limit === 'number' && fc.limit > 0 ? fc.limit : 100;
+  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(limit, MAX_DETAIL_FETCHES);
+  candidates = candidates.slice(0, cap);
+
+  // 4. Hydrate descriptions via the per-posting detail endpoint.
+  const jobs = await Promise.all(candidates.map(async (p) => {
+    const externalPath = p.externalPath || ''; // already begins with '/job/...'
+    let info = {};
+    try {
+      // externalPath already carries the '/job/...' segment, so it is
+      // concatenated directly onto the CXS base. Inserting another
+      // '/job' here yields '/job/job/...' which Workday rejects (422).
+      const dResp = await fetch(`${base}${externalPath}`);
+      if (dResp.ok) {
+        const detail = await dResp.json();
+        info = detail.jobPostingInfo || {};
+      }
+    } catch {
+      // detail failed: fall back to list fields, empty description
+    }
+
+    return normalize({
+      companySlug: slug,
+      company: ctx.companyName || slug,
+      title: p.title || info.title || '',
+      department: '',
+      location: info.location || p.locationsText || '',
+      description: stripHtml(info.jobDescription || ''),
+      url: `https://${tenant}.${env}.myworkdayjobs.com/${site}${externalPath}`,
+      postedAt: parseWorkdayDate(info.startDate) || normalizePostedOn(p.postedOn),
+      salary: null, // normalizer extracts from description text
+      metadata: {
+        workdayTenant: tenant,
+        workdayEnv: env,
+        workdaySite: site,
+        externalPath,
+      },
+    }, 'workday');
+  }));
+
+  return jobs;
+}
+
+/**
+ * Workday list `postedOn` is a relative string ("Posted Today",
+ * "Posted 5 Days Ago", "Posted 30+ Days Ago"). Decide membership in
+ * the last N days WITHOUT a network call. Unparseable -> keep (true);
+ * the library re-filters authoritatively on the real postedAt after
+ * hydration, so a false-keep here is corrected downstream.
+ */
+function withinDays(postedOn, days) {
+  if (!postedOn) return true;
+  const s = String(postedOn).toLowerCase();
+  if (/today/.test(s)) return days >= 0;
+  if (/yesterday/.test(s)) return days >= 1;
+  const m = s.match(/(\d+)\+?\s*days?\s*ago/);
+  if (m) return parseInt(m[1], 10) <= days;
+  return true;
+}
+
+/**
+ * Coerce a Workday list `postedOn` (relative) into an approx ISO date
+ * so the library's postedWithinDays re-filter has a value to compare.
+ */
+function normalizePostedOn(v) {
+  if (!v) return null;
+  const direct = new Date(v);
+  if (Number.isFinite(direct.getTime())) return direct.toISOString();
+  const s = String(v).toLowerCase();
+  let daysAgo = null;
+  if (/today/.test(s)) daysAgo = 0;
+  else if (/yesterday/.test(s)) daysAgo = 1;
+  else {
+    const m = s.match(/(\d+)\+?\s*days?\s*ago/);
+    if (m) daysAgo = parseInt(m[1], 10);
+  }
+  if (daysAgo === null) return null;
+  return new Date(Date.now() - daysAgo * 86400000).toISOString();
+}
+
+/**
+ * Workday detail `startDate` ("2026-05-01" or "May 1, 2026"). Return
+ * ISO, or null if unparseable.
+ */
+function parseWorkdayDate(s) {
+  if (!s) return null;
+  const d = new Date(s);
+  return Number.isFinite(d.getTime()) ? d.toISOString() : null;
+}
+
+/**
+ * Registry-only invariant: the {tenant,env,site} triple can't be
+ * probed from a company name. Always false so detect_ats never selects
+ * Workday and discovery-mode fetchJobs bails via the config guard.
+ */
+export async function hasWorkday() {
+  return false;
+}

package/src/cli.js

@@ -4,7 +4,7 @@
  * jd-intel CLI
  *
  * Usage:
- *   jd-intel fetch <company> [--ats greenhouse|lever|ashby] [--filter keyword|pattern]
+ *   jd-intel fetch <company> [--ats <platform>] [--filter keyword|pattern]
  *   jd-intel detect <company>
  *   jd-intel registry search <query>
  */
@@ -18,12 +18,12 @@ async function main() {
   switch (command) {
     case 'fetch': {
       const company = args[0];
-      if (!company) { console.error('Usage: jd-intel fetch <company> [--ats greenhouse|lever|ashby]'); process.exit(1); }
+      if (!company) { console.error('Usage: jd-intel fetch <company> [--ats <platform>]  (omit --ats to auto-detect; run "jd-intel" for the platform list)'); process.exit(1); }
       const getArg = (flag) => {
         const idx = args.indexOf(flag);
         return idx >= 0 ? args[idx + 1] : undefined;
       };
-      const ats = getArg('--ats');
+      let ats = getArg('--ats');
       const titleFilter = getArg('--title-filter');
       const filter = getArg('--filter');
       const postedWithinRaw = getArg('--posted-within-days');
@@ -35,6 +35,28 @@ async function main() {
       const limitRaw = getArg('--limit');
       const limit = limitRaw !== undefined ? Number(limitRaw) : undefined;
 
+      // Workday is keyed by a {tenant, env, site} triple, not a slug.
+      // Supplying it here makes a Workday board reachable without a
+      // registry entry; presence of the flags infers --ats workday.
+      const wdTenant = getArg('--workday-tenant');
+      const wdEnv = getArg('--workday-env');
+      const wdSite = getArg('--workday-site');
+      let config;
+      if (wdTenant || wdEnv || wdSite) {
+        if (!wdTenant || !wdEnv || !wdSite) {
+          console.error('Workday needs all three: --workday-tenant, --workday-env, --workday-site.');
+          console.error('Find them in the careers URL: https://{tenant}.{env}.myworkdayjobs.com/{site}');
+          console.error('e.g. https://expedia.wd108.myworkdayjobs.com/search  ->  --workday-tenant expedia --workday-env wd108 --workday-site search');
+          process.exit(1);
+        }
+        if (ats && ats !== 'workday') {
+          console.error(`--ats ${ats} conflicts with the --workday-* flags (workday is inferred). Drop one.`);
+          process.exit(1);
+        }
+        config = { tenant: wdTenant, env: wdEnv, site: wdSite };
+        ats = 'workday';
+      }
+
       const parts = [];
       if (titleFilter) parts.push(`title: ${titleFilter}`);
       if (filter) parts.push(`topic: ${filter}`);
@@ -43,10 +65,23 @@ async function main() {
       if (locationExcludes) parts.push(`loc-: ${locationExcludes.join('|')}`);
       const suffix = parts.length ? ` [${parts.join(', ')}]` : '';
 
-      console.log(`Fetching jobs from ${company}${ats ? ` (${ats})` : ' (auto-detect)'}${suffix}...`);
-      const jobs = await fetchJobs({
-        company, ats, titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit,
-      });
+      const atsLabel = config
+        ? ` (workday: ${config.tenant}/${config.env}/${config.site})`
+        : ats ? ` (${ats})` : ' (auto-detect)';
+      console.log(`Fetching jobs from ${company}${atsLabel}${suffix}...`);
+      let jobs;
+      try {
+        jobs = await fetchJobs({
+          company, ats, config, titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit,
+        });
+      } catch (err) {
+        if (config) {
+          console.error(`Could not reach that Workday board (${config.tenant}/${config.env}/${config.site}): ${err.message}`);
+          console.error('Verify the triple against the careers URL: https://{tenant}.{env}.myworkdayjobs.com/{site}');
+          process.exit(1);
+        }
+        throw err;
+      }
       console.log(`Found ${jobs.length} jobs\n`);
 
       for (const job of jobs.slice(0, 20)) {
@@ -112,7 +147,18 @@ Usage:
   jd-intel registry search <query>
 
 Fetch options:
-  --ats greenhouse|lever|ashby    Skip auto-detect
+  --ats <platform>                Skip auto-detect. One of: greenhouse, lever,
+                                  ashby, smartrecruiters, teamtailor, recruitee,
+                                  workday. Omit to auto-detect (registry-backed).
+  --workday-tenant T              Workday is keyed by a {tenant, env, site}
+  --workday-env wdN               triple, not a slug. Registered Workday
+  --workday-site S                companies work via auto-detect or --ats
+                                  workday; for any other Workday board pass
+                                  all three, read from the careers URL
+                                  https://{tenant}.{env}.myworkdayjobs.com/{site}
+                                  e.g. https://expedia.wd108.myworkdayjobs.com/search
+                                  -> --workday-tenant expedia --workday-env wd108
+                                     --workday-site search
   --title-filter pattern          Regex matched against TITLE only (role identity)
   --filter pattern                Regex matched across title, department, description (topic/scope)
   --posted-within-days N          Only jobs posted in the last N days
@@ -132,6 +178,7 @@ Examples:
   jd-intel fetch stripe --title-filter "product manager" --filter "growth|platform"
   jd-intel fetch ramp --location-include "United States,US,Remote - US" --location-exclude "London,Dublin"
   jd-intel fetch notion --ats ashby --title-filter engineer --posted-within-days 14
+  jd-intel fetch expedia --workday-tenant expedia --workday-env wd108 --workday-site search
   jd-intel detect figma
   jd-intel registry search fintech`);
   }

package/src/index.js

@@ -2,11 +2,12 @@
  * jd-intel — JD intelligence toolkit: fetch, normalize, and search job descriptions across every major ATS.
  *
  * Fetches, normalizes, and enriches job data from public ATS APIs
- * (Greenhouse, Lever, Ashby) into a unified schema.
+ * (Greenhouse, Lever, Ashby, SmartRecruiters, Teamtailor, Recruitee,
+ * Workday) into a unified schema.
  */
 
 import { ADAPTERS, ATS_NAMES } from './adapters/index.js';
-import { loadRegistry, searchRegistry, detectAts, findAtsBySlug } from './registry.js';
+import { loadRegistry, searchRegistry, detectAts, findAtsBySlug, findEntryBySlug } from './registry.js';
 import { applyFilters } from './filters.js';
 
 /**
@@ -15,6 +16,7 @@ import { applyFilters } from './filters.js';
  * @param {Object} options
  * @param {string} options.company - Company slug or name
  * @param {string} [options.ats] - Specific ATS platform. If omitted, auto-detects.
+ * @param {object} [options.config] - Adapter-specific config (e.g. Workday {tenant, env, site}). Bypasses the registry; the only way to reach a Workday company not in the registry.
  * @param {string} [options.titleFilter] - Regex matched against title only. Use for role identity ("product manager", "staff engineer").
  * @param {string} [options.filter] - Regex matched across title, department, description. Use for topic/scope.
  * @param {number} [options.postedWithinDays] - Only return jobs posted within N days.
@@ -26,6 +28,7 @@ import { applyFilters } from './filters.js';
 export async function fetchJobs({
   company,
   ats,
+  config,
   titleFilter,
   filter,
   postedWithinDays,
@@ -38,21 +41,51 @@ export async function fetchJobs({
   // Unified slug normalization: strip all non-alphanumeric (matches detectAts)
   const slug = company.toLowerCase().replace(/[^a-z0-9]/g, '');
 
+  // Filter context is passed as an additive 2nd arg to adapters. Existing
+  // adapters declare fetch{Name}(slug) and ignore extra positional args
+  // (JS no-op), so this is backward-compatible. Filter-aware adapters
+  // (e.g. Workday) use it to avoid mass detail-fetching on huge tenants.
+  const filterContext = { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit };
+
   let jobs;
   if (ats) {
     const adapter = ADAPTERS[ats];
     if (!adapter) throw new Error(`Unknown ATS: ${ats}. Supported: ${ATS_NAMES.join(', ')}`);
-    jobs = await adapter.fetch(slug);
+    // Explicit ATS: an explicitly passed config wins (the only path that
+    // can reach a Workday company not in the registry). With no explicit
+    // config, fall back to the registry so config-keyed adapters
+    // (Workday) and canonically-cased registry slugs (SmartRecruiters
+    // "Visa") also work on the explicit path, not just under auto-detect.
+    let fetchSlug = slug;
+    let cfg = config;
+    let companyName;
+    if (!cfg) {
+      const hit = await findEntryBySlug(slug);
+      if (hit && hit.ats === ats) {
+        fetchSlug = hit.entry.slug;
+        cfg = hit.entry.config;
+        companyName = hit.entry.name;
+      }
+    }
+    jobs = await adapter.fetch(fetchSlug, { config: cfg, companyName, filterContext });
   } else {
     // Consult registry first — if we know which ATS this company uses,
     // skip probing the others (saves API calls, clearer error semantics).
-    const known = await findAtsBySlug(slug);
-    if (known) {
-      jobs = await ADAPTERS[known].fetch(slug);
+    // The registry entry carries the canonical slug (so the adapter is
+    // called with the ATS's own casing, e.g. SmartRecruiters "Visa") and
+    // any adapter-specific config (the Workday {tenant,env,site} triple).
+    const hit = await findEntryBySlug(slug);
+    if (hit) {
+      jobs = await ADAPTERS[hit.ats].fetch(hit.entry.slug, {
+        config: config || hit.entry.config,
+        companyName: hit.entry.name,
+        filterContext,
+      });
     } else {
-      // Discovery mode: company not in registry, probe all adapters
+      // Discovery mode: company not in registry, probe all adapters.
+      // (Registry-only adapters like Workday bail here via their guard.)
       const results = await Promise.allSettled(
-        Object.entries(ADAPTERS).map(async ([name, adapter]) => adapter.fetch(slug))
+        Object.entries(ADAPTERS).map(async ([name, adapter]) => adapter.fetch(slug, { filterContext }))
       );
       jobs = results
         .filter(r => r.status === 'fulfilled')
@@ -79,7 +112,7 @@ export { detectAts } from './registry.js';
 
 /**
  * Look up which ATS a slug belongs to in the registry (cached, no network).
- * Returns the ATS name ("greenhouse" | "lever" | "ashby") or null if not in registry.
+ * Returns the ATS name (e.g. "greenhouse", "workday") or null if not in registry.
  */
 export { findAtsBySlug } from './registry.js';
 
@@ -91,6 +124,7 @@ export const registry = {
   search: searchRegistry,
   detect: detectAts,
   findAtsBySlug,
+  findEntryBySlug,
 };
 
 // Re-export individual adapters for direct use

package/src/registry.js

@@ -25,7 +25,7 @@ export async function loadRegistry(ats) {
 
   // Load all
   const all = {};
-  for (const platform of ['greenhouse', 'lever', 'ashby']) {
+  for (const platform of ['greenhouse', 'lever', 'ashby', 'smartrecruiters', 'teamtailor', 'recruitee', 'workday']) {
     try {
       const data = await readFile(join(REGISTRY_DIR, `${platform}.json`), 'utf-8');
       all[platform] = JSON.parse(data);
@@ -58,14 +58,40 @@ export async function searchRegistry(query) {
   return results;
 }
 
+// Slug match is case/punctuation-insensitive: registry slugs are stored
+// in each ATS's canonical form (SmartRecruiters uses PascalCase, e.g.
+// "Visa"), but callers pass a lowercased/alnum-stripped slug. Comparing
+// normalized forms keeps registry-first routing working for those.
+const normSlug = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, '');
+
 /**
  * Look up which ATS a slug belongs to in the registry.
  * Returns the ATS name (e.g., "greenhouse") or null if not in registry.
  */
 export async function findAtsBySlug(slug) {
   const all = await loadRegistry();
+  const key = normSlug(slug);
+  for (const [ats, companies] of Object.entries(all)) {
+    if (companies.some(c => normSlug(c.slug) === key)) return ats;
+  }
+  return null;
+}
+
+/**
+ * Look up the full registry entry for a slug, with its ATS.
+ * Unlike findAtsBySlug (returns just the ats name), this returns the
+ * whole entry so callers can read adapter-specific config (e.g. the
+ * Workday {tenant, env, site} triple). Additive — does not change
+ * findAtsBySlug, which has other callers.
+ *
+ * @returns {Promise<{ats: string, entry: object}|null>}
+ */
+export async function findEntryBySlug(slug) {
+  const all = await loadRegistry();
+  const key = normSlug(slug);
   for (const [ats, companies] of Object.entries(all)) {
-    if (companies.some(c => c.slug === slug)) return ats;
+    const entry = companies.find(c => normSlug(c.slug) === key);
+    if (entry) return { ats, entry };
   }
   return null;
 }