jd-intel 0.10.0 → 0.11.1

package/README.md

@@ -240,7 +240,8 @@ No custom parsing per company.
 | `locationType` | `remote`, `hybrid`, `onsite`, or `unknown` when neither the platform nor the location text says |
 | `workplace` | `{ type, source }`. `type` repeats `locationType`; `source` is `ats` when the platform stated it, `text` when read from the location string, null when unknown |
 | `salary` | Min-max range with `currency`, plus `period` (`year`, `month`, `hour`, or null) and `source` (`ats` when the platform supplied it, `text` when parsed from the posting). Null when nothing is stated |
-| `description` | Full JD in clean markdown |
+| `description` | Full JD in clean markdown. Empty when `content.status` is `missing` |
+| `content` | `{ status, reason }`. `complete` when the posting was read. `missing` when Workday or SmartRecruiters listed the job but its detail request failed (`reason`: `http_503`, `http_429`, `network_error`), so `description` and `salary` are unknown |
 | `url` | Direct link to the posting |
 | `postedAt` | Publication date (when provided) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jd-intel",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "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",
@@ -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/src/adapters/ashby.js

@@ -1,4 +1,4 @@
-import { normalize, extractSalaryFromText } from '../normalizer.js';
+import { normalize, extractSalaryFromText, WORKPLACE_TYPES } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
 
@@ -14,11 +14,9 @@ const BOARD_URL = 'https://api.ashbyhq.com/posting-api/job-board';
  * 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, ctx = {}) {
+export async function fetchAshby(slug) {
   const url = `${BOARD_URL}/${slug}?includeCompensation=true`;
   const resp = await atsFetch(url);
 
@@ -31,10 +29,8 @@ export async function fetchAshby(slug, ctx = {}) {
   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 });
-  }
+  // every link is on jobs.ashbyhq.com. Nothing to report, so the board's
+  // org_name and org_url stay null (issue #58).
 
   return jobs.map(job => {
     const comp = job.compensation || {};
@@ -69,16 +65,14 @@ export async function fetchAshby(slug, ctx = {}) {
   });
 }
 
-const WORKPLACE_TYPES = { remote: 'remote', hybrid: 'hybrid', onsite: 'onsite' };
-
 /**
  * `workplaceType` is 'Remote', 'Hybrid' or 'OnSite'. `isRemote` is the
  * older flag and can only say remote, so it is the fallback when the type
  * is absent. false means nothing: the role may be hybrid or onsite.
  */
 function parseAshbyWorkplace(job) {
-  const type = WORKPLACE_TYPES[String(job.workplaceType || '').toLowerCase()];
-  if (type) return type;
+  const type = String(job.workplaceType || '').toLowerCase();
+  if (WORKPLACE_TYPES.has(type)) return type;
   return job.isRemote === true ? 'remote' : null;
 }
 

package/src/adapters/greenhouse.js

@@ -1,4 +1,4 @@
-import { normalize, decodeEntities } from '../normalizer.js';
+import { normalize, decodeEntities, periodWord } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
 
@@ -11,11 +11,12 @@ const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
  *
  * @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
+ *   { org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
 export async function fetchGreenhouse(slug, ctx = {}) {
-  const url = `${BASE_URL}/${slug}/jobs?content=true`;
+  // pay_transparency adds pay_input_ranges to each row (issue #86).
+  const url = `${BASE_URL}/${slug}/jobs?content=true&pay_transparency=true`;
   const resp = await atsFetch(url);
 
   if (!resp.ok) {
@@ -31,35 +32,86 @@ export async function fetchGreenhouse(slug, ctx = {}) {
   // 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,
-    title: job.title || '',
-    department: job.departments?.[0]?.name || '',
-    location: job.location?.name || '',
-    workplace: parseGreenhouseWorkplace(job.metadata),
-    // `content` arrives HTML-escaped (`&lt;p&gt;`). Decode that outer layer
-    // once so normalize() sees real tags; it strips and decodes the rest.
-    description: decodeEntities(job.content || ''),
-    url: job.absolute_url || '',
-    // updated_at is an edit time that many boards bulk-refresh, so it is not
-    // a posting date. first_published is. Fallback covers boards without it (#69).
-    postedAt: job.first_published || job.updated_at || null,
-    salary: null, // list endpoint has no structured pay; normalizer parses the pay transparency text
-    metadata: {
-      greenhouseId: job.id,
-      internal_job_id: job.internal_job_id,
-      departments: job.departments?.map(d => d.name) || [],
-      offices: job.offices?.map(o => o.name) || [],
-      updatedAt: job.updated_at,
-    },
-  }, 'greenhouse'));
+  return jobs.map(job => {
+    const payRanges = parsePayRanges(job.pay_input_ranges);
+    return normalize({
+      companySlug: slug,
+      company: data.name || slug,
+      title: job.title || '',
+      department: job.departments?.[0]?.name || '',
+      location: job.location?.name || '',
+      workplace: parseGreenhouseWorkplace(job.metadata),
+      // `content` arrives HTML-escaped (`&lt;p&gt;`). Decode that outer layer
+      // once so normalize() sees real tags; it strips and decodes the rest.
+      description: decodeEntities(job.content || ''),
+      url: job.absolute_url || '',
+      // updated_at is an edit time that many boards bulk-refresh, so it is not
+      // a posting date. first_published is. Fallback covers boards without it (#69).
+      postedAt: job.first_published || job.updated_at || null,
+      salary: salaryFromRanges(payRanges), // null without structured pay; normalize() then parses the text
+      metadata: {
+        greenhouseId: job.id,
+        internal_job_id: job.internal_job_id,
+        departments: job.departments?.map(d => d.name) || [],
+        offices: job.offices?.map(o => o.name) || [],
+        updatedAt: job.updated_at,
+        payRanges,
+      },
+    }, 'greenhouse');
+  });
+}
+
+/**
+ * `pay_input_ranges` is the board's pay transparency data:
+ * [{ min_cents, max_cents, currency_type, title, blurb }]. The blurb is
+ * boilerplate already rendered in the description, so it is dropped, and
+ * the platform can send the same entry twice, so entries are deduplicated.
+ * A board that does not publish pay sends an empty array or no key.
+ */
+function parsePayRanges(ranges) {
+  const seen = new Set();
+  const out = [];
+  for (const r of Array.isArray(ranges) ? ranges : []) {
+    const range = {
+      title: r.title || '',
+      min: Number.isFinite(r.min_cents) ? r.min_cents / 100 : null,
+      max: Number.isFinite(r.max_cents) ? r.max_cents / 100 : null,
+      currency: r.currency_type || 'USD',
+    };
+    const key = JSON.stringify(range);
+    if ((range.min === null && range.max === null) || seen.has(key)) continue;
+    seen.add(key);
+    out.push(range);
+  }
+  return out;
+}
+
+/**
+ * One salary from the ranges. Ranges in one currency span (lowest min,
+ * highest max), as the Ashby adapter does for its tiers; with mixed
+ * currencies the first range stands alone. Every range stays in
+ * metadata.payRanges. The field has no period, so the period is the one
+ * the range titles state ("Annual", "Hourly") and null when they state
+ * none or disagree: an 'ats' value carries no guessed period.
+ */
+function salaryFromRanges(ranges) {
+  if (ranges.length === 0) return null;
+  const used = ranges.every(r => r.currency === ranges[0].currency) ? ranges : [ranges[0]];
+  const mins = used.map(r => r.min).filter(v => v !== null);
+  const maxes = used.map(r => r.max).filter(v => v !== null);
+  const periods = new Set(used.map(r => periodWord(r.title)));
+  return {
+    min: mins.length ? Math.min(...mins) : null,
+    max: maxes.length ? Math.max(...maxes) : null,
+    currency: used[0].currency,
+    period: periods.size === 1 ? [...periods][0] : null,
+    source: 'ats',
+  };
 }
 
 /**

package/src/adapters/index.js

@@ -1,19 +1,29 @@
-export { fetchGreenhouse, hasGreenhouse } from './greenhouse.js';
-export { fetchLever, hasLever } from './lever.js';
-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';
+import { fetchGreenhouse, hasGreenhouse } from './greenhouse.js';
+import { fetchLever, hasLever } from './lever.js';
+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 { fetchWorkday, hasWorkday } from './workday.js';
+
+export {
+  fetchGreenhouse, hasGreenhouse,
+  fetchLever, hasLever,
+  fetchAshby, hasAshby,
+  fetchSmartrecruiters, hasSmartrecruiters,
+  fetchTeamtailor, hasTeamtailor,
+  fetchRecruitee, hasRecruitee,
+  fetchWorkday, hasWorkday,
+};
 
 export const ADAPTERS = {
-  greenhouse: { fetch: (...args) => import('./greenhouse.js').then(m => m.fetchGreenhouse(...args)), has: (...args) => import('./greenhouse.js').then(m => m.hasGreenhouse(...args)) },
-  lever: { fetch: (...args) => import('./lever.js').then(m => m.fetchLever(...args)), has: (...args) => import('./lever.js').then(m => m.hasLever(...args)) },
-  ashby: { fetch: (...args) => import('./ashby.js').then(m => m.fetchAshby(...args)), has: (...args) => import('./ashby.js').then(m => m.hasAshby(...args)) },
-  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)) },
+  greenhouse: { fetch: fetchGreenhouse, has: hasGreenhouse },
+  lever: { fetch: fetchLever, has: hasLever },
+  ashby: { fetch: fetchAshby, has: hasAshby },
+  smartrecruiters: { fetch: fetchSmartrecruiters, has: hasSmartrecruiters },
+  teamtailor: { fetch: fetchTeamtailor, has: hasTeamtailor },
+  recruitee: { fetch: fetchRecruitee, has: hasRecruitee },
+  workday: { fetch: fetchWorkday, has: hasWorkday },
 };
 
 export const ATS_NAMES = Object.keys(ADAPTERS);

package/src/adapters/lever.js

@@ -1,12 +1,10 @@
-import { normalize, extractSalaryFromText } from '../normalizer.js';
+import { normalize, extractSalaryFromText, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
 
 const BASE_URL = 'https://api.lever.co/v0/postings';
 
 const PERIODS = { 'per-year-salary': 'year', 'per-month-salary': 'month', 'per-hour-wage': 'hour' };
-// Lever's workplaceType is one of these or 'unspecified'.
-const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
 
 /**
  * Fetch all jobs from a Lever job board.
@@ -14,11 +12,9 @@ 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, ctx = {}) {
+export async function fetchLever(slug) {
   const url = `${BASE_URL}/${slug}?mode=json`;
   const resp = await atsFetch(url);
 
@@ -31,10 +27,8 @@ export async function fetchLever(slug, ctx = {}) {
   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 });
-  }
+  // anywhere, and every link is on jobs.lever.co. Nothing to report, so
+  // the board's org_name and org_url stay null (issue #58).
 
   return jobs.map(job => normalize({
     companySlug: slug,
@@ -46,10 +40,11 @@ export async function fetchLever(slug, ctx = {}) {
     department: job.categories?.department || job.categories?.team || '',
     location: job.categories?.location || '',
     locations: job.categories?.allLocations || [],
-    workplace: WORKPLACE_TYPES.has(job.workplaceType) ? job.workplaceType : null,
+    // 'remote', 'hybrid', 'onsite' or 'unspecified'; normalize() ignores the last.
+    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/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';
@@ -21,7 +21,7 @@ import { orgHost } from '../boards.js';
  *
  * @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
+ *   { org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
 export async function fetchRecruitee(slug, ctx = {}) {
@@ -41,7 +41,6 @@ export async function fetchRecruitee(slug, ctx = {}) {
   // 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),
     });
@@ -52,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,
@@ -66,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,
@@ -78,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/smartrecruiters.js

@@ -1,7 +1,7 @@
-import { normalize } from '../normalizer.js';
+import { normalize, missingContent } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 import { atsFetch, probeResult } from '../http.js';
-import { makeLocationMatcher } from '../filters.js';
+import { prefilterRows } from '../filters.js';
 
 const BASE_URL = 'https://api.smartrecruiters.com/v1/companies';
 const PAGE_SIZE = 100;
@@ -21,12 +21,12 @@ const MAX_DETAIL_FETCHES = 100;
  * 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
+ * are hydrated (see prefilterRows). 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 }
+ *   with { listed, prefiltered, hydrated, capped, org_name, org_url }
  *   when given
  * @returns {Promise<Array>} Normalized job objects
  */
@@ -54,60 +54,28 @@ export async function fetchSmartrecruiters(slug, ctx = {}) {
     if (content.length === 0 || offset >= (data.totalFound || 0)) break;
   }
 
-  // 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 => {
+  // 2. Filter-aware candidate selection BEFORE the N+1 detail cost, then
+  //    the detail budget (see prefilterRows). The list row carries name,
+  //    location and releasedDate. 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.
+  //    postedAt comes from releasedDate alone, so a missing or unparseable
+  //    date is out, as it is in the library.
+  const { candidates, hydrate } = prefilterRows(postings, fc, {
+    title: p => p.name || '',
+    location: p => listLocation(p).location.toLowerCase(),
+    postedWithin: (p, days) => {
       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);
+      return Number.isFinite(released) && released >= Date.now() - days * 86400000;
+    },
+    max: MAX_DETAIL_FETCHES,
+  });
 
   // 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,
@@ -125,6 +93,7 @@ export async function fetchSmartrecruiters(slug, ctx = {}) {
     let sections = {};
     let postingUrl = '';
     let salary = null;
+    let content; // set only when the detail could not be read (issue #85)
 
     try {
       const detailResp = await atsFetch(`${BASE_URL}/${slug}/postings/${p.id}`);
@@ -133,10 +102,13 @@ export async function fetchSmartrecruiters(slug, ctx = {}) {
         sections = detail.jobAd?.sections || {};
         postingUrl = detail.postingUrl || detail.applyUrl || '';
         salary = parseCompensation(detail.compensation);
+      } else {
+        content = missingContent(detailResp);
       }
-    } catch {
-      // Detail fetch failed, retries included: fall back to list-only
-      // fields (no description). Reporting this is #85.
+    } catch (err) {
+      // Detail fetch failed, retries included: list-only fields (no
+      // description, no url), marked missing.
+      content = missingContent(err);
     }
 
     const description = [
@@ -158,6 +130,7 @@ export async function fetchSmartrecruiters(slug, ctx = {}) {
       url: postingUrl,
       postedAt: p.releasedDate || null,
       salary, // null when the detail has no compensation; normalize() then parses text
+      content,
       metadata: {
         smartRecruitersId: p.id,
         refNumber: p.refNumber || '',

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';
@@ -26,7 +26,7 @@ import { orgHost } from '../boards.js';
  *
  * @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
+ *   { org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
 // Most sites are {slug}.teamtailor.com, but some sit on a regional
@@ -85,7 +85,6 @@ export async function fetchTeamtailor(slug, ctx = {}) {
       || xml.match(/<channel>[\s\S]*?<link>([\s\S]*?)<\/link>/)?.[1]
       || '';
     ctx.report({
-      ats: 'teamtailor',
       org_name: decodeEntities(channelTitle) || null,
       org_url: orgHost(link.trim()),
     });
@@ -117,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,
@@ -133,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/workday.js

@@ -1,6 +1,6 @@
-import { normalize } from '../normalizer.js';
+import { normalize, missingContent, toIso } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
-import { makeLocationMatcher } from '../filters.js';
+import { prefilterRows } from '../filters.js';
 import { atsFetch } from '../http.js';
 import { orgHost } from '../boards.js';
 
@@ -35,7 +35,7 @@ const MULTI_LOCATION = /^\s*\d+\s+locations?\s*$/;
  * @param {string} slug - normalized company slug (registry routing key)
  * @param {object} [ctx] - { config:{tenant,env,site}, companyName, filterContext, report };
  *   report is called once, after hydration, with
- *   { ats, listed, prefiltered, hydrated, capped, org_name, org_url } when given
+ *   { listed, prefiltered, hydrated, capped, org_name, org_url } when given
  * @returns {Promise<Array>} Normalized job objects
  */
 export async function fetchWorkday(slug, ctx = {}) {
@@ -92,55 +92,27 @@ export async function fetchWorkday(slug, ctx = {}) {
     if (firstTotal > 0 && offset >= firstTotal) 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 || ''));
-  }
-  // Location rows go through the applyFilters matcher, so the pre-filter
-  // keeps exactly the rows the pass after hydration would (issue #61).
-  // "2 Locations" says nothing about where: the row stays a candidate
-  // through both filters and that later pass decides on the detail's
-  // location list.
-  if (Array.isArray(fc.locationIncludes) && fc.locationIncludes.length > 0) {
-    const inc = fc.locationIncludes.map(makeLocationMatcher);
-    candidates = candidates.filter(p => {
-      const loc = (p.locationsText || '').toLowerCase();
-      return MULTI_LOCATION.test(loc) || inc.some(m => m(loc));
-    });
-  }
-  if (Array.isArray(fc.locationExcludes) && fc.locationExcludes.length > 0) {
-    const exc = fc.locationExcludes.map(makeLocationMatcher);
-    candidates = candidates.filter(p => {
+  // 2. Filter-aware candidate selection BEFORE the N+1 detail cost, then
+  //    the detail budget (see prefilterRows). The list carries
+  //    title/locationsText/postedOn, enough to apply titleFilter, location
+  //    and recency without descriptions. "2 Locations" says nothing about
+  //    where: the row stays a candidate through both location filters and
+  //    the library's pass after hydration decides on the detail's location
+  //    list (issue #61).
+  //    NOTE: huge-tenant coverage is intentionally capped for v1. Two caps
+  //    apply: the list scan above stops at LIST_PAGE_HARD_CAP pages (2000
+  //    postings, enough for Salesforce's ~1398), and the detail set is cut
+  //    to MAX_DETAIL_FETCHES here. Proper fix (smart pagination, surfaced
+  //    truncation) is tracked in #26.
+  const { candidates, hydrate } = prefilterRows(postings, fc, {
+    title: p => p.title || '',
+    location: p => {
       const loc = (p.locationsText || '').toLowerCase();
-      return MULTI_LOCATION.test(loc) || !exc.some(m => m(loc));
-    });
-  }
-  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. Two
-  //    caps apply: the list scan above stops at LIST_PAGE_HARD_CAP pages
-  //    (2000 postings, enough for Salesforce's ~1398), and the detail set
-  //    is cut to MAX_DETAIL_FETCHES here. 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). The library pages with `offset` after this
-  //    returns, so the budget covers the page plus what precedes it.
-  //    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 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);
+      return MULTI_LOCATION.test(loc) ? null : loc;
+    },
+    postedWithin: (p, days) => withinDays(p.postedOn, days),
+    max: MAX_DETAIL_FETCHES,
+  });
 
   // 4. Hydrate descriptions via the per-posting detail endpoint. The detail
   //    also carries `hiringOrganization: { name, url }` next to
@@ -151,6 +123,7 @@ export async function fetchWorkday(slug, ctx = {}) {
   const jobs = await Promise.all(hydrate.map(async (p, i) => {
     const externalPath = p.externalPath || ''; // already begins with '/job/...'
     let info = {};
+    let content; // set only when the detail could not be read (issue #85)
     try {
       // externalPath already carries the '/job/...' segment, so it is
       // concatenated directly onto the CXS base. Inserting another
@@ -160,9 +133,12 @@ export async function fetchWorkday(slug, ctx = {}) {
         const detail = await dResp.json();
         info = detail.jobPostingInfo || {};
         orgs[i] = detail.hiringOrganization || null;
+      } else {
+        content = missingContent(dResp);
       }
-    } catch {
-      // detail failed, retries included: fall back to list fields, empty description
+    } catch (err) {
+      // detail failed, retries included: list fields only, marked missing
+      content = missingContent(err);
     }
 
     return normalize({
@@ -175,8 +151,10 @@ 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: {
         workdayTenant: tenant,
         workdayEnv: env,
@@ -191,7 +169,6 @@ export async function fetchWorkday(slug, ctx = {}) {
   if (typeof ctx.report === 'function') {
     const org = orgs.find(Boolean) || {};
     ctx.report({
-      ats: 'workday',
       listed: postings.length,
       prefiltered: candidates.length,
       hydrated: hydrate.length,
@@ -220,49 +197,37 @@ function parseWorkdayRemoteType(remoteType) {
 
 /**
  * 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.
+ * "Posted 5 Days Ago", "Posted 30+ Days Ago"). The days it names, or null
+ * when it names none.
  */
-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;
+function daysAgo(postedOn) {
+  const s = String(postedOn || '').toLowerCase();
+  if (/today/.test(s)) return 0;
+  if (/yesterday/.test(s)) return 1;
   const m = s.match(/(\d+)\+?\s*days?\s*ago/);
-  if (m) return parseInt(m[1], 10) <= days;
-  return true;
+  return m ? parseInt(m[1], 10) : null;
 }
 
 /**
- * Coerce a Workday list `postedOn` (relative) into an approx ISO date
- * so the library's postedWithinDays re-filter has a value to compare.
+ * 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 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();
+function withinDays(postedOn, days) {
+  const n = daysAgo(postedOn);
+  return n === null || n <= days;
 }
 
 /**
- * Workday detail `startDate` ("2026-05-01" or "May 1, 2026"). Return
- * ISO, or null if unparseable.
+ * Coerce a Workday list `postedOn` (relative) into an approx ISO date
+ * so the library's postedWithinDays re-filter has a value to compare.
  */
-function parseWorkdayDate(s) {
-  if (!s) return null;
-  const d = new Date(s);
-  return Number.isFinite(d.getTime()) ? d.toISOString() : null;
+function normalizePostedOn(v) {
+  const direct = toIso(v);
+  if (direct) return direct;
+  const n = daysAgo(v);
+  return n === null ? null : new Date(Date.now() - n * 86400000).toISOString();
 }
 
 /**

package/src/cli.js

@@ -11,6 +11,7 @@
 
 import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { parseArgs } from 'node:util';
 import { fetchJobs } from './index.js';
 import { detectAtsDetailed, searchRegistry } from './registry.js';
 
@@ -19,30 +20,35 @@ const [,, command, ...args] = process.argv;
 async function main() {
   switch (command) {
     case 'fetch': {
-      const company = args[0];
+      const string = { type: 'string' };
+      const { values: flags, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+          ats: string, 'title-filter': string, filter: string, 'posted-within-days': string,
+          'location-include': string, 'location-exclude': string, limit: string,
+          'workday-tenant': string, 'workday-env': string, 'workday-site': string,
+          json: { type: 'boolean' },
+        },
+      });
+      const company = positionals[0];
       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;
-      };
-      let ats = getArg('--ats');
-      const titleFilter = getArg('--title-filter');
-      const filter = getArg('--filter');
-      const postedWithinRaw = getArg('--posted-within-days');
-      const postedWithinDays = postedWithinRaw !== undefined ? Number(postedWithinRaw) : undefined;
-      const locIncludeRaw = getArg('--location-include');
-      const locationIncludes = locIncludeRaw ? locIncludeRaw.split(',').map(s => s.trim()).filter(Boolean) : undefined;
-      const locExcludeRaw = getArg('--location-exclude');
-      const locationExcludes = locExcludeRaw ? locExcludeRaw.split(',').map(s => s.trim()).filter(Boolean) : undefined;
-      const limitRaw = getArg('--limit');
-      const limit = limitRaw !== undefined ? Number(limitRaw) : undefined;
+      const number = (v) => (v !== undefined ? Number(v) : undefined);
+      const list = (v) => (v ? v.split(',').map(s => s.trim()).filter(Boolean) : undefined);
+      let ats = flags.ats;
+      const titleFilter = flags['title-filter'];
+      const filter = flags.filter;
+      const postedWithinDays = number(flags['posted-within-days']);
+      const locationIncludes = list(flags['location-include']);
+      const locationExcludes = list(flags['location-exclude']);
+      const limit = number(flags.limit);
 
       // 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');
+      const wdTenant = flags['workday-tenant'];
+      const wdEnv = flags['workday-env'];
+      const wdSite = flags['workday-site'];
       let config;
       if (wdTenant || wdEnv || wdSite) {
         if (!wdTenant || !wdEnv || !wdSite) {
@@ -91,8 +97,10 @@ async function main() {
         const loc = job.location ? ` | ${job.location}` : '';
         const dept = job.department ? ` [${job.department}]` : '';
         console.log(`  ${job.title}${dept}${loc}${salary}`);
-        console.log(`  ${job.url}`);
-        if (job.description) {
+        console.log(`  ${job.url || '(no URL: posting not read)'}`);
+        if (job.content?.status === 'missing') {
+          console.log(`  posting not read: ${job.content.reason}`);
+        } else if (job.description) {
           const preview = job.description.substring(0, 120).replace(/\n/g, ' ');
           console.log(`  ${preview}...`);
         }
@@ -103,7 +111,7 @@ async function main() {
         console.log(`  ... and ${jobs.length - 20} more. Use --json for full output.`);
       }
 
-      if (args.includes('--json')) {
+      if (flags.json) {
         console.log(JSON.stringify(jobs, null, 2));
       }
       break;

package/src/filters.js

@@ -88,11 +88,7 @@ export function pageJobs(jobs, { order = 'newest', offset = 0, limit = 100 } = {
 
   const start = typeof offset === 'number' && offset > 0 ? offset : 0;
   const end = typeof limit === 'number' ? start + limit : undefined;
-  if (start > 0 || (end !== undefined && result.length > end)) {
-    result = result.slice(start, end);
-  }
-
-  return result;
+  return result.slice(start, end);
 }
 
 /**
@@ -174,3 +170,51 @@ export function makeLocationMatcher(needle) {
   }
   return (loc) => loc.includes(lower);
 }
+
+/**
+ * The list pre-filter and detail budget the two-step adapters (Workday,
+ * SmartRecruiters) share: narrow the cheap list rows with the filters a row
+ * can answer, then bound how many get a detail request.
+ *
+ * The library re-applies every filter after hydration, so a keep here is
+ * never final. `location(row)` returns the lowercased location, or null
+ * when the row cannot say where it is (it then stays a candidate through
+ * both location filters). `postedWithin(row, days)` decides recency.
+ *
+ * A description `filter` runs only after hydration, so that case keeps the
+ * full `max` budget instead of truncating to the page (which could hydrate
+ * rows that all fail the regex while better matches go unscanned). Without
+ * one, the budget is the page plus the offset before it. List order is kept.
+ *
+ * @returns {{ candidates: Array, hydrate: Array }}
+ */
+export function prefilterRows(rows, fc, { title, location, postedWithin, max }) {
+  let candidates = rows;
+
+  if (fc.titleFilter) {
+    const re = new RegExp(fc.titleFilter, 'i');
+    candidates = candidates.filter(p => re.test(title(p)));
+  }
+  if (Array.isArray(fc.locationIncludes) && fc.locationIncludes.length > 0) {
+    const inc = fc.locationIncludes.map(makeLocationMatcher);
+    candidates = candidates.filter(p => {
+      const loc = location(p);
+      return loc === null || inc.some(m => m(loc));
+    });
+  }
+  if (Array.isArray(fc.locationExcludes) && fc.locationExcludes.length > 0) {
+    const exc = fc.locationExcludes.map(makeLocationMatcher);
+    candidates = candidates.filter(p => {
+      const loc = location(p);
+      return loc === null || !exc.some(m => m(loc));
+    });
+  }
+  if (typeof fc.postedWithinDays === 'number') {
+    candidates = candidates.filter(p => postedWithin(p, fc.postedWithinDays));
+  }
+
+  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 : Math.min(skip + limit, max);
+  return { candidates, hydrate: candidates.slice(0, cap) };
+}

package/src/index.js

@@ -57,6 +57,7 @@ export async function fetchJobs(options = {}) {
  *   jobs: Array,
  *   total_matched: number,
  *   total_before_filters: number,
+ *   content_missing: number,
  *   match: 'registry'|'probe'|'workday_override',
  *   company: { key: string, name: string }|null,
  *   boards: Array<object>,
@@ -65,6 +66,9 @@ export async function fetchJobs(options = {}) {
  *   jobs: the page. total_matched: matches before offset and limit.
  *   total_before_filters: rows every board listed before any filter (on
  *   Workday and SmartRecruiters the list count, not the rows they hydrated).
+ *   content_missing: jobs whose posting was not read because the detail
+ *   request failed (Workday, SmartRecruiters), counted before the filters:
+ *   a description filter cannot match text that never arrived.
  *   match: how the company was resolved. company: the registry row's name
  *   and its key (normalized name); null unless match is 'registry'.
  *   boards: one entry per board that answered (see src/boards.js), with
@@ -194,6 +198,7 @@ export async function fetchJobsDetailed({
     jobs: pageJobs(matched, { order, offset, limit }),
     total_matched: matched.length,
     total_before_filters: boards.reduce((n, b) => n + b.jobs_found, 0),
+    content_missing: rows.filter(j => j.content?.status === 'missing').length,
     match,
     company: match === 'registry' ? { key: normSlug(targets[0].name), name: targets[0].name } : null,
     boards,
@@ -205,7 +210,13 @@ function registryTarget(hit, config) {
   return { ats: hit.ats, slug: hit.entry.slug, name: hit.entry.name, config: config || hit.entry.config };
 }
 
-function discoveryFailure(company, failed) {
+/**
+ * The AtsError for a lookup where no board answered and at least one check
+ * failed: rate_limited when any failure was a 429, else ats_unreachable,
+ * with a message naming each failed check. `failed` is the list
+ * fetchJobsDetailed and detectAtsDetailed return.
+ */
+export function discoveryFailure(company, failed) {
   const limited = failed.some(f => f.code === ERROR_CODES.RATE_LIMITED);
   const checks = failed.map(f => `${f.ats} (${f.message})`).join('; ');
   return new AtsError(

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.
  */
@@ -23,6 +33,9 @@ export function jobId(company, title, ats, location = '') {
  * adapter to 'remote' | 'hybrid' | 'onsite', or null when the platform
  * gives no signal. `raw.locations` lists every place the posting is open
  * in; `location` stays the primary because it feeds the id (issue #68).
+ *
+ * `raw.content` is set only by a two-step adapter whose detail request
+ * failed (see missingContent). Every other job was read in full.
  */
 export function normalize(raw, ats) {
   const now = new Date().toISOString();
@@ -47,10 +60,21 @@ export function normalize(raw, ats) {
     firstSeen: now,
     lastSeen: now,
     status: 'open',
+    content: raw.content || { status: 'complete', reason: null },
     metadata: raw.metadata || {},
   };
 }
 
+/**
+ * The `content` of a job whose detail request failed, so its description
+ * and pay were never read (issue #85). `failure` is the non-OK Response or
+ * the error atsFetch threw: an HTTP status gives "http_503", anything else
+ * "network_error".
+ */
+export function missingContent(failure) {
+  return { status: 'missing', reason: failure?.status ? `http_${failure.status}` : 'network_error' };
+}
+
 const CURRENCY_CODES = 'USD|EUR|GBP|CAD|AUD|NZD|CHF|SEK|NOK|DKK|PLN|CZK|HUF|INR|SGD|HKD|JPY|CNY|BRL|MXN|ZAR|AED|ILS';
 const SYMBOL_CURRENCY = { $: 'USD', '€': 'EUR', '£': 'GBP' };
 
@@ -140,14 +164,14 @@ function detectPeriod(before, after, min) {
   return min >= 10000 ? 'year' : null;
 }
 
-function periodWord(text) {
+export function periodWord(text) {
   if (HOUR_RE.test(text)) return 'hour';
   if (MONTH_RE.test(text)) return 'month';
   if (YEAR_RE.test(text)) return 'year';
   return null;
 }
 
-const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
+export const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
 
 /**
  * The platform's own value wins. Without one, a keyword in the location

package/src/registry.js

@@ -2,15 +2,11 @@ import { readFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AtsError } from './errors.js';
+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 = ['greenhouse', 'lever', 'ashby', 'smartrecruiters', 'teamtailor', 'recruitee', 'workday'];
-
 // 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
@@ -72,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]]));
 }
 
 /**
@@ -94,7 +93,10 @@ export function getRegistrySource() {
 }
 
 /**
- * Search registry for companies matching a query.
+ * Search registry for companies matching a query, best match first: an
+ * exact name or slug, then a name that starts with the query, then a name
+ * that contains it, then a sector-only match. Ties keep platform order, so
+ * a caller that cuts the list drops the weakest matches (issue #62).
  */
 export async function searchRegistry(query) {
   const all = await loadRegistry();
@@ -105,13 +107,16 @@ export async function searchRegistry(query) {
     for (const company of companies) {
       const name = (company.name || company.slug || '').toLowerCase();
       const sector = (company.sector || '').toLowerCase();
-      if (name.includes(lower) || sector.includes(lower)) {
-        results.push({ ...company, ats });
-      }
+      const rank = name === lower || String(company.slug).toLowerCase() === lower ? 0
+        : name.startsWith(lower) ? 1
+        : name.includes(lower) ? 2
+        : sector.includes(lower) ? 3
+        : -1;
+      if (rank >= 0) results.push({ rank, row: { ...company, ats } });
     }
   }
 
-  return results;
+  return results.sort((a, b) => a.rank - b.rank).map(r => r.row);
 }
 
 // Slug match is case/punctuation-insensitive: registry slugs are stored
@@ -120,18 +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, '');
 
-// The loaded registry as [ats, companies] pairs in PLATFORMS order, whatever
-// order the object's keys are in.
-function platformEntries(all) {
-  return PLATFORMS.map(ats => [ats, all[ats] || []]);
-}
-
-function platformIndex(ats) {
-  const i = PLATFORMS.indexOf(ats);
-  return i === -1 ? PLATFORMS.length : i;
-}
-
-const byPlatform = (a, b) => platformIndex(a.ats) - platformIndex(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.
@@ -147,14 +141,14 @@ 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>}
  */
 export async function findEntryBySlug(slug) {
   const all = await loadRegistry();
   const key = normSlug(slug);
-  for (const [ats, companies] of platformEntries(all)) {
+  for (const [ats, companies] of Object.entries(all)) {
     const entry = companies.find(c => normSlug(c.slug) === key);
     if (entry) return { ats, entry };
   }
@@ -171,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' }>,
@@ -179,14 +173,13 @@ export async function findEntryBySlug(slug) {
  * }>}
  */
 export async function detectAtsDetailed(companyName) {
-  const { ADAPTERS } = await import('./adapters/index.js');
   const slug = normSlug(companyName);
   const all = await loadRegistry();
 
   const boards = [];
   const failed = [];
   const known = new Set();
-  for (const [ats, companies] of platformEntries(all)) {
+  for (const [ats, companies] of Object.entries(all)) {
     const entry = companies.find(c => normSlug(c.slug) === slug);
     if (entry) {
       boards.push({ ats, slug: entry.slug, source: 'registry' });