openings 0.1.37 → 0.1.39

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "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,49 @@
       "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"
+    }
+  },
+  "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"
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "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

@@ -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/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/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 {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.1.37";
+export const VERSION = "0.1.39";