openings 0.1.36 → 0.1.38

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Find evidence-grounded jobs, including relevant roles you may not have searched for, without accounts or API keys.",
   "author": { "name": "Openings contributors" },
   "license": "MIT",

package/data/companies.json

@@ -108370,5 +108370,93 @@
       "payloadVersion": "amazon-jobs-search:v1",
       "jobCount": 2368
     }
+  },
+  "jpmorganchase": {
+    "name": "JPMorganChase",
+    "ats": "oraclecloud",
+    "token": "jpmc.fa.oraclecloud.com/CX_1",
+    "cohorts": [
+      "IN"
+    ],
+    "sourceUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1/requisitions",
+    "discoveredFrom": {
+      "channel": "company_site",
+      "reference": "https://careers.jpmorgan.com/"
+    },
+    "verification": {
+      "observedCompanyName": "JPMorganChase",
+      "identityEvidence": "company_page_link",
+      "contentType": "application/json",
+      "payloadVersion": "oracle-recruiting-ce:v1",
+      "jobCount": 7447,
+      "checkedAt": "2026-09-17T10:47:14.367307Z",
+      "canonicalSourceUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1/requisitions"
+    }
+  },
+  "exl": {
+    "name": "EXL",
+    "ats": "oraclecloud",
+    "token": "fa-ewjt-saasfaprod1.fa.ocs.oraclecloud.com/CX_2",
+    "cohorts": [
+      "IN"
+    ],
+    "sourceUrl": "https://fa-ewjt-saasfaprod1.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_2/requisitions",
+    "discoveredFrom": {
+      "channel": "company_site",
+      "reference": "https://www.exlservice.com/careers"
+    },
+    "verification": {
+      "observedCompanyName": "EXL",
+      "identityEvidence": "company_page_link",
+      "contentType": "application/json",
+      "payloadVersion": "oracle-recruiting-ce:v1",
+      "jobCount": 3301,
+      "checkedAt": "2026-09-17T10:47:14.367307Z",
+      "canonicalSourceUrl": "https://fa-ewjt-saasfaprod1.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_2/requisitions"
+    }
+  },
+  "tatacapital": {
+    "name": "Tata Capital",
+    "ats": "oraclecloud",
+    "token": "eofh.fa.em2.oraclecloud.com/CX",
+    "cohorts": [
+      "IN"
+    ],
+    "sourceUrl": "https://eofh.fa.em2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX/requisitions",
+    "discoveredFrom": {
+      "channel": "company_site",
+      "reference": "https://www.tatacapital.com/careers.html"
+    },
+    "verification": {
+      "observedCompanyName": "Tata Capital",
+      "identityEvidence": "company_page_link",
+      "contentType": "application/json",
+      "payloadVersion": "oracle-recruiting-ce:v1",
+      "jobCount": 5278,
+      "checkedAt": "2026-09-17T10:47:14.367307Z",
+      "canonicalSourceUrl": "https://eofh.fa.em2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX/requisitions"
+    }
+  },
+  "marriott": {
+    "name": "Marriott International",
+    "ats": "oraclecloud",
+    "token": "ejwl.fa.us2.oraclecloud.com/CX",
+    "cohorts": [
+      "IN"
+    ],
+    "sourceUrl": "https://ejwl.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX/requisitions",
+    "discoveredFrom": {
+      "channel": "company_site",
+      "reference": "https://careers.marriott.com/"
+    },
+    "verification": {
+      "observedCompanyName": "Marriott International",
+      "identityEvidence": "company_page_link",
+      "contentType": "application/json",
+      "payloadVersion": "oracle-recruiting-ce:v1",
+      "jobCount": 13693,
+      "checkedAt": "2026-09-17T10:47:14.367307Z",
+      "canonicalSourceUrl": "https://ejwl.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX/requisitions"
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "A free, candidate-safe job-search substrate for AI agents",
   "license": "MIT",
   "repository": { "type": "git", "url": "git+https://github.com/abhay-avagama/hiring-agent.git" },

package/src/board-verification.ts

@@ -55,7 +55,9 @@ export async function verifyBoards(registryPath: string, catalogPath: string, op
     for (const lead of registry.leads) {
       if (!BOARD_TIER_PROVIDERS.has(lead.ats) || !resolveSource(lead.sourceUrl)) { skipped.unsupported += 1; continue; }
       if (knownSources.has(`${lead.ats}:${lead.token.toLowerCase()}`)) { skipped.inCatalog += 1; continue; }
-      if (looksLikeTestBoard(lead.token)) { skipped.unsupported += 1; continue; }
+      // Keka tokens contain tenant/UUID; the provider-issued routing UUID is not a company name.
+      const boardName = lead.ats === "keka" ? lead.token.split("/")[0]! : lead.token;
+      if (looksLikeTestBoard(boardName)) { skipped.unsupported += 1; continue; }
       if (coolingDown(lead, now(), cooldownMs)) { skipped.coolingDown += 1; continue; }
       eligible.push(lead);
     }

package/src/catalog-discovery.ts

@@ -0,0 +1,228 @@
+import { Database } from "bun:sqlite";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { assertArtifactFile } from "./artifact-path.ts";
+import { atomicJson } from "./atomic-file.ts";
+import { commonCrawlPatterns } from "./common-crawl-discovery.ts";
+import { withFileLock } from "./file-lock.ts";
+import { resolveSource } from "./source-verification.ts";
+import { ALL_PROVIDERS, type Ats } from "./types.ts";
+
+interface Options {
+  state: string; indexes: string[]; providers: Ats[]; execute?: boolean;
+  requestBudget?: number; pageBudget?: number; targetBoards?: number; delayMs?: number;
+  catalogPath?: string; exportPath?: string;
+}
+interface Dependencies {
+  fetch?: (input: string | URL, init?: RequestInit) => Promise<Response>;
+  sleep?: (ms: number) => Promise<void>; now?: () => number;
+}
+interface Query { id: number; index_id: string; provider: Ats; pattern: string; pages: number | null; next_page: number }
+interface Board { key: string; ats: Ats; token: string; url: string }
+interface GatewayRetry { url: string; failures: number; nextAt: number }
+interface FailureDetail { at: string; url: string; status: number; headers: Record<string, string>; bodyPreview: string }
+const MAX_BODY_BYTES = 8 * 1024 * 1024;
+const SCHEMA = 1;
+
+/** Discovery only: fixed-host index requests, durable page checkpoints, no ATS probes or catalog writes. */
+export async function discoverCatalog(options: Options, deps: Dependencies = {}) {
+  // Distinct suffixes prevent SQLite files from aliasing the export's .lock or .PID.tmp sidecars.
+  if (!options.state.endsWith(".sqlite")) throw Error("Discovery state must use a .sqlite filename");
+  if (options.exportPath && !options.exportPath.endsWith(".json")) throw Error("Discovery export must use a .json filename");
+  const indexes = [...new Set(options.indexes)].sort();
+  const providers = [...new Set(options.providers)].sort();
+  if (!indexes.length || indexes.length > 24 || indexes.some(id => !/^CC-MAIN-20\d{2}-\d{2}$/.test(id))) throw Error("Supply 1–24 pinned CC-MAIN-YYYY-NN index IDs");
+  if (!providers.length || providers.some(p => !ALL_PROVIDERS.includes(p) || !commonCrawlPatterns(p)?.length)) throw Error("Supply supported providers with discovery patterns");
+  const requests = integer(options.requestBudget ?? 100, 1, 1000, "requestBudget");
+  const pages = integer(options.pageBudget ?? 80, 1, 1000, "pageBudget");
+  const target = integer(options.targetBoards ?? 50000, 1, 1000000, "targetBoards");
+  const delay = integer(options.delayMs ?? 1500, 1000, 60000, "delayMs");
+  await assertArtifactFile(options.state);
+  if (options.exportPath) {
+    await assertArtifactFile(options.exportPath);
+    if ([options.state, `${options.state}.lock`, `${options.state}-wal`, `${options.state}-shm`, `${options.state}-journal`, options.catalogPath].some(p => p && resolve(p) === resolve(options.exportPath!))) throw Error("Export must not overwrite state, lock, or catalog");
+    if (await Bun.file(options.exportPath).exists()) throw Error("Export already exists; choose a new artifact path to preserve verification outcomes");
+  }
+  const known = new Set<string>();
+  if (options.catalogPath) {
+    const catalog = JSON.parse(await readFile(options.catalogPath, "utf8"));
+    if (!catalog || typeof catalog !== "object" || Array.isArray(catalog)) throw Error("Invalid catalog");
+    for (const entry of Object.values(catalog) as Array<{ ats: string; token: string }>) {
+      if (typeof entry.ats !== "string" || typeof entry.token !== "string") throw Error("Invalid catalog entry");
+      known.add(`${entry.ats}:${entry.token.toLowerCase()}`);
+    }
+  }
+  const config = JSON.stringify({ schema: SCHEMA, indexes, providers, pageSize: 1, patterns: providers.map(p => [p, commonCrawlPatterns(p)]) });
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms: number) => new Promise<void>(done => setTimeout(done, ms)));
+  const fetcher = deps.fetch ?? globalThis.fetch;
+  return withFileLock(options.state, async () => {
+    const db = new Database(options.state);
+    try {
+      db.exec(`PRAGMA foreign_keys=ON; PRAGMA busy_timeout=10000;
+        CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+        CREATE TABLE IF NOT EXISTS queries (id INTEGER PRIMARY KEY, index_id TEXT NOT NULL, provider TEXT NOT NULL, pattern TEXT NOT NULL, pages INTEGER, next_page INTEGER NOT NULL DEFAULT 0, UNIQUE(index_id,pattern));
+        CREATE TABLE IF NOT EXISTS boards (key TEXT PRIMARY KEY, ats TEXT NOT NULL, token TEXT NOT NULL, url TEXT NOT NULL);
+        CREATE TABLE IF NOT EXISTS origins (board_key TEXT REFERENCES boards(key), query_id INTEGER REFERENCES queries(id), PRIMARY KEY(board_key,query_id));`);
+      const get = (key: string) => db.query<{ value: string }, [string]>("SELECT value FROM meta WHERE key=?").get(key)?.value;
+      const put = (key: string, value: string | number) => db.prepare("INSERT INTO meta VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(key, String(value));
+      if (get("config") && get("config") !== config) throw Error("Checkpoint configuration differs; use a new state file for different indexes/providers");
+      if (!get("config")) db.transaction(() => {
+        put("config", config);
+        for (const index of indexes) for (const provider of providers) for (const pattern of commonCrawlPatterns(provider)) db.prepare("INSERT INTO queries(index_id,provider,pattern) VALUES (?,?,?)").run(index, provider, pattern);
+      })();
+      const boardCount = () => db.query<{ n: number }, []>("SELECT count(*) AS n FROM boards").get()!.n;
+      let requestsThisRun = 0, pagesThisRun = 0;
+      let status = options.execute ? "complete" : "plan";
+      let error: string | undefined;
+      if (options.execute) while (true) {
+        const query = db.query<Query, []>("SELECT * FROM queries WHERE pages IS NULL OR next_page < pages ORDER BY next_page,id LIMIT 1").get();
+        if (!query) break;
+        if (Number(get("retryAt") ?? 0) > now()) { status = "cooling_down"; break; }
+        if (boardCount() >= target) { status = "target_reached"; break; }
+        if (requestsThisRun >= requests) { status = "request_budget"; break; }
+        if (pagesThisRun >= pages) { status = "page_budget"; break; }
+        const url = new URL(`https://index.commoncrawl.org/${query.index_id}-index`);
+        url.search = new URLSearchParams({ url: query.pattern, output: "json", filter: "=status:200", fl: "url", pageSize: "1", ...(query.pages === null ? { showNumPages: "true" } : { page: String(query.next_page) }) }).toString();
+        const gatewayRetry: GatewayRetry | null = JSON.parse(get("gatewayRetry") ?? "null");
+        // Persist request accounting before dispatch: a process crash cannot erase a consumed attempt.
+        const waitMs = Math.max(delay, Number(get("lastRequestAt") ?? 0) + delay - now(), gatewayRetry?.url === String(url) ? gatewayRetry.nextAt - now() : 0);
+        // Long Retry-After values yield control to the operator rather than holding a CLI open indefinitely.
+        if (waitMs > 60000) { status = "cooling_down"; break; }
+        await sleep(waitMs);
+        put("lastRequestAt", now()); put("requests", Number(get("requests") ?? 0) + 1); requestsThisRun++;
+        try {
+          const response = await fetcher(url, { redirect: "error", signal: AbortSignal.timeout(30000), headers: { "user-agent": "OpeningsCatalogDiscovery/1.0" } });
+          if (response.status === 502 || response.status === 504) {
+            const failures = (gatewayRetry?.url === String(url) ? gatewayRetry.failures : 0) + 1;
+            const nextAt = Math.max(now() + 10000 * 2 ** (failures - 1), retryAfter(response, now()));
+            put("lastFailure", JSON.stringify(await failureDetail(response, url, now())));
+            if (failures >= 3) {
+              put("retryAt", Math.max(now() + 15 * 60000, nextAt)); put("gatewayRetry", "null");
+              error = `Common Crawl HTTP ${response.status}; gateway retry allowance exhausted`; status = "error"; break;
+            }
+            put("gatewayRetry", JSON.stringify({ url: String(url), failures, nextAt } satisfies GatewayRetry));
+            continue;
+          }
+          if (response.status === 429 || response.status === 503) {
+            put("retryAt", Math.max(now() + 15 * 60000, retryAfter(response, now())));
+            put("lastFailure", JSON.stringify(await failureDetail(response, url, now())));
+            status = "throttled"; break;
+          }
+          if (response.status === 404) {
+            const text = await boundedText(response);
+            let message: unknown;
+            try { const value = JSON.parse(text); message = value?.message ?? value?.error; } catch { /* Unknown 404s must not advance. */ }
+            // CDX prefix queries may echo the prefix without its trailing wildcard.
+            const emptyMessages = [query.pattern, query.pattern.replace(/\*$/, "")].map(pattern => `No Captures found for: ${pattern}`.toLowerCase());
+            if (typeof message === "string" && emptyMessages.includes(message.toLowerCase())) {
+              if (query.pages === null) db.prepare("UPDATE queries SET pages=0 WHERE id=?").run(query.id);
+              else { db.prepare("UPDATE queries SET next_page=next_page+1 WHERE id=?").run(query.id); pagesThisRun++; }
+              put("gatewayRetry", "null");
+              continue;
+            }
+            put("lastFailure", JSON.stringify({ at: new Date(now()).toISOString(), url: String(url), status: 404, headers: diagnosticHeaders(response), bodyPreview: text.slice(0,2048) } satisfies FailureDetail));
+            throw Error("Common Crawl HTTP 404");
+          }
+          if (!response.ok) { put("lastFailure", JSON.stringify(await failureDetail(response, url, now()))); throw Error(`Common Crawl HTTP ${response.status}`); }
+          const body = await boundedText(response);
+          if (query.pages === null) {
+            const info = JSON.parse(body);
+            if (!Number.isSafeInteger(info.pages) || info.pages < 0 || info.pages > 1000000 || info.pageSize !== 1) throw Error("Invalid CDX page count or pageSize");
+            db.prepare("UPDATE queries SET pages=? WHERE id=?").run(info.pages, query.id);
+          } else {
+            const records = body.split(/\r?\n/).filter(line => line.trim());
+            const additions: Board[] = []; let rejected = 0;
+            for (const line of records) {
+              const record: unknown = JSON.parse(line);
+              if (!record || typeof record !== "object" || !("url" in record) || typeof record.url !== "string") throw Error("Malformed CDX URL record; page was not checkpointed");
+              const source = resolveSource(record.url);
+              if (!source || source.ats !== query.provider) { rejected++; continue; }
+              additions.push({ key: `${source.ats}:${source.token.toLowerCase()}`, ats: source.ats, token: source.token, url: source.canonicalSourceUrl });
+            }
+            db.transaction(() => {
+              for (const board of additions) {
+                db.prepare("INSERT OR IGNORE INTO boards VALUES (?,?,?,?)").run(board.key, board.ats, board.token, board.url);
+                db.prepare("INSERT OR IGNORE INTO origins VALUES (?,?)").run(board.key, query.id);
+              }
+              put("records", Number(get("records") ?? 0) + records.length);
+              put("rejected", Number(get("rejected") ?? 0) + rejected);
+              db.prepare("UPDATE queries SET next_page=next_page+1 WHERE id=?").run(query.id);
+            })();
+            pagesThisRun++;
+          }
+          put("gatewayRetry", "null");
+        } catch (cause) { error = cause instanceof Error ? cause.message : String(cause); status = "error"; break; }
+      }
+      const boards = db.query<Board, []>("SELECT * FROM boards ORDER BY key").all();
+      let exported: number | undefined;
+      if (options.exportPath) {
+        const origins = db.query<{ board_key: string; index_id: string }, []>("SELECT DISTINCT board_key,index_id FROM origins JOIN queries ON queries.id=origins.query_id ORDER BY board_key,index_id").all();
+        const byKey = new Map<string, string[]>();
+        for (const origin of origins) { const refs = byKey.get(origin.board_key) ?? []; refs.push(origin.index_id); byKey.set(origin.board_key, refs); }
+        const leads = boards.filter(b => !known.has(b.key)).map(b => ({ sourceKey: b.key, ats: b.ats, token: b.token, sourceUrl: b.url, discoveredFrom: (byKey.get(b.key) ?? []).map(id => ({ channel: "dataset", reference: `https://index.commoncrawl.org/${id}-index` })), companyMatches: [], identityEvidence: [], attempts: [] }));
+        await withFileLock(options.exportPath, async () => {
+          if (await Bun.file(options.exportPath!).exists()) throw Error("Export already exists; choose a new artifact path");
+          await atomicJson(options.exportPath!, { version: 1, updatedAt: new Date(now()).toISOString(), leads });
+        }, { operation: "export discovery leads" }); exported = leads.length;
+      }
+      return { status, error, state: options.state, indexes, providers, boards: boards.length, knownBoards: boards.filter(b => known.has(b.key)).length, newBoardLeads: boards.filter(b => !known.has(b.key)).length,
+        records: Number(get("records") ?? 0), rejectedRecords: Number(get("rejected") ?? 0), requestsTotal: Number(get("requests") ?? 0), requestsThisRun, pagesThisRun,
+        retryAt: nextRetryAt(get("retryAt"), get("gatewayRetry"), now()),
+        lastFailure: JSON.parse(get("lastFailure") ?? "null") as FailureDetail | null,
+        limits: { requestBudget: requests, pageBudget: pages, targetBoards: target, delayMs: delay, maxResponseBytes: MAX_BODY_BYTES },
+        queries: db.query<Query, []>("SELECT * FROM queries ORDER BY id").all(), exported,
+        note: "Unverified discovery leads, not active boards or eligible employers. No catalog or shared registry was changed." };
+    } finally { db.close(); }
+  }, { operation: "catalog discovery" });
+}
+
+function retryAfter(response: Response, now: number): number {
+  const header = response.headers.get("retry-after");
+  const value = header && /^\d+$/.test(header) ? now + Number(header) * 1000 : Date.parse(header ?? "");
+  return Number.isFinite(value) && value <= 8640000000000000 ? value : 0;
+}
+function nextRetryAt(cooldown: string | undefined, gateway: string | undefined, now: number) {
+  const retry: GatewayRetry | null = JSON.parse(gateway ?? "null");
+  const value = Math.max(Number(cooldown ?? 0), retry?.nextAt ?? 0);
+  return value > now ? new Date(value).toISOString() : undefined;
+}
+function diagnosticHeaders(response: Response) {
+  return Object.fromEntries(["server", "via", "cf-ray", "x-request-id", "x-cache", "retry-after", "content-type"].flatMap(name => {
+    const value = response.headers.get(name); return value === null ? [] : [[name, value.slice(0,512)]];
+  }));
+}
+async function failureDetail(response: Response, url: URL, now: number): Promise<FailureDetail> {
+  const detail: FailureDetail = { at: new Date(now).toISOString(), url: String(url), status: response.status, headers: diagnosticHeaders(response), bodyPreview: "" };
+  const reader = response.body?.getReader(); if (!reader) return detail;
+  const chunks: Uint8Array[] = []; let bytes = 0;
+  try {
+    while (bytes < 2048) {
+      const chunk = await reader.read(); if (chunk.done) break;
+      const part = chunk.value.subarray(0, 2048-bytes); chunks.push(part); bytes += part.length;
+    }
+    const buffer = new Uint8Array(bytes); let offset = 0;
+    for (const chunk of chunks) { buffer.set(chunk, offset); offset += chunk.length; }
+    detail.bodyPreview = new TextDecoder().decode(buffer);
+  } catch { detail.bodyPreview = "[response body unavailable]"; }
+  finally { await reader.cancel().catch(() => {}); reader.releaseLock(); }
+  return detail;
+}
+
+function integer(value: number, min: number, max: number, name: string) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw Error(`${name} must be an integer from ${min} to ${max}`);
+  return value;
+}
+async function boundedText(response: Response): Promise<string> {
+  const reader = response.body?.getReader(); if (!reader) return "";
+  const decoder = new TextDecoder(); let bytes = 0, text = "";
+  try {
+    while (true) {
+      const chunk = await reader.read(); if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > MAX_BODY_BYTES) throw Error("CDX response exceeded byte limit; page was not checkpointed");
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    return text + decoder.decode();
+  } finally { await reader.cancel().catch(() => {}); reader.releaseLock(); }
+}

package/src/catalog.ts

@@ -2,7 +2,7 @@ import { CASCADE_MINIMUM, CASCADE_WINDOWS, type Company, type Job, type JobAge,
 import { decodeEntities, providerSpec, type JsonGet } from "./providers.ts";
 import { crawlSite, sitePostingsToJobs } from "./jobposting-site.ts";
 import { classifyJob, isEligibleForCountry, normalizeLocation } from "./locations.ts";
-import { statedExperience } from "./experience.ts";
+import { experienceMatches, normalizeJobExperience } from "./experience.ts";
 
 type Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
 
@@ -102,7 +102,7 @@ export function createCatalog(options: CatalogOptions): Catalog {
       let job = (await fetchJobs(company)).find((candidate) => candidate.id === id) ?? null;
       if (job && !job.description.trim()) job = { ...job, description: await fetchJobDescription(company, job, fetcher) };
       if (job && !job.description.trim()) throw new Error(`Full description unavailable for job: ${id}`);
-      return job;
+      return job ? normalizeJobExperience(job) : null;
     },
   };
 }
@@ -119,10 +119,10 @@ export function withinWindow(job: Pick<Job, "updatedAt">, days: number, now: num
 
 /** Keyword search newest first. Without maxAgeDays it walks 7, 14, 30, then everything until CASCADE_MINIMUM results appear; the window used rides on the result. */
 export function searchJobs(jobs: Job[], query: SearchQuery, now: number = Date.now()): SearchResult {
-  const matched = jobs.filter((job) => matches(job, query)).filter((job) => {
+  const matched = jobs.filter((job) => matches(job, query)).map(normalizeJobExperience).filter((job) => {
     if (query.experienceYears === undefined) return true;
-    const experience = job.experience === undefined ? statedExperience(job.description) : job.experience;
-    return experience ? query.experienceYears >= experience.min && (experience.max === undefined || query.experienceYears <= experience.max) : query.includeUnknownExperience === true;
+    const experience = job.experience;
+    return experience ? experienceMatches(experience, query.experienceYears) : query.includeUnknownExperience === true;
   });
   const run = (days: number) => matched.filter((job) => withinWindow(job, days, now)).sort((left, right) => postedTime(right) - postedTime(left) || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0));
   const steps: SearchWindow["steps"] = [];
@@ -133,7 +133,7 @@ export function searchJobs(jobs: Job[], query: SearchQuery, now: number = Date.n
     if (found.length >= CASCADE_MINIMUM) break;
   }
   const offset = query.offset ?? 0, limit = query.limit ?? 50;
-  const result = found.slice(offset, offset + limit).map((job) => toSummary(query.experienceYears !== undefined && job.experience === undefined ? { ...job, experience: statedExperience(job.description) } : job, now)) as SearchResult;
+  const result = found.slice(offset, offset + limit).map((job) => toSummary(job, now)) as SearchResult;
   Object.defineProperty(result, "pagination", { value: { offset, limit, total: found.length, nextOffset: offset + limit < found.length ? offset + limit : null }, enumerable: false });
   Object.defineProperty(result, "window", { value: { daysUsed: steps[steps.length - 1]!.days, widened: steps.length > 1, steps } satisfies SearchWindow, enumerable: false });
   return result;
@@ -199,7 +199,15 @@ const WORKDAY_LISTING_CAP = 2000;
 const WORKDAY_COUNTRY_NAMES: Record<string, string[]> = { IN: ["india"], US: ["united states of america", "united states", "usa"] };
 /** Countries whose multi-location postings ("2 Locations") are labelled from the tenant's own country filter, not only on capped tenants. */
 const WORKDAY_LABEL_COUNTRIES = new Set(["IN"]);
-function workdayJobKey(job: WorkdayJob): string { return job.bulletFields?.[0] ?? job.externalPath; }
+function workdayJobKey(job: WorkdayJob): string {
+  // Bullets are tenant-defined display fields (e.g. "Regular"), not a requisition contract.
+  // Preserve existing requisition IDs only when the posting URL corroborates them.
+  const tail = job.externalPath.split("/").at(-1) ?? "";
+  const suffix = tail.includes("_") ? tail.slice(tail.lastIndexOf("_") + 1) : "";
+  const bullet = job.bulletFields?.[0]?.trim();
+  if (bullet && /\d/.test(bullet) && (suffix === bullet || (suffix.startsWith(`${bullet}-`) && /^\d+$/.test(suffix.slice(bullet.length + 1))))) return bullet;
+  return suffix && /^[a-z0-9.-]+$/i.test(suffix) && /\d/.test(suffix) ? suffix : job.externalPath;
+}
 
 export interface WorkdayCountryFacet { parameter: string; id: string; count: number }
 /**
@@ -378,7 +386,7 @@ export function abortableDelay(ms: number, signal?: AbortSignal): Promise<void>
 
 function normalizeWorkday(company: Company, source: ReturnType<typeof parseWorkdayToken>, job: WorkdayJob): Job {
   const location = job.locationsText ?? "Unspecified";
-  const requisition = job.bulletFields?.[0] ?? job.externalPath.split("_").at(-1) ?? job.externalPath;
+  const requisition = workdayJobKey(job);
   return classifyJob({
     id: `workday:${company.slug}:${requisition}`,
     company: company.name,

package/src/cli.ts

@@ -11,6 +11,8 @@ import { runSourceDiscovery, runYcSourceDiscovery } from "./source-discovery.ts"
 import { discoverAndPromote } from "./source-discovery-pipeline.ts";
 import { traceCareerSources } from "./career-tracing.ts";
 import { discoverCommonCrawlSources } from "./common-crawl-discovery.ts";
+import { discoverCatalog } from "./catalog-discovery.ts";
+import { parseArgs } from "node:util";
 import { generateYcCompanySeeds } from "./company-seeds.ts";
 import { exportSnapshot } from "./snapshot-export.ts";
 import { enrichSourcesFromCompanies } from "./source-enrichment.ts";
@@ -39,6 +41,7 @@ Usage:
   openings sources discover-yc --country CODE [--registry FILE] [--output FILE] [--catalog FILE] [--report FILE]
   openings sources seed-companies-yc --country CODE [--output FILE]
   openings sources discover-common-crawl [--country CODE] [--provider NAME] [--index-record-limit N] [--sample-token-limit N] [--exclude-token TOKEN] [--report-only] [--registry FILE] [--output FILE] [--report FILE] [--index-url URL]
+  openings sources discover-catalog --index CC-MAIN-YYYY-NN --provider NAME [repeat index/provider] --state .openings/campaign.sqlite [--execute] [--request-budget N] [--page-budget N] [--target-boards N] [--delay-ms N] [--catalog FILE] [--export .openings/leads.json]
   openings sources enrich COMPANIES.json [--companies FILE]... [--evidence-kind authoritative_dataset|company_registry] [--registry FILE] [--output FILE] [--report FILE]
   openings sources trace-careers COMPANIES.json [--country CODE] [--registry FILE] [--common-crawl-report FILE] [--search-key-env NAME] [--output FILE] [--catalog FILE] [--report FILE]
   openings sources probe-jobposting COMPANIES.md [--catalog FILE] [--report FILE] [--company-limit 10|20]
@@ -223,6 +226,22 @@ export async function run(args: string[]): Promise<number> {
       console.log(JSON.stringify({ discovery: compactCareerTraceReport(discovery), promotion }, null, 2));
       return 0;
     }
+    if (rest[0] === "discover-catalog") {
+      const { values } = parseArgs({ args: rest.slice(1), strict: true, allowPositionals: false, options: {
+        index: { type: "string", multiple: true }, provider: { type: "string", multiple: true }, state: { type: "string" },
+        execute: { type: "boolean" }, "request-budget": { type: "string" }, "page-budget": { type: "string" },
+        "target-boards": { type: "string" }, "delay-ms": { type: "string" }, catalog: { type: "string" }, export: { type: "string" },
+      } });
+      if (!values.state) return fail("discover-catalog requires --state under .openings");
+      const report = await discoverCatalog({ state: values.state, indexes: values.index ?? [], providers: (values.provider ?? []) as Ats[], execute: values.execute,
+        requestBudget: values["request-budget"] === undefined ? undefined : Number(values["request-budget"]),
+        pageBudget: values["page-budget"] === undefined ? undefined : Number(values["page-budget"]),
+        targetBoards: values["target-boards"] === undefined ? undefined : Number(values["target-boards"]),
+        delayMs: values["delay-ms"] === undefined ? undefined : Number(values["delay-ms"]),
+        catalogPath: values.catalog ?? "data/companies.json", exportPath: values.export });
+      console.log(JSON.stringify(report, null, 2));
+      return ["error", "throttled", "cooling_down"].includes(report.status) ? 1 : 0;
+    }
     if (rest[0] === "discover-common-crawl") {
       const parsed = parseCommonCrawlDiscovery(rest.slice(1));
       if (typeof parsed === "string") return fail(parsed);

package/src/common-crawl-discovery.ts

@@ -39,10 +39,11 @@ export interface CommonCrawlDiscoveryReport extends ReportMeta {
 
 const providerPatterns: Record<Ats, string[]> = {
   greenhouse: ["job-boards.greenhouse.io/*", "boards.greenhouse.io/*"], lever: ["jobs.lever.co/*"], ashby: ["jobs.ashbyhq.com/*"], workday: ["*.myworkdayjobs.com/*"], recruitee: ["*.recruitee.com/*"],
-  ...Object.fromEntries(PROVIDERS.map((spec) => [spec.ats, spec.crawlPatterns])) as Record<"smartrecruiters" | "workable" | "breezy" | "freshteam" | "keka" | "zohorecruit" | "accenture" | "infosys" | "capgemini" | "amazon", string[]>,
+  ...Object.fromEntries(PROVIDERS.map((spec) => [spec.ats, spec.crawlPatterns])) as Record<"smartrecruiters" | "workable" | "breezy" | "freshteam" | "keka" | "zohorecruit" | "oraclecloud" | "accenture" | "infosys" | "capgemini" | "amazon", string[]>,
   jobposting: [], // company sites are found by probing seeds, never by URL pattern
 };
 const patterns = Object.values(providerPatterns).flat();
+export function commonCrawlPatterns(provider: Ats): readonly string[] { return providerPatterns[provider]; }
 const recordsPerPattern = 10_000;
 
 export async function discoverCommonCrawlSources(candidatesPath: string, reportPath: string, options: Options = {}): Promise<CommonCrawlDiscoveryReport> {

package/src/crawler.ts

@@ -1,5 +1,5 @@
 import type { FetchJobsObserver } from "./catalog.ts";
-import { statedExperience } from "./experience.ts";
+import { EXPERIENCE_VERSION, normalizeJobExperience } from "./experience.ts";
 import { partitionFor, type Company, type CrawlFailure, type CrawlReport, type CrawlSourceResult, type Job, type JobPartition, type JobSnapshot } from "./types.ts";
 
 export interface SnapshotStore {
@@ -49,23 +49,22 @@ export function createCrawler(options: CrawlerOptions): Crawler {
 
   /** Required experience for every job: from its description, the last crawl's reading, or a paced detail fetch for recent roles in describeCountries. */
   async function withExperience(source: Company, jobs: Job[], previous: Job[] | undefined): Promise<Job[]> {
-    const known = new Map((previous ?? []).filter((job) => job.experience !== undefined).map((job) => [job.id, job.experience]));
+    const known = new Map((previous ?? []).map(normalizeJobExperience).filter((job) => job.experienceVersion === EXPERIENCE_VERSION && job.experience !== undefined).map((job) => [job.id, job]));
     const since = now().getTime() - 30 * 86_400_000;
     const deadline = Date.now() + DESCRIBE_BUDGET_MS;
     let budget = DESCRIBE_LIMIT;
     const out: Job[] = [];
     for (const job of jobs) {
-      if (job.experience !== undefined) out.push(job);
-      else if (job.description.trim()) out.push({ ...job, experience: statedExperience(job.description) });
-      else if (known.has(job.id)) out.push({ ...job, experience: known.get(job.id) });
+      if (job.description.trim() || job.experienceVersion === EXPERIENCE_VERSION) out.push(normalizeJobExperience(job));
+      else if (known.has(job.id)) out.push({ ...job, description: known.get(job.id)!.description, experience: known.get(job.id)!.experience, experienceVersion: EXPERIENCE_VERSION });
       else if (options.describe && budget > 0 && Date.now() < deadline && job.eligibleCountries.some((code) => describeCountries.has(code)) && Date.parse(job.updatedAt ?? "") >= since) {
         budget -= 1;
         try {
           if (options.workdayPageDelayMs) await pacingSleep(options.workdayPageDelayMs);
           const description = await options.describe(source, job);
-          out.push(description.trim() ? { ...job, experience: statedExperience(description) } : job);
-        } catch { out.push(job); } // unread; the next crawl tries again
-      } else out.push(job);
+          out.push(normalizeJobExperience({ ...job, description }));
+        } catch { out.push(normalizeJobExperience(job)); } // unread; the next crawl tries again
+      } else out.push(normalizeJobExperience(job));
     }
     return out;
   }

package/src/experience.ts

@@ -1,7 +1,8 @@
-import { decodeEntities } from "./providers.ts";
+import { plainText } from "./providers.ts";
 
 /** Years of experience a posting asks for, read from its own text. */
-export interface Experience { min: number; max?: number }
+export interface Experience { min: number; max?: number; maxOpen?: boolean }
+export const EXPERIENCE_VERSION = 2;
 
 const WORDS: Record<string, number> = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10, twelve: 12, fifteen: 15 };
 const NUM = String.raw`(\d{1,2}(?:\.\d)?|${Object.keys(WORDS).join("|")})`;
@@ -11,6 +12,7 @@ const YEARS_THEN_EXPERIENCE = new RegExp(String.raw`${RANGE}(?:\s+of)?(?:\s+[\w/
 const EXPERIENCE_THEN_YEARS = new RegExp(String.raw`\b(?:experiences?|exp)\b[^.\n\d]{0,30}?${RANGE}`, "gi");
 // "minimum 15+ years" with no word "experience" after it.
 const MINIMUM_YEARS = new RegExp(String.raw`\b(?:minimum|min\.?|at least|atleast)\s*(?:of\s*)?${RANGE}`, "gi");
+const STANDALONE_YEARS = new RegExp(String.raw`^[ \t]*(?:[•·-][ \t]*)?${RANGE}[ \t]*[.!]?[ \t]*$`, "gmi");
 // Company history reads the same way ("our 135 years of experience"); skip matches that talk about the employer.
 const ABOUT_EMPLOYER = /\b(?:our (?:company|firm|group|organi[sz]ation|brands?|history|legacy)|(?:company|firm|group) (?:has|with)|founded|established|history|legacy|heritage)\b[^.\n?!:;•·-]*$/i;
 const MIN_PREFIX = /\b(?:minimum|min\.?|at least|atleast)\s*(?:of\s*)?$/i;
@@ -20,11 +22,15 @@ function value(text: string | undefined): number | undefined {
   return WORDS[text.toLowerCase()] ?? Number(text);
 }
 
-/** The first experience requirement the text states, or null when it states none. */
+/** Prefer overall/total experience and standalone role ranges to skill-specific requirements. */
 export function statedExperience(description: string): Experience | null {
-  const text = decodeEntities(description);
-  const found: Array<{ index: number; experience: Experience }> = [];
-  for (const pattern of [YEARS_THEN_EXPERIENCE, EXPERIENCE_THEN_YEARS, MINIMUM_YEARS]) {
+  return readExperience(description)?.experience ?? null;
+}
+
+export function readExperience(description: string): { index: number; quote: string; priority: number; experience: Experience } | null {
+  const text = plainText(description);
+  const found: Array<{ index: number; quote: string; priority: number; experience: Experience }> = [];
+  for (const pattern of [YEARS_THEN_EXPERIENCE, EXPERIENCE_THEN_YEARS, MINIMUM_YEARS, STANDALONE_YEARS]) {
     for (const match of text.matchAll(pattern)) {
       const [low, high] = [value(match[1]), value(match[2])];
       if (low === undefined || !Number.isFinite(low)) continue;
@@ -32,11 +38,15 @@ export function statedExperience(description: string): Experience | null {
       if (low > 20 || (high !== undefined && (high < low || high > 40))) continue;
       const before = text.slice(Math.max(0, match.index - 60), match.index);
       if (pattern !== MINIMUM_YEARS && ABOUT_EMPLOYER.test(before) && !MIN_PREFIX.test(before)) continue;
-      found.push({ index: match.index, experience: high !== undefined && high !== low ? { min: low, max: high } : { min: low } });
+      const lineStart = Math.max(text.lastIndexOf("\n", match.index - 1), text.lastIndexOf(".", match.index - 1)) + 1;
+      const context = text.slice(lineStart, match.index) + match[0];
+      const priority = /\b(?:overall|total)\b/i.test(context) ? 3 : pattern === STANDALONE_YEARS ? 2 : 1;
+      const maxOpen = high !== undefined && /(?:\+\s*(?:years?|yrs?)|(?:years?|yrs?)\s*\+)/i.test(match[0]);
+      found.push({ index: match.index, quote: match[0], priority, experience: high !== undefined && high !== low ? { min: low, max: high, ...(maxOpen ? { maxOpen: true } : {}) } : { min: low } });
     }
   }
-  found.sort((left, right) => left.index - right.index);
-  return found[0]?.experience ?? null;
+  found.sort((left, right) => right.priority - left.priority || right.experience.min - left.experience.min || left.index - right.index);
+  return found[0] ?? null;
 }
 
 /** Entry-level titles (intern, trainee, fresher, graduate) as a rough 0–1 year estimate when the posting states nothing. */
@@ -46,5 +56,17 @@ export function titleExperience(title: string): Experience | undefined {
 
 /** "2–5 yrs", "5+ yrs". */
 export function experienceLabel(experience: Experience): string {
-  return experience.max === undefined ? `${experience.min}+ yrs` : `${experience.min}–${experience.max} yrs`;
+  return experience.max === undefined ? `${experience.min}+ yrs` : `${experience.min}–${experience.max}${experience.maxOpen ? "+" : ""} yrs`;
+}
+
+export function experienceMatches(experience: Experience, years: number): boolean {
+  return years >= experience.min && (experience.max === undefined || experience.maxOpen === true || years <= experience.max);
+}
+
+/** Old cached readings without their source text cannot be safely corrected: make them unknown. */
+export function normalizeJobExperience<T extends { description: string; experience?: Experience | null; experienceVersion?: number }>(job: T): Omit<T, "experience" | "experienceVersion"> & { experience?: Experience | null; experienceVersion?: number } {
+  if (job.description.trim()) return { ...job, experience: statedExperience(job.description), experienceVersion: EXPERIENCE_VERSION };
+  if (job.experienceVersion === EXPERIENCE_VERSION) return job;
+  const { experience: _experience, experienceVersion: _version, ...rest } = job;
+  return rest;
 }

package/src/index.ts

@@ -17,7 +17,7 @@ export const companies: Company[] = Object.entries(companyData).map(([slug, valu
 
 export const catalog = createCatalog({ companies });
 export { createCatalog } from "./catalog.ts";
-export { experienceLabel, statedExperience, titleExperience, type Experience } from "./experience.ts";
+export { EXPERIENCE_VERSION, experienceLabel, experienceMatches, normalizeJobExperience, statedExperience, titleExperience, type Experience } from "./experience.ts";
 export type { Catalog } from "./catalog.ts";
 export type { Ats, Company, CrawlReport, Job, JobPartition, JobSnapshot, JobSummary, SearchQuery } from "./types.ts";
 export { createCrawlReporter, fetchSeedSnapshot, resolveAggregatorUrl } from "./crawl-reporting.ts";

package/src/job-matching.ts

@@ -1,4 +1,4 @@
-import { experienceLabel } from "./experience.ts";
+import { experienceLabel, normalizeJobExperience } from "./experience.ts";
 import { validateCandidateProfileEvidence, type CandidateProfile } from "./candidate-profile.ts";
 import { isEligibleForCountry, normalizeLocation } from "./locations.ts";
 import { detectRequirementTerms, findTransferability, matchesExactSkillEvidence, requiresExactSkillEvidence, type TransferabilityKind } from "./requirement-vocabulary.ts";
@@ -71,7 +71,8 @@ export function matchJobs(profile: CandidateProfile, intent: CandidateIntent, jo
   const roleFamilies = deriveRoleFamilies(profile, intent);
   const filteredOut: FilteredJob[] = [];
   const ranked: Array<JobMatch & { score: number; index: number }> = [];
-  for (const [index, job] of jobs.entries()) {
+  for (const [index, rawJob] of jobs.entries()) {
+    const job = normalizeJobExperience(rawJob);
     const rejectionReasons = hardFilterReasons(job, intent);
     if (rejectionReasons.length) {
       filteredOut.push({ jobId: job.id, reasons: rejectionReasons });
@@ -263,7 +264,7 @@ function seniorityAlignment(profile: CandidateProfile, intent: CandidateIntent,
   if (job.experience && typeof resumeYears === "number" && !intent.seniority?.length) {
     // The posting's own range is better evidence than a seniority word in the title. A year short or a few over still fits.
     const asked = experienceLabel(job.experience);
-    const fits = resumeYears >= job.experience.min - 1 && (job.experience.max === undefined || resumeYears <= job.experience.max + 3);
+    const fits = resumeYears >= job.experience.min - 1 && (job.experience.max === undefined || job.experience.maxOpen === true || resumeYears <= job.experience.max + 3);
     return { score: fits ? 3 : -3, reason: `posting asks for ${asked}; resume shows about ${resumeYears} years` };
   }
   const jobSeniority = seniorityTerms.find((term) => includesPhrase(job.title, term));

package/src/locations.ts

@@ -15,7 +15,7 @@ const INDIA_PLACES = [
 const INDIA_PATTERN = new RegExp(`\\b(${INDIA_PLACES.map(escapeRegExp).join("|")})\\b`, "i");
 const INDIA_INCLUSIVE_REGION_PATTERN = /\b(apac|asia|asia[ -]pacific|worldwide|anywhere|global)\b/i;
 const INDIA_EXCLUSION_PATTERN = /\b(not available|unavailable|excluding|except|cannot hire|can't hire|unable to hire|do not hire|does not hire)\b.{0,80}\b(india|apac|asia)\b|\b(india|apac|asia)\b.{0,40}\b(excluded|not eligible|not supported)\b/i;
-const INDIA_ELIGIBILITY_PATTERN = /\b(remote (?:in|from)|available (?:in|to)|open to|hiring (?:in|from)|candidates? (?:in|from)|applicants? (?:in|from)|work (?:in|from)|based in)\b.{0,80}\b(india|apac|asia)\b|\b(india|apac|asia)\b.{0,40}\b(remote|candidates?|applicants?|eligible|hiring)\b/i;
+const INDIA_ELIGIBILITY_PATTERN = /\b(remote (?:in|from)|available (?:in|to)|open to|hiring (?:in|from)|candidates? (?:in|from)|applicants? (?:in|from)|based in)\b.{0,80}\b(india|apac|asia)\b|\bwork (?:in|from)\s+(?:anywhere\s+in\s+)?(?:india|apac|asia)\b|\b(india|apac|asia)\b.{0,40}\b(remote|candidates?|applicants?|eligible|hiring)\b/i;
 
 export function normalizeLocation(value: string): string {
   const aliases: Record<string, string> = {
@@ -135,7 +135,7 @@ function detectEligibleCountries(description: string): string[] {
   for (const rule of countryRules()) {
     if (rule.eligibility.test(description)) matches.push(rule.code);
   }
-  if (/\b(open to|hiring|candidates?|applicants?|eligible|remote (?:in|from)|work (?:in|from)|based in|available (?:in|to))\b.{0,80}\bGeorgia\b/i.test(description)) matches.push("GE");
+  if (descriptionEligibilityPattern("\\bGeorgia\\b").test(description)) matches.push("GE");
   return matches;
 }
 
@@ -172,6 +172,10 @@ function countryMatchers(): Array<[string, string]> {
 }
 
 interface CountryRule { code: string; location: RegExp; codeLocation: RegExp; exclusion: RegExp; eligibility: RegExp }
+/** "Work in tandem with our India team" describes colleagues, not an applicant's work location. */
+function descriptionEligibilityPattern(country: string): RegExp {
+  return new RegExp(`\\b(open to|hiring|candidates?|applicants?|eligible|remote (?:in|from)|based in|available (?:in|to))\\b.{0,80}(?:${country})|\\bwork (?:in|from)\\s+(?:anywhere\\s+in\\s+)?(?:${country})`, "i");
+}
 let cachedCountryRules: CountryRule[] | undefined;
 function countryRules(): CountryRule[] {
   if (cachedCountryRules) return cachedCountryRules;
@@ -180,7 +184,7 @@ function countryRules(): CountryRule[] {
     location: new RegExp(country, "i"),
     codeLocation: new RegExp(`(?:^|[,(/-]\\s*)${code === "GB" ? "(?:GB|UK)" : code}(?=\\s*(?:$|[,)/-]))`, "i"),
     exclusion: new RegExp(`\\b(not available|unavailable|excluding|except|cannot hire|can't hire|unable to hire|do not hire|does not hire)\\b.{0,80}(?:${country})|(?:${country}).{0,40}\\b(excluded|not eligible|not supported)\\b`, "i"),
-    eligibility: new RegExp(`\\b(open to|hiring|candidates?|applicants?|eligible|remote (?:in|from)|work (?:in|from)|based in|available (?:in|to))\\b.{0,80}(?:${country})`, "i"),
+    eligibility: descriptionEligibilityPattern(country),
   }));
   return cachedCountryRules;
 }

package/src/providers.ts

@@ -186,6 +186,80 @@ const freshteam: ProviderSpec = {
 };
 
 /** Keka (India HRMS): the careers portal calls an unauthenticated embed API. Token is `tenant/orgId`; the org id sits in the portal shell. */
+/** Oracle Cloud Recruiting (the "CandidateExperience" career sites). Token: "<host>/<siteNumber>", e.g. "jpmc.fa.oraclecloud.com/CX_1". */
+const ORACLE_HOST = /^[a-z0-9-]+\.fa(?:\.[a-z0-9-]+)*\.oraclecloud\.com$/i;
+const ORACLE_PAGE = 200;
+/** Newest first, so a large employer costs a few pages: stop once a whole page predates this. */
+const ORACLE_MAX_AGE_DAYS = 45;
+// Enterprise tenants run to thousands of open roles; this bounds a crawl at 20 requests while covering the window we care about.
+const ORACLE_MAX_RECORDS = 4000;
+const oracleHost = (token: string) => token.split("/")[0] ?? "";
+const oracleSite = (token: string) => token.split("/")[1] ?? "CX_1";
+function oracleList(token: string, offset: number): string {
+  return `https://${oracleHost(token)}/hcmRestApi/resources/latest/recruitingCEJobRequisitions?onlyData=true&expand=requisitionList.secondaryLocations` +
+    `&finder=findReqs;siteNumber=${encodeURIComponent(oracleSite(token))},limit=${ORACLE_PAGE},offset=${offset},sortBy=POSTING_DATES_DESC`;
+}
+function oracleRequisitions(body: unknown): Rec[] | null {
+  if (!isRecord(body)) return null;
+  const items = asRecords(body.items) ?? [];
+  const list = items.flatMap((item) => asRecords(item.requisitionList) ?? []);
+  return items.length ? list : null;
+}
+
+const oraclecloud: ProviderSpec = {
+  ats: "oraclecloud",
+  label: "Oracle Cloud Recruiting",
+  hosts: ["oraclecloud.com"],
+  crawlPatterns: ["*.fa.oraclecloud.com/hcmUI/CandidateExperience*"],
+  resolve(url) {
+    if (!ORACLE_HOST.test(url.hostname)) return null;
+    const site = /\/sites\/([A-Za-z0-9_]{2,32})/.exec(url.pathname)?.[1] ?? url.searchParams.get("siteNumber");
+    return site && /^[A-Za-z0-9_]{2,32}$/.test(site) ? `${url.hostname.toLowerCase()}/${site}` : null;
+  },
+  canonicalUrl: (token) => `https://${oracleHost(token)}/hcmUI/CandidateExperience/en/sites/${oracleSite(token)}/requisitions`,
+  endpoint: (token) => oracleList(token, 0),
+  jobsFromBody: (body) => oracleRequisitions(body),
+  providerName: () => "",
+  payloadVersion: () => "oracle-recruiting-ce:v1",
+  async fetchAll(token, get) {
+    const records: Rec[] = [];
+    const cutoff = Date.now() - ORACLE_MAX_AGE_DAYS * 86_400_000;
+    for (let offset = 0; offset < ORACLE_MAX_RECORDS; offset += ORACLE_PAGE) {
+      const page = oracleRequisitions(await get(oracleList(token, offset))) ?? [];
+      records.push(...page);
+      if (page.length < ORACLE_PAGE) break;
+      // Sorted newest first: once a whole page is older than the window, later pages are older still.
+      const dates = page.map((job) => Date.parse(str(job.PostedDate))).filter((time) => Number.isFinite(time));
+      if (dates.length && Math.max(...dates) < cutoff) break;
+    }
+    return records;
+  },
+  normalize(company, job) {
+    const secondary = (asRecords(job.secondaryLocations) ?? []).map((place) => str(place.Name)).filter(Boolean);
+    const country = countryLabel(str(job.PrimaryLocationCountry));
+    const primary = str(job.PrimaryLocation);
+    // The country name is appended so eligibility reads it: Oracle gives the code separately from the label.
+    const location = [primary, ...secondary].filter(Boolean).join("; ") + (country && !new RegExp(`\\b${country}\\b`, "i").test(primary) ? `, ${country}` : "");
+    const workplace = str(job.WorkplaceType) || str(job.WorkplaceTypeCode);
+    const remote = /remote|work from home/i.test(`${workplace} ${location}`);
+    return classifyJob({
+      id: `oraclecloud:${company.slug}:${str(job.Id)}`, company: company.name, title: str(job.Title),
+      location: location || "Unspecified", remote, workMode: remote ? "remote" : "unknown",
+      eligibleCountries: [], excludedCountries: [], eligibleRegions: [], eligibilityConfidence: "unknown",
+      url: `https://${oracleHost(company.token)}/hcmUI/CandidateExperience/en/sites/${oracleSite(company.token)}/job/${encodeURIComponent(str(job.Id))}`,
+      ...(str(job.PostedDate) ? { updatedAt: str(job.PostedDate) } : {}),
+      description: "", // the listing carries only a teaser; detail() reads the advert
+    });
+  },
+  async detail(company, job, get) {
+    const id = job.id.split(":").pop() ?? "";
+    const body = await get(`https://${oracleHost(company.token)}/hcmRestApi/resources/latest/recruitingCEJobRequisitionDetails?expand=all&onlyData=true&finder=ById;Id="${encodeURIComponent(id)}",siteNumber=${encodeURIComponent(oracleSite(company.token))}`);
+    const item = (asRecords(isRecord(body) ? body.items : null) ?? [])[0];
+    if (!item) return "";
+    return plainText([str(item.ExternalDescriptionStr), str(item.ExternalResponsibilitiesStr), str(item.ExternalQualificationsStr)].filter(Boolean).join("\n\n"));
+  },
+};
+
 const keka: ProviderSpec = {
   ats: "keka",
   label: "Keka",
@@ -264,7 +338,7 @@ function tag(xml: string, name: string): string { return new RegExp(`<${name}(?:
 function cdata(value: string): string { return value.replace(/^<!\[CDATA\[([\s\S]*?)\]\]>$/, "$1").trim(); }
 
 import { PORTALS } from "./portals.ts";
-export const PROVIDERS: ReadonlyArray<ProviderSpec> = [smartrecruiters, workable, breezy, freshteam, keka, zohorecruit, ...PORTALS];
+export const PROVIDERS: ReadonlyArray<ProviderSpec> = [smartrecruiters, workable, breezy, freshteam, keka, zohorecruit, oraclecloud, ...PORTALS];
 
 export function providerSpec(ats: string): ProviderSpec | undefined {
   return PROVIDERS.find((spec) => spec.ats === ats);

package/src/runtime.ts

@@ -5,6 +5,7 @@ import { fetchJobDescription, fetchSourceJobs } from "./catalog.ts";
 import { createCrawlReporter, fetchSeedSnapshot, resolveAggregatorUrl } from "./crawl-reporting.ts";
 import { createUsageReporter, type UsageReporter } from "./usage.ts";
 import { VERSION } from "./version.ts";
+import { normalizeJobExperience } from "./experience.ts";
 import { catalog as liveCatalog, companies } from "./index.ts";
 import { createLocalJobs } from "./local-jobs.ts";
 import { createJobRecommender } from "./job-recommendations.ts";
@@ -82,7 +83,7 @@ export function createHostedRuntime(options: { sources: Company[]; store: Snapsh
     if (!company) return job;
     try {
       const description = await fetchJobDescription(company, job, globalThis.fetch);
-      return description.trim() ? { ...job, description } : job;
+      return description.trim() ? normalizeJobExperience({ ...job, description }) : job;
     } catch { return job; } // the employer's board is unreachable; the summary is still useful
   }
   const snapshotJob = async (id: string) => (await local.get(id, { offline: true, staleDays: 3650 })).job;

package/src/screening-requirements.ts

@@ -1,5 +1,7 @@
 import type { CandidateProfile } from "./candidate-profile.ts";
 import type { Job } from "./types.ts";
+import { readExperience } from "./experience.ts";
+import { plainText } from "./providers.ts";
 
 export interface ScreeningRequirement {
   kind: "experience" | "education";
@@ -14,6 +16,12 @@ export function evaluateScreeningRequirements(profile: CandidateProfile, job: Jo
     ...experienceRequirements(profile, description),
     ...educationRequirements(profile, description),
   ];
+  const text = plainText(job.description);
+  const reading = readExperience(text);
+  if (reading && (isMandatory(text, reading.index, reading.quote) || (reading.priority === 2 && lastSectionKind(text.slice(0, reading.index)) !== "optional")) && !requirements.some((item) => item.kind === "experience" && Number(item.requirement.match(/\d+/)?.[0]) === reading.experience.min)) {
+    const inference = profile.inferences.find((value) => value.kind === "approximate_experience_years");
+    requirements.push({ kind: "experience", requirement: clean(reading.quote), status: !inference ? "unsupported" : inference.value >= reading.experience.min ? "supported" : "partial", factIds: inference?.derivedFromFactIds ?? [] });
+  }
   return [...new Map(requirements.map((item) => [`${item.kind}:${item.requirement.toLocaleLowerCase()}`, item])).values()];
 }
 

package/src/selected-job-lookup.ts

@@ -1,4 +1,5 @@
 import type { Job } from "./types.ts";
+import { normalizeJobExperience } from "./experience.ts";
 
 export interface SelectedJobLookupOptions {
   getSnapshotJob(id: string): Promise<Job | null>;
@@ -8,7 +9,8 @@ export interface SelectedJobLookupOptions {
 export function createSelectedJobLookup(options: SelectedJobLookupOptions) {
   return async (id: string): Promise<Job | null> => {
     const snapshot = await options.getSnapshotJob(id);
-    if (snapshot?.description.trim()) return snapshot;
-    return options.getDetailedJob(id);
+    if (snapshot?.description.trim()) return normalizeJobExperience(snapshot);
+    const detailed = await options.getDetailedJob(id);
+    return detailed ? normalizeJobExperience(detailed) : null;
   };
 }

package/src/snapshot-catalog.ts

@@ -1,5 +1,6 @@
 import { searchJobs, type Catalog } from "./catalog.ts";
 import type { SnapshotStore } from "./crawler.ts";
+import { normalizeJobExperience } from "./experience.ts";
 
 export function createSnapshotCatalog(store: SnapshotStore): Catalog {
   return {
@@ -13,7 +14,7 @@ export function createSnapshotCatalog(store: SnapshotStore): Catalog {
       if (!snapshot) return null;
       for (const partition of Object.values(snapshot.partitions)) {
         const job = partition.jobs.find((candidate) => candidate.id === id);
-        if (job) return job;
+        if (job) return normalizeJobExperience(job);
       }
       return null;
     },

package/src/types.ts

@@ -1,5 +1,5 @@
 /** ATS boards plus "jobposting": a company's own career site read only through its schema.org JobPosting markup (token = careers URL). */
-export const ALL_PROVIDERS = ["greenhouse", "lever", "ashby", "workday", "recruitee", "smartrecruiters", "workable", "breezy", "freshteam", "keka", "zohorecruit", "jobposting", "accenture", "infosys", "capgemini", "amazon"] as const;
+export const ALL_PROVIDERS = ["greenhouse", "lever", "ashby", "workday", "recruitee", "smartrecruiters", "workable", "breezy", "freshteam", "keka", "zohorecruit", "oraclecloud", "jobposting", "accenture", "infosys", "capgemini", "amazon"] as const;
 export type Ats = (typeof ALL_PROVIDERS)[number];
 
 export interface DomainEvidence {
@@ -87,6 +87,7 @@ export interface JobSummary {
   updatedAt?: string;
   /** Years of experience the posting states, read from its description. null: the description states none. Absent: not read yet. */
   experience?: Experience | null;
+  experienceVersion?: number;
   /** Days since the posting date at the time of the search; absent when the board gave no date. */
   postedDaysAgo?: number;
   /** new = 7 days or less, older = 8 to 30, stale = beyond 30, undated = no posting date. Present it as such; a stale listing may still be open. */

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.1.36";
+export const VERSION = "0.1.38";