jd-intel 0.11.0 → 0.12.0

package/README.md

@@ -9,7 +9,7 @@
 
 > **Stop pasting job descriptions into AI assistants. Let your AI fetch them directly.**
 
-Full text. Clean structure. Across seven major ATS. No copy-paste. No context loss.
+Full text. Clean structure. Across nine major ATS. No copy-paste. No context loss.
 
 ---
 
@@ -40,9 +40,9 @@ Done.
 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 seven ATS.
+- **Structured data, not HTML soup.** Salary, location type, department, and clean markdown, normalized across nine ATS.
 - **No keys, no browser.** Public APIs only. Runs anywhere your AI does.
-- **One schema, every platform.** Greenhouse, Lever, Ashby, SmartRecruiters, Teamtailor, Recruitee, Workday return the same shape.
+- **One schema, every platform.** Greenhouse, Lever, Ashby, SmartRecruiters, Teamtailor, Recruitee, Personio, Workable, Workday return the same shape.
 
 ---
 
@@ -257,8 +257,9 @@ 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 |
+| Personio | Shipped | German / EU mid-market |
+| Workable | Shipped | SMBs worldwide |
 | Workday | Shipped | Large enterprises (registry-keyed) |
-| Personio | Planned | German / EU mid-market |
 
 Adding a new ATS is a single adapter file. See [Contributing](#contributing).
 
@@ -283,14 +284,12 @@ 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, Workday adapters
+- Greenhouse, Ashby, Lever, SmartRecruiters, Teamtailor, Recruitee, Personio, Workable, Workday adapters
 - Title, topic, location, and date filters
 - Salary extraction from JD text
-- Verified company registry (900+ companies)
+- Verified company registry (1,000+ companies)
 
 **Next**
-- Personio adapter (German / EU mid-market)
-- Workable adapter (widget API; broad SMB coverage)
 - Anthropic MCP marketplace submission
 
 **Planned**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jd-intel",
-  "version": "0.11.0",
-  "description": "Fetch and normalize job descriptions across seven major ATS (Greenhouse, Lever, Ashby, Workday, and more), for your AI assistant. No copy-paste.",
+  "version": "0.12.0",
+  "description": "Fetch and normalize job descriptions across nine major ATS (Greenhouse, Lever, Ashby, Workday, and more), for your AI assistant. No copy-paste.",
   "type": "module",
   "main": "src/index.js",
   "bin": {
@@ -15,7 +15,6 @@
   "scripts": {
     "test": "node --test test/*.test.js",
     "fetch": "node src/cli.js fetch",
-    "search": "node src/cli.js search",
     "verify:registry": "node scripts/verify-registry.mjs",
     "sync:registry-pages": "node scripts/sync-pages-registry.mjs",
     "pack:mcpb": "node scripts/build-mcpb.mjs",

package/registry/personio.json

@@ -0,0 +1,11 @@
+[
+  {"slug": "1komma5grad", "name": "1KOMMA5°",    "sector": "energy tech"},
+  {"slug": "thermondo",   "name": "Thermondo",   "sector": "energy tech"},
+  {"slug": "westwing",    "name": "Westwing",    "sector": "ecommerce"},
+  {"slug": "vivid",       "name": "Vivid Money", "sector": "fintech (banking)"},
+  {"slug": "merantix",    "name": "Merantix",    "sector": "ai venture studio"},
+  {"slug": "ottonova",    "name": "ottonova",    "sector": "health insurance"},
+  {"slug": "finanzguru",  "name": "Finanzguru",  "sector": "fintech"},
+  {"slug": "holidu",      "name": "Holidu",      "sector": "travel tech"},
+  {"slug": "clark",       "name": "CLARK",       "sector": "insurtech"}
+]

package/registry/workable.json

@@ -0,0 +1,17 @@
+[
+  {"slug": "viva",           "name": "Viva.com",        "sector": "fintech / payments"},
+  {"slug": "spotawheel",     "name": "Spotawheel",      "sector": "automotive"},
+  {"slug": "learnworlds",    "name": "LearnWorlds",     "sector": "edtech"},
+  {"slug": "welcomepickups", "name": "Welcome Pickups", "sector": "travel tech"},
+  {"slug": "novibet",        "name": "Novibet",         "sector": "gaming"},
+  {"slug": "upstream",       "name": "Upstream",        "sector": "marketing tech"},
+  {"slug": "skroutz",        "name": "Skroutz",         "sector": "ecommerce"},
+  {"slug": "epignosis",      "name": "Epignosis",       "sector": "edtech"},
+  {"slug": "blueground",     "name": "Blueground",      "sector": "real estate tech"},
+  {"slug": "orfium",         "name": "Orfium",          "sector": "media"},
+  {"slug": "huggingface",    "name": "Hugging Face",    "sector": "ai / llms"},
+  {"slug": "hellasdirect",   "name": "Hellas Direct",   "sector": "insurtech"},
+  {"slug": "ferryhopper",    "name": "Ferryhopper",     "sector": "travel tech"},
+  {"slug": "persado",        "name": "Persado",         "sector": "marketing tech"},
+  {"slug": "natech",         "name": "Natech",          "sector": "banking software"}
+]

package/src/adapters/index.js

@@ -4,6 +4,8 @@ import { fetchAshby, hasAshby } from './ashby.js';
 import { fetchSmartrecruiters, hasSmartrecruiters } from './smartrecruiters.js';
 import { fetchTeamtailor, hasTeamtailor } from './teamtailor.js';
 import { fetchRecruitee, hasRecruitee } from './recruitee.js';
+import { fetchPersonio, hasPersonio } from './personio.js';
+import { fetchWorkable, hasWorkable } from './workable.js';
 import { fetchWorkday, hasWorkday } from './workday.js';
 
 export {
@@ -13,6 +15,8 @@ export {
   fetchSmartrecruiters, hasSmartrecruiters,
   fetchTeamtailor, hasTeamtailor,
   fetchRecruitee, hasRecruitee,
+  fetchPersonio, hasPersonio,
+  fetchWorkable, hasWorkable,
   fetchWorkday, hasWorkday,
 };
 
@@ -23,6 +27,8 @@ export const ADAPTERS = {
   smartrecruiters: { fetch: fetchSmartrecruiters, has: hasSmartrecruiters },
   teamtailor: { fetch: fetchTeamtailor, has: hasTeamtailor },
   recruitee: { fetch: fetchRecruitee, has: hasRecruitee },
+  personio: { fetch: fetchPersonio, has: hasPersonio },
+  workable: { fetch: fetchWorkable, has: hasWorkable },
   workday: { fetch: fetchWorkday, has: hasWorkday },
 };
 

package/src/adapters/lever.js

@@ -1,4 +1,4 @@
-import { normalize, extractSalaryFromText } from '../normalizer.js';
+import { normalize, extractSalaryFromText, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
 
@@ -44,7 +44,7 @@ export async function fetchLever(slug) {
     workplace: job.workplaceType,
     description: buildDescription(job),
     url: job.hostedUrl || '',
-    postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
+    postedAt: toIso(job.createdAt),
     salary: parseLeverSalary(job.salaryRange, job.text),
     metadata: {
       leverId: job.id,

package/src/adapters/personio.js

@@ -0,0 +1,106 @@
+import { normalize, decodeEntities, toIso } from '../normalizer.js';
+import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch } from '../http.js';
+
+/**
+ * Fetch jobs from a Personio career site via its public XML feed.
+ *
+ * `{slug}.jobs.personio.de/xml` is the unauthenticated feed Personio
+ * publishes for job-board integrations. One GET returns every open
+ * position with its full description, split into titled sections
+ * ("Your mission", "Your profile"), each an HTML fragment inside CDATA.
+ *
+ * Existence is read from the status, not the body: a career site with
+ * nothing open answers 200 with an empty <workzag-jobs>, and a slug with
+ * no site answers 307 to personio.com. So the request must not follow
+ * redirects, or every unknown slug would read as a marketing page.
+ *
+ * The feed names no company. `subcompany` is the hiring legal entity
+ * where the tenant set one, so it is what the board states about itself.
+ *
+ * @param {string} slug - Personio career-site subdomain (e.g., 'holidu')
+ * @param {object} [ctx] - { companyName, report }; report is called once with
+ *   { org_name, org_url } when given
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchPersonio(slug, ctx = {}) {
+  const resp = await requestFeed(slug);
+  if (!resp) return []; // No Personio career site for this slug
+
+  const xml = await resp.text();
+  const positions = [...xml.matchAll(/<position>([\s\S]*?)<\/position>/g)].map(m => m[1]);
+  const pick = (src, tag) => decodeEntities(src.match(new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`))?.[1].trim() || '');
+
+  // Every link is on jobs.personio.de, so there is no company host to report.
+  if (typeof ctx.report === 'function') {
+    ctx.report({ org_name: positions.map(p => pick(p, 'subcompany')).find(Boolean) || null, org_url: null });
+  }
+
+  return positions.map(raw => {
+    // The posting's own fields, without the sections: each section has a
+    // <name> of its own.
+    const position = raw.replace(/<jobDescriptions>[\s\S]*<\/jobDescriptions>/, '');
+    const id = pick(position, 'id');
+    // The primary <office>, then any under <additionalOffices>.
+    const offices = [...position.matchAll(/<office>([\s\S]*?)<\/office>/g)].map(m => decodeEntities(m[1].trim()));
+
+    return normalize({
+      companySlug: slug,
+      // The feed names no company; subcompany is a legal entity that varies
+      // per posting, so it goes to metadata and the registry name labels the job.
+      company: ctx.companyName || slug,
+      title: pick(position, 'name'),
+      department: pick(position, 'department'),
+      location: offices[0] || '',
+      locations: offices,
+      workplace: null, // The feed has no remote/hybrid field; the location string decides.
+      description: buildDescription(raw),
+      url: id ? `https://${slug}.jobs.personio.de/job/${id}` : '',
+      postedAt: toIso(pick(position, 'createdAt')),
+      salary: null, // No structured salary; normalizer parses from text
+      metadata: {
+        personioId: id,
+        subcompany: pick(position, 'subcompany'),
+        recruitingCategory: pick(position, 'recruitingCategory'),
+        employmentType: pick(position, 'employmentType'),
+        seniority: pick(position, 'seniority'),
+        schedule: pick(position, 'schedule'),
+        yearsOfExperience: pick(position, 'yearsOfExperience'),
+      },
+    }, 'personio');
+  });
+}
+
+/**
+ * The feed response, or null when the slug has no career site (a redirect
+ * or a 404). atsFetch throws the 429, 5xx and network cases itself.
+ */
+async function requestFeed(slug) {
+  const resp = await atsFetch(`https://${slug}.jobs.personio.de/xml?language=en`, { redirect: 'manual' });
+  if (resp.ok) return resp;
+  if (resp.status === 404 || (resp.status >= 300 && resp.status < 400)) return null;
+  throw atsErrorFromStatus(resp.status, `Personio feed error for ${slug}: ${resp.status}`);
+}
+
+/**
+ * One posting's sections as HTML: each <jobDescription> is a plain-text
+ * <name> heading and a CDATA <value> that already holds HTML. Only the
+ * CDATA wrapper comes off here; normalize() strips and decodes the rest,
+ * once (see normalizer.js).
+ */
+function buildDescription(position) {
+  return [...position.matchAll(/<jobDescription>([\s\S]*?)<\/jobDescription>/g)].map(([, section]) => {
+    const heading = section.match(/<name>([\s\S]*?)<\/name>/)?.[1].trim() || '';
+    const value = (section.match(/<value>([\s\S]*?)<\/value>/)?.[1] || '').replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1').trim();
+    return (heading ? `<h3>${heading}</h3>` : '') + value;
+  }).filter(Boolean).join('\n');
+}
+
+/**
+ * Check if a company has a Personio career site: true when the feed
+ * answers, false on a redirect or a 404, and the AtsError from requestFeed
+ * for anything else.
+ */
+export async function hasPersonio(slug) {
+  return (await requestFeed(slug)) !== null;
+}

package/src/adapters/recruitee.js

@@ -1,4 +1,4 @@
-import { normalize } from '../normalizer.js';
+import { normalize, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
 import { orgHost } from '../boards.js';
@@ -51,7 +51,7 @@ export async function fetchRecruitee(slug, ctx = {}) {
     let location = place;
     if (offer.remote) location = place ? `Remote - ${place}` : 'Remote';
 
-    const createdAt = toIso(offer.created_at);
+    const createdAt = recruiteeDate(offer.created_at);
 
     return normalize({
       companySlug: slug,
@@ -65,7 +65,7 @@ export async function fetchRecruitee(slug, ctx = {}) {
       url: offer.careers_url || offer.careers_apply_url || '',
       // created_at can predate publication by years on long-lived offers,
       // so it is not a posting date. published_at is.
-      postedAt: toIso(offer.published_at) || createdAt,
+      postedAt: recruiteeDate(offer.published_at) || createdAt,
       salary: parseRecruiteeSalary(offer.salary),
       metadata: {
         recruiteeId: offer.guid || offer.id,
@@ -77,14 +77,8 @@ export async function fetchRecruitee(slug, ctx = {}) {
   });
 }
 
-/**
- * Recruitee returns "2026-05-13 07:38:11 UTC"; coerce to ISO.
- */
-function toIso(ts) {
-  if (!ts) return null;
-  const d = new Date(ts.replace(' UTC', 'Z').replace(' ', 'T'));
-  return Number.isNaN(d.getTime()) ? null : d.toISOString();
-}
+// Recruitee returns "2026-05-13 07:38:11 UTC".
+const recruiteeDate = (ts) => toIso(ts?.replace(' UTC', 'Z').replace(' ', 'T'));
 
 /**
  * Recruitee sends three booleans, not one enum. Hybrid wins when remote is

package/src/adapters/teamtailor.js

@@ -1,4 +1,4 @@
-import { normalize, decodeEntities } from '../normalizer.js';
+import { normalize, decodeEntities, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch } from '../http.js';
 import { orgHost } from '../boards.js';
@@ -116,12 +116,6 @@ export async function fetchTeamtailor(slug, ctx = {}) {
       location = location ? `Remote - ${location}` : 'Remote';
     }
 
-    let postedAt = null;
-    if (pubDateRaw) {
-      const d = new Date(pubDateRaw);
-      if (!Number.isNaN(d.getTime())) postedAt = d.toISOString();
-    }
-
     return normalize({
       companySlug: slug,
       company,
@@ -132,7 +126,7 @@ export async function fetchTeamtailor(slug, ctx = {}) {
       workplace: REMOTE_STATUS[remoteStatus.toLowerCase()] || null,
       description: decodeEntities(pick('description')),
       url: link,
-      postedAt,
+      postedAt: toIso(pubDateRaw),
       salary: null, // No structured salary; normalizer parses from text
       metadata: {
         teamtailorId: guid,

package/src/adapters/workable.js

@@ -0,0 +1,78 @@
+import { normalize, toIso } from '../normalizer.js';
+import { atsErrorFromStatus } from '../errors.js';
+import { atsFetch, probeResult } from '../http.js';
+
+const BASE_URL = 'https://apply.workable.com/api/v1/widget/accounts';
+
+/**
+ * Fetch jobs from a Workable careers page via its public widget endpoint.
+ *
+ * Why the widget, not the official API: Workable's REST API needs a
+ * per-account token. The widget endpoint is the unauthenticated one the
+ * hosted careers page itself calls, and `details=true` adds each job's
+ * full HTML description, so one GET returns the whole board.
+ *
+ * An account with nothing open answers 200 with `jobs: []`; a slug with no
+ * account answers 404.
+ *
+ * @param {string} slug - Workable account slug (e.g., 'epignosis')
+ * @param {object} [ctx] - { report }; report is called once with
+ *   { org_name, org_url } when given
+ * @returns {Promise<Array>} Normalized job objects
+ */
+export async function fetchWorkable(slug, ctx = {}) {
+  const resp = await atsFetch(`${BASE_URL}/${slug}?details=true`);
+
+  if (!resp.ok) {
+    if (resp.status === 404) return []; // No Workable account for this slug
+    throw atsErrorFromStatus(resp.status, `Workable API error for ${slug}: ${resp.status}`);
+  }
+
+  const data = await resp.json();
+  const jobs = data.jobs || [];
+
+  // The account's own name is at the top of the response. Every link is on
+  // apply.workable.com, so there is no company host to report.
+  if (typeof ctx.report === 'function') {
+    ctx.report({ org_name: data.name || null, org_url: null });
+  }
+
+  return jobs.map(job => {
+    const place = [job.city, job.state, job.country].filter(Boolean).join(', ');
+    return normalize({
+      companySlug: slug,
+      company: data.name || slug,
+      title: job.title || '',
+      department: job.department || '',
+      location: job.telecommuting ? (place ? `Remote - ${place}` : 'Remote') : place,
+      locations: (job.locations || [])
+        .filter(l => !l.hidden)
+        .map(l => [l.city, l.region, l.country].filter(Boolean).join(', ')),
+      // `telecommuting` can only say remote; false means nothing.
+      workplace: job.telecommuting === true ? 'remote' : null,
+      description: job.description || '',
+      url: job.url || job.shortlink || '',
+      // Date-only strings ("2026-09-07").
+      postedAt: toIso(job.published_on) || toIso(job.created_at),
+      salary: null, // No structured salary; normalizer parses from text
+      metadata: {
+        workableId: job.shortcode,
+        code: job.code || '',
+        employmentType: job.employment_type || '',
+        experience: job.experience || '',
+        education: job.education || '',
+        industry: job.industry || '',
+        function: job.function || '',
+      },
+    }, 'workable');
+  });
+}
+
+/**
+ * Check if a company has a Workable account. See probeResult for the
+ * outcomes. The plain list (no details) is the cheap request.
+ */
+export async function hasWorkable(slug) {
+  const resp = await atsFetch(`${BASE_URL}/${slug}`);
+  return probeResult(resp, `Workable probe for ${slug}`);
+}

package/src/adapters/workday.js

@@ -1,4 +1,4 @@
-import { normalize, missingContent } from '../normalizer.js';
+import { normalize, missingContent, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { prefilterRows } from '../filters.js';
 import { atsFetch } from '../http.js';
@@ -151,7 +151,8 @@ export async function fetchWorkday(slug, ctx = {}) {
       workplace: parseWorkdayRemoteType(info.remoteType),
       description: info.jobDescription || '',
       url: `https://${tenant}.${env}.myworkdayjobs.com/${site}${externalPath}`,
-      postedAt: parseWorkdayDate(info.startDate) || normalizePostedOn(p.postedOn),
+      // startDate is "2026-05-01" or "May 1, 2026".
+      postedAt: toIso(info.startDate) || normalizePostedOn(p.postedOn),
       salary: null, // normalizer extracts from description text
       content,
       metadata: {
@@ -223,23 +224,12 @@ function withinDays(postedOn, days) {
  * 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 direct = toIso(v);
+  if (direct) return direct;
   const n = daysAgo(v);
   return n === null ? null : new Date(Date.now() - n * 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

package/src/boards.js

@@ -18,13 +18,15 @@ const BOARD_URLS = {
   smartrecruiters: (slug) => `https://careers.smartrecruiters.com/${slug}`,
   teamtailor: (slug) => `https://${slug}.teamtailor.com`,
   recruitee: (slug) => `https://${slug}.recruitee.com`,
+  personio: (slug) => `https://${slug}.jobs.personio.de`,
+  workable: (slug) => `https://apply.workable.com/${slug}`,
   workday: (slug, config) => (config ? `https://${config.tenant}.${config.env}.myworkdayjobs.com/${config.site}` : null),
 };
 
 // Domains the platforms own. A link there (boards.greenhouse.io,
 // jobs.lever.co, testco.recruitee.com, cisco.wd5.myworkdayjobs.com) says
 // which ATS hosts the board, nothing about whose board it is.
-const ATS_DOMAINS = ['greenhouse.io', 'lever.co', 'ashbyhq.com', 'smartrecruiters.com', 'teamtailor.com', 'recruitee.com', 'myworkdayjobs.com'];
+const ATS_DOMAINS = ['greenhouse.io', 'lever.co', 'ashbyhq.com', 'smartrecruiters.com', 'teamtailor.com', 'recruitee.com', 'personio.de', 'personio.com', 'workable.com', 'myworkdayjobs.com'];
 
 /**
  * The page a person opens to see the board, or null when the ATS is unknown

package/src/cli.js

@@ -163,7 +163,8 @@ Usage:
 Fetch options:
   --ats <platform>                Skip auto-detect. One of: greenhouse, lever,
                                   ashby, smartrecruiters, teamtailor, recruitee,
-                                  workday. Omit to auto-detect (registry-backed).
+                                  personio, workable, 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

package/src/index.js

@@ -3,7 +3,7 @@
  *
  * Fetches, normalizes, and enriches job data from public ATS APIs
  * (Greenhouse, Lever, Ashby, SmartRecruiters, Teamtailor, Recruitee,
- * Workday) into a unified schema.
+ * Personio, Workable, Workday) into a unified schema.
  */
 
 import { ADAPTERS, ATS_NAMES } from './adapters/index.js';

package/src/normalizer.js

@@ -1,5 +1,15 @@
 import { createHash } from 'node:crypto';
 
+/**
+ * A date value (string or epoch ms) as an ISO string, or null when it is
+ * missing or does not parse.
+ */
+export function toIso(value) {
+  if (!value) return null;
+  const d = new Date(value);
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+
 /**
  * Generate a stable ID for a job posting.
  */

package/src/registry.js

@@ -7,11 +7,6 @@ import { ADAPTERS, ATS_NAMES } from './adapters/index.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REGISTRY_DIR = join(__dirname, '..', 'registry');
 
-// The one order the registry is ever walked in. Lookups, detectAts and the
-// loaded object all follow it, so which file answers for a slug does not
-// depend on which file's load finished first (issue #87).
-const PLATFORMS = ATS_NAMES;
-
 // Network-first registry. A hosted copy lets installed bundles AND npx users
 // pick up newly-added companies without reinstalling; the on-disk copy that
 // ships with the package is the guaranteed offline fallback. The base URL is
@@ -73,8 +68,11 @@ async function loadPlatform(platform) {
  */
 export async function loadRegistry(ats) {
   if (ats) return loadPlatform(ats);
-  const lists = await Promise.all(PLATFORMS.map(loadPlatform));
-  return Object.fromEntries(PLATFORMS.map((platform, i) => [platform, lists[i]]));
+  // ATS_NAMES is the one order the registry is ever walked in. Lookups,
+  // detectAts and this object all follow it, so which file answers for a
+  // slug does not depend on which file's load finished first (issue #87).
+  const lists = await Promise.all(ATS_NAMES.map(loadPlatform));
+  return Object.fromEntries(ATS_NAMES.map((platform, i) => [platform, lists[i]]));
 }
 
 /**
@@ -127,7 +125,7 @@ export async function searchRegistry(query) {
 // normalized forms keeps registry-first routing working for those.
 export const normSlug = (s) => String(s).toLowerCase().replace(/[^a-z0-9]/g, '');
 
-const byPlatform = (a, b) => PLATFORMS.indexOf(a.ats) - PLATFORMS.indexOf(b.ats);
+const byPlatform = (a, b) => ATS_NAMES.indexOf(a.ats) - ATS_NAMES.indexOf(b.ats);
 
 /**
  * Look up which ATS a slug belongs to in the registry.
@@ -143,7 +141,7 @@ export async function findAtsBySlug(slug) {
  * 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). The files are searched in
- * PLATFORMS order, so the first match is the same on every call.
+ * ATS_NAMES order, so the first match is the same on every call.
  *
  * @returns {Promise<{ats: string, entry: object}|null>}
  */
@@ -167,7 +165,7 @@ export async function findEntryBySlug(slug) {
  * adds nothing, and an AtsError (429, 5xx, 401, network) goes to `failed`
  * with its code, so a board the probe could not check never reads as
  * absent (issue #55). Any other error is a bug and is rethrown. Both lists
- * come back in PLATFORMS order, never in completion order.
+ * come back in ATS_NAMES order, never in completion order.
  *
  * @returns {Promise<{
  *   boards: Array<{ ats: string, slug: string, source: 'registry'|'probe' }>,