diff --git a/docs/superpowers/specs/2026-10-07-oilgas-job-portal-adapters-design.md b/docs/superpowers/specs/2026-10-07-oilgas-job-portal-adapters-design.md
new file mode 100644
index 000000000..67f18a868
--- /dev/null
+++ b/docs/superpowers/specs/2026-10-07-oilgas-job-portal-adapters-design.md
@@ -0,0 +1,137 @@
+# Oil & gas job portal adapter: EnergyJobline
+
+**Date:** 2026-10-07
+**Status:** design approved, scope narrowed after a Rigzone feasibility spike
+
+## The problem
+
+The user supplied ~40 oil & gas domains (agencies, job portals, majors, EPC/service
+companies) to evaluate as new ingest sources. Recon across all of them, plus a pass over
+the live `boards` table, narrowed things down fast:
+
+- 18 majors/EPC/service companies sit on a known ATS. 13 were already boarded
+  (Shell, BP, Baker Hughes, Eni, ExxonMobil, Fluor, Halliburton, KBR, McDermott, SLB,
+  TechnipFMC, Wood, Worley). 5 were added via `cmd/add-board` on 2026-10-06 (Subsea7,
+  Bechtel, ADNOC, QatarEnergy, TotalEnergies). Aramco is excluded — its site TCP-blocks
+  automated requests and the platform could not be confirmed.
+- Of the 7 general/niche job portals (Rigzone, Oilcareers, EnergyJobline,
+  OilAndGasJobSearch, Bayt, GulfTalent, NaukriGulf, Laimoon — 8 names, 7 distinct
+  backends since Oilcareers shares Rigzone's infrastructure):
+  - **Bayt and GulfTalent already have adapters**, already registered, and already have
+    live `boards` rows. Nothing to build.
+  - **Laimoon's jobs backend is dead** — confirmed stub/kill-switch across the whole
+    `jobs.laimoon.com` subdomain, no link from the live homepage. Out of scope.
+  - **NaukriGulf and OilAndGasJobSearch are unreachable at the network level** from both
+    this environment and the prod host (tar-pit / connection refused). Out of scope.
+  - **Rigzone** looked buildable on first recon (AWS WAF challenge, same shape as
+    Bayt/GulfTalent's Cloudflare challenge) but a feasibility spike invalidated that — see
+    below. Moved to the deferred group.
+  - **EnergyJobline** is the one portal this design covers.
+
+## Rigzone feasibility spike (2026-10-07) — INVALIDATED for now
+
+Before committing to build Rigzone alongside EnergyJobline, its one open risk (would the
+project's existing Chrome-fingerprint transport, `fingerprinthttp.go`, clear Rigzone's bot
+defense the way it clears Bayt's and GulfTalent's?) was spiked directly against the live
+site, using the actual transport code rather than a guess:
+
+- **Plain fingerprint transport (`newFingerprintHTTP`, the same one `bayt.go`/
+  `gulftalent.go` use):** both `https://www.rigzone.com/` and `/sitemap.xml` returned a
+  flat `HTTP 403 Forbidden` (nginx-style, "a padding to disable MSIE and Chrome friendly
+  error page" body) with no `x-amzn-waf-action` header at all — i.e. not the solvable
+  "challenge" response seen from a plain `curl`, but a harder block that offers nothing to
+  pass. This matches the pattern this repo's own `firecrawltier.go` documents for
+  Bayt/GulfTalent/Wellfound: "the refusal comes before any challenge is offered" — a
+  datacenter-IP-level block, not a fingerprint check.
+- **Proxied fingerprint transport (`newProxiedFingerprintHTTP`, over this repo's existing
+  `SOURCES_PROXY_URL`):** untestable — the proxy account returned `402 Payment Required`.
+  Determining whether a non-datacenter egress clears Rigzone's block would require
+  topping up that account first, a real spend decision.
+- The further escalation this repo already has for exactly this shape of wall — the hosted
+  Firecrawl tier (`firecrawltier.go`) — also costs money per page and was not attempted.
+
+**Verdict: INVALIDATED within the current budget.** The free tier (fingerprint spoofing
+alone) flatly fails, and the next tier that might work costs money to even test. Asked
+directly, the user chose not to spend to find out — so Rigzone joins NaukriGulf and
+OilAndGasJobSearch in the deferred group rather than being forced through. It can be
+revisited later specifically because it is a 100%-on-topic oil & gas board (unlike Bayt/
+GulfTalent, whose broad general listings make the hosted tier's cost/relevance trade-off
+much worse) — if the user later wants to fund a proxy top-up or a Firecrawl trial, this
+spike's numbers are the starting point, not a dead end.
+
+## EnergyJobline
+
+Confirmed with a plain `curl` (Googlebot UA, no cookies, no JS) — no bot defense observed:
+
+- `https://www.energyjobline.com/sitemap.xml` is an open sitemap **index** of 4
+  sub-sitemaps.
+- A live posting, `https://www.energyjobline.com/job/controls-engineer-atlanta-31835232`,
+  server-renders three `<script type="application/ld+json">` blocks (`WebSite`,
+  `Organization`, `JobPosting`). `ldJobPosting` already walks past the non-JobPosting
+  blocks (`jobPostingNode` + `isJobPosting` filter by `@type`), so no new ld+json plumbing
+  is needed.
+- The `JobPosting` block carries `title`, `description`, `jobLocation`/`address`,
+  `hiringOrganization`, `datePosted`, `employmentType`, `baseSalary`.
+
+This is the same enumeration shape as `dataart.go` — sitemap to enumerate, `fetchDetails`
+with `defaultDetailWorkers` to fetch each page, `ldJobPosting` to decode — combined with the
+same **company resolution** `bayt.go`/`gulftalent.go` already use for exactly this
+situation, rather than a new mechanism:
+
+- `boardless()` — EnergyJobline has one sitemap, no per-tenant board id.
+- `aggregator()` — the existing marker interface (`internal/ingest/sources/source.go`)
+  that documents "one crawl aggregates postings from many companies" and keeps the source
+  included in the source facet. No `CompanyEntry.Hub`/`Tenants` involvement at all — that
+  mechanism belongs to a different family of adapters (huntflow/cleverstaff/loxo/
+  successfactors) whose platform does NOT hand back a clean per-posting employer name,
+  so they resolve it from a URL/API field/title/curated map instead. EnergyJobline's
+  `JobPosting` ld+json already carries a clean `hiringOrganization.name` per posting — the
+  same situation Bayt and GulfTalent are in — so it follows their pattern exactly:
+
+```go
+company := strings.TrimSpace(p.HiringOrg.Name)
+if company == "" {
+    return unreadableDetail(id, link, e.Company), true // proves the posting existed; no good employer name to show
+}
+```
+
+This reuses the existing `unreadableDetail` helper (`helpers.go`) rather than inventing a
+fallback — the same one `bayt.go`'s `detail` uses for an empty `hiringOrganization` and for
+an unparseable fetch.
+
+## Boards
+
+Added via `cmd/add-board` after the code ships and a first manual run looks sane:
+
+- `energyjobline` / board `www.energyjobline.com` / company `EnergyJobline`
+
+## Testing
+
+A unit test over a fixture sitemap-index + 2-3 fixture job pages under different
+`hiringOrganization` values, asserting: the resolved employer per posting, the
+`unreadableDetail` fallback when `hiringOrganization` is absent/empty, and the dedup
+`ExternalID` — the same shape as `bayt_test.go`'s existing coverage of the same pattern.
+
+## Risks
+
+- **Job volume is unknown.** Recon confirmed the markup shape on one posting, not a count.
+  Sanity-check the first run's job count/duration before trusting the board long-term —
+  the same caution the SuccessFactors hub design raised for a large, uncounted hub.
+- **`hiringOrganization` has no curation step.** A scraped `hiringOrganization.name` can be
+  messy — the platform's own brand, a recruiter's name instead of the real employer,
+  inconsistent casing — and the fallback only catches *empty* values, not wrong-but-present
+  ones. Bayt and GulfTalent accept the same risk for the same reason: it is the only
+  per-posting signal the site offers. Watch the catalogue after launch for obviously wrong
+  employer names on this source specifically.
+
+## Out of scope
+
+- **Rigzone (and Oilcareers)** — spiked and invalidated within the current budget (see
+  above). Revisit if the user wants to fund a `SOURCES_PROXY_URL` top-up or a Firecrawl
+  trial specifically for it.
+- Laimoon — jobs backend is confirmed dead, not resurrectable by an adapter.
+- NaukriGulf, OilAndGasJobSearch — unreachable at the network level from this environment
+  and from the prod host; the same paid-capability question as Rigzone would apply, not
+  attempted.
+- Any change to `bayt.go`/`gulftalent.go` or the `aggregator`/`boardless` marker
+  interfaces — EnergyJobline only consumes them, exactly as they already exist.
diff --git a/internal/ingest/sources/energyjobline.go b/internal/ingest/sources/energyjobline.go
new file mode 100644
index 000000000..3bd962e30
--- /dev/null
+++ b/internal/ingest/sources/energyjobline.go
@@ -0,0 +1,161 @@
+package sources
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"golang.org/x/net/html"
+)
+
+// energyjobline adapts EnergyJobline (www.energyjobline.com), an energy-sector job-portal
+// aggregator (oil & gas is one of its categories). It is boardless — one sitemap index
+// covers the whole site, no per-tenant board id — and an aggregator: each posting's
+// employer comes from its own schema.org JobPosting hiringOrganization, the same
+// resolution bayt.go/gulftalent.go use. For agency/recruiter-submitted postings that
+// value is the agency's own brand (e.g. "Energy Jobline ZR") rather than a confidential
+// end client — verified against the live site's own human-visible company link, not just
+// its ld+json, so it is stored as-is rather than filtered or guessed around.
+type energyjobline struct {
+	http energyjoblineHTTP
+}
+
+// energyjoblineHTTP is the transport energyjobline needs: the XML sitemap (index and
+// per-page urlset) plus HTML detail pages.
+type energyjoblineHTTP interface {
+	XMLGetter
+	HTMLGetter
+}
+
+const energyjoblineSitemapIndexURL = "https://www.energyjobline.com/sitemap.xml"
+
+// NewEnergyJobline builds the EnergyJobline adapter over the given HTTP client.
+func NewEnergyJobline(c energyjoblineHTTP) Source { return energyjobline{http: c} }
+
+func (energyjobline) Provider() string { return "energyjobline" }
+
+// energyjobline is single-sitemap, so its config entry carries no board.
+func (energyjobline) boardless() {}
+
+// aggregator documents that one crawl aggregates postings from many companies (the
+// employer comes from each posting, not the configured entry).
+func (energyjobline) aggregator() {}
+
+func (e energyjobline) Fetch(ctx context.Context, ce CompanyEntry) ([]Job, error) {
+	urls, err := e.jobURLs(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("energyjobline: sitemap: %w", err)
+	}
+	return fetchDetails(urls, defaultDetailWorkers, func(u string) (Job, bool) {
+		return e.detail(ctx, ce, u)
+	}), nil
+}
+
+// jobURLs resolves the top-level sitemap index to its paginated sub-sitemaps (each a flat
+// urlset mixing job postings with the site's other pages, e.g. news articles) and returns
+// every job-detail URL found across all of them.
+func (e energyjobline) jobURLs(ctx context.Context) ([]string, error) {
+	idx, err := getSitemap(ctx, e.http, energyjoblineSitemapIndexURL)
+	if err != nil {
+		return nil, err
+	}
+	var urls []string
+	for _, sm := range idx.Sitemaps {
+		locs, err := sitemapJobLocs(ctx, e.http, sm.Loc, energyjoblineJobID)
+		if err != nil {
+			return nil, err
+		}
+		urls = append(urls, locs...)
+	}
+	return urls, nil
+}
+
+// detail fetches one job-detail page and maps its JobPosting ld+json to a Job. A URL with
+// no extractable id, an unreadable fetch, a missing JobPosting block, or an empty
+// hiringOrganization all return an unreadableDetail stub rather than a dropped posting or
+// a guessed employer — the posting's existence is still proven, just with no usable
+// catalogue entry.
+func (e energyjobline) detail(ctx context.Context, ce CompanyEntry, link string) (Job, bool) {
+	id := energyjoblineJobID(link)
+	if id == "" {
+		return Job{}, false
+	}
+	root, err := e.http.GetHTML(ctx, link)
+	if err != nil {
+		if detailUnreadable(err) {
+			return unreadableDetail(id, link, ce.Company), true
+		}
+		return Job{}, false
+	}
+	var p energyjoblinePosting
+	if !ldJobPosting(root, &p) {
+		return unreadableDetail(id, link, ce.Company), true
+	}
+	company := strings.TrimSpace(p.HiringOrg.Name)
+	if company == "" {
+		return unreadableDetail(id, link, ce.Company), true
+	}
+	location := joinNonEmpty(
+		strings.TrimSpace(p.jobLocationAddress().Locality),
+		strings.TrimSpace(p.jobLocationAddress().Country),
+	)
+	return Job{
+		ExternalID: id,
+		URL:        link,
+		Title:      strings.TrimSpace(p.Title),
+		Company:    company,
+		Location:   location,
+		// EnergyJobline's description carries HTML-entity-encoded markup (e.g. literal
+		// "&amp;" inside the JSON string, confirmed on a live posting), so it needs
+		// unescaping before sanitizeHTML — unlike bayt.go/gulftalent.go, whose descriptions
+		// arrive already decoded.
+		Description: sanitizeHTML(html.UnescapeString(p.Description)),
+		Remote:      isRemote(location),
+		PostedAt:    parseDate(p.DatePosted),
+	}, true
+}
+
+// energyjoblineJobURLPattern captures the trailing numeric id from a canonical job-detail
+// URL (https://www.energyjobline.com/job/<slug>-<id>), excluding the listing root
+// (/jobs), the site root, and unrelated pages (e.g. /news-article/..., /company/...).
+var energyjoblineJobURLPattern = regexp.MustCompile(`^https?://(?:www\.)?energyjobline\.com/job/[a-z0-9-]+-(\d+)/?$`)
+
+// energyjoblineJobID extracts the job id from a canonical job-detail URL, returning "" for
+// any other page shape on the site.
+func energyjoblineJobID(u string) string {
+	return firstSubmatch(energyjoblineJobURLPattern, u)
+}
+
+// energyjoblinePosting is the schema.org JobPosting decoded from an EnergyJobline
+// job-detail page's ld+json.
+type energyjoblinePosting struct {
+	Title       string               `json:"title"`
+	Description string               `json:"description"`
+	DatePosted  string               `json:"datePosted"`
+	HiringOrg   energyjoblineOrg     `json:"hiringOrganization"`
+	JobLocation []energyjoblinePlace `json:"jobLocation"`
+}
+
+type energyjoblineOrg struct {
+	Name string `json:"name"`
+}
+
+type energyjoblinePlace struct {
+	Address energyjoblineAddress `json:"address"`
+}
+
+type energyjoblineAddress struct {
+	Locality string `json:"addressLocality"`
+	Country  string `json:"addressCountry"`
+}
+
+// jobLocationAddress returns the first jobLocation's address, or a zero value when the
+// posting carries none — EnergyJobline's postings each carry exactly one, but the field is
+// an array in the markup, so this guards the empty case rather than indexing directly.
+func (p energyjoblinePosting) jobLocationAddress() energyjoblineAddress {
+	if len(p.JobLocation) == 0 {
+		return energyjoblineAddress{}
+	}
+	return p.JobLocation[0].Address
+}
diff --git a/internal/ingest/sources/energyjobline_test.go b/internal/ingest/sources/energyjobline_test.go
new file mode 100644
index 000000000..60f9f5a03
--- /dev/null
+++ b/internal/ingest/sources/energyjobline_test.go
@@ -0,0 +1,292 @@
+package sources
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+func energyjoblineSitemapIndexXML(subs ...string) string {
+	s := `<?xml version="1.0" encoding="UTF-8"?><sitemapindex>`
+	for _, sm := range subs {
+		s += `<sitemap><loc>` + sm + `</loc></sitemap>`
+	}
+	return s + `</sitemapindex>`
+}
+
+func energyjoblineURLSetXML(locs ...string) string {
+	s := `<?xml version="1.0" encoding="UTF-8"?><urlset>`
+	for _, l := range locs {
+		s += `<url><loc>` + l + `</loc></url>`
+	}
+	return s + `</urlset>`
+}
+
+func energyjoblineDetailHTML(title, company, description, datePosted, locality, country string) string {
+	return `<html><head><script type="application/ld+json">` +
+		`{"@context":"https://schema.org/","@type":"WebSite","name":"Energy Jobline"}` +
+		`</script><script type="application/ld+json">` +
+		`{"@context":"https://schema.org/","@type":"Organization","name":"Energy Jobline"}` +
+		`</script><script type="application/ld+json">` +
+		`{"@context":"https://schema.org/","@type":"JobPosting",` +
+		`"title":"` + title + `",` +
+		`"hiringOrganization":{"@type":"Organization","name":"` + company + `"},` +
+		`"description":"` + description + `",` +
+		`"datePosted":"` + datePosted + `",` +
+		`"jobLocation":[{"@type":"Place","address":{"@type":"PostalAddress",` +
+		`"addressLocality":"` + locality + `","addressCountry":"` + country + `"}}]}` +
+		`</script></head><body></body></html>`
+}
+
+func TestEnergyjoblineFetchWalksIndexThenDetailAndMaps(t *testing.T) {
+	jobURL := "https://www.energyjobline.com/job/controls-engineer-atlanta-31835232"
+	detail := energyjoblineDetailHTML(
+		"Controls Engineer in Atlanta", "The AES Corporation",
+		"Field service controls engineering.", "2026-10-01", "Atlanta", "US")
+
+	fake := (&routedHTTP{}).
+		route("sitemap.xml?page=1", energyjoblineURLSetXML(
+			jobURL,
+			"https://www.energyjobline.com/",     // site root, not a job
+			"https://www.energyjobline.com/jobs", // listing root, not a job
+			"https://www.energyjobline.com/news-article/oil-and-gas/some-story", // unrelated
+		)).
+		route("sitemap.xml?page=2", energyjoblineURLSetXML()).
+		// Registered after the page-specific routes: routedHTTP matches by substring in
+		// append order, and "sitemap.xml" is itself a substring of "sitemap.xml?page=1" —
+		// this generic route must lose that race for the index URL to resolve correctly.
+		route("sitemap.xml", energyjoblineSitemapIndexXML(
+			"https://www.energyjobline.com/sitemap.xml?page=1",
+			"https://www.energyjobline.com/sitemap.xml?page=2",
+		)).
+		route("/job/controls-engineer-atlanta-31835232", detail)
+
+	jobs, err := NewEnergyJobline(fake).Fetch(context.Background(), CompanyEntry{
+		Company: "EnergyJobline", Provider: "energyjobline",
+	})
+	if err != nil {
+		t.Fatalf("Fetch: %v", err)
+	}
+	if len(jobs) != 1 {
+		t.Fatalf("got %d jobs, want 1 (non-job sitemap entries must be excluded)", len(jobs))
+	}
+	j := jobs[0]
+	if j.ExternalID != "31835232" {
+		t.Errorf("ExternalID = %q, want 31835232", j.ExternalID)
+	}
+	if j.Title != "Controls Engineer in Atlanta" {
+		t.Errorf("Title = %q", j.Title)
+	}
+	if j.Company != "The AES Corporation" {
+		t.Errorf("Company = %q, want the posting's own hiringOrganization", j.Company)
+	}
+	if j.URL != jobURL {
+		t.Errorf("URL = %q, want %q", j.URL, jobURL)
+	}
+	if j.Location != "Atlanta, US" {
+		t.Errorf("Location = %q", j.Location)
+	}
+	if j.PostedAt == nil || j.PostedAt.Format("2006-01-02") != "2026-10-01" {
+		t.Errorf("PostedAt = %v, want 2026-10-01", j.PostedAt)
+	}
+}
+
+func TestEnergyjoblineBrokenSitemapIndexErrorsTheCrawl(t *testing.T) {
+	fake := (&routedHTTP{}).routeErr("sitemap.xml", errors.New("origin down"))
+	_, err := NewEnergyJobline(fake).Fetch(context.Background(), CompanyEntry{
+		Company: "EnergyJobline", Provider: "energyjobline",
+	})
+	if err == nil {
+		t.Fatal("Fetch: want error on a broken sitemap index, got nil")
+	}
+}
+
+// The index itself can resolve fine while one of its sub-sitemaps fails; that failure
+// propagates as a hard Fetch error too (no fullBoardListing is claimed here, so any shard
+// failure means the enumeration is incomplete and the caller should not trust a partial
+// result as "today's whole catalogue").
+func TestEnergyjoblineSubSitemapFailureFailsTheCrawl(t *testing.T) {
+	fake := (&routedHTTP{}).
+		route("sitemap.xml?page=1", energyjoblineURLSetXML("https://www.energyjobline.com/job/ok-1")).
+		route("sitemap.xml", energyjoblineSitemapIndexXML(
+			"https://www.energyjobline.com/sitemap.xml?page=1",
+			"https://www.energyjobline.com/sitemap.xml?page=2",
+		)).
+		routeErr("sitemap.xml?page=2", errors.New("origin down"))
+
+	_, err := NewEnergyJobline(fake).Fetch(context.Background(), CompanyEntry{
+		Company: "EnergyJobline", Provider: "energyjobline",
+	})
+	if err == nil {
+		t.Fatal("Fetch: want error when one sub-sitemap fails, got nil")
+	}
+}
+
+func TestEnergyjoblineCompanyComesFromThePosting(t *testing.T) {
+	jobURL := "https://www.energyjobline.com/job/welder-kent-27543774"
+	detail := energyjoblineDetailHTML("WELDER in Kent", "Energy Jobline ZR",
+		"desc", "2026-10-02", "Kent", "GB")
+	fake := (&routedHTTP{}).route("/job/welder-kent-27543774", detail)
+
+	j, ok := energyjobline{http: fake}.detail(context.Background(),
+		CompanyEntry{Company: "EnergyJobline", Provider: "energyjobline"}, jobURL)
+	if !ok {
+		t.Fatal("detail returned ok=false")
+	}
+	// The site attributes agency-submitted postings to the agency's own brand, not a
+	// confidential end client — that is the real, honest value of hiringOrganization for
+	// this posting (verified against the live site's own human-visible company link, not
+	// just its ld+json), so it is stored as-is rather than filtered or guessed around.
+	if j.Company != "Energy Jobline ZR" {
+		t.Errorf("Company = %q, want the posting's own (agency) hiringOrganization", j.Company)
+	}
+}
+
+func TestEnergyjoblineUnreadableDetailWhenHiringOrgEmpty(t *testing.T) {
+	jobURL := "https://www.energyjobline.com/job/no-employer-99999999"
+	detail := energyjoblineDetailHTML("Mystery Role", "", "desc", "2026-10-02", "Kent", "GB")
+	fake := (&routedHTTP{}).route("/job/no-employer-99999999", detail)
+
+	j, ok := energyjobline{http: fake}.detail(context.Background(),
+		CompanyEntry{Company: "EnergyJobline", Provider: "energyjobline"}, jobURL)
+	if !ok {
+		t.Fatal("detail returned ok=false, want an unreadableDetail stub")
+	}
+	if !j.Unreadable {
+		t.Error("Unreadable = false, want true (empty hiringOrganization)")
+	}
+	if j.Company != "EnergyJobline" {
+		t.Errorf("Company = %q, want the configured fallback EnergyJobline", j.Company)
+	}
+}
+
+func TestEnergyjoblineUnreadableDetailWhenNoJobPosting(t *testing.T) {
+	jobURL := "https://www.energyjobline.com/job/broken-page-11111111"
+	fake := (&routedHTTP{}).route("/job/broken-page-11111111", "<html><body>no ld+json here</body></html>")
+
+	j, ok := energyjobline{http: fake}.detail(context.Background(),
+		CompanyEntry{Company: "EnergyJobline", Provider: "energyjobline"}, jobURL)
+	if !ok {
+		t.Fatal("detail returned ok=false, want an unreadableDetail stub")
+	}
+	if !j.Unreadable {
+		t.Error("Unreadable = false, want true (no JobPosting block)")
+	}
+}
+
+// A posting can carry a JobPosting block with no jobLocation entries at all (the field is
+// an array in the markup, but nothing guarantees the site always populates it) — this must
+// not panic on an empty-slice index and should simply leave Location blank.
+func TestEnergyjoblineDetailWithNoJobLocation(t *testing.T) {
+	jobURL := "https://www.energyjobline.com/job/no-location-66666666"
+	html := `<html><head><script type="application/ld+json">` +
+		`{"@context":"https://schema.org/","@type":"JobPosting",` +
+		`"title":"Remote Role","hiringOrganization":{"@type":"Organization","name":"Real Co"},` +
+		`"description":"d","datePosted":"2026-10-02","jobLocation":[]}` +
+		`</script></head><body></body></html>`
+	fake := (&routedHTTP{}).route("/job/no-location-66666666", html)
+
+	j, ok := energyjobline{http: fake}.detail(context.Background(),
+		CompanyEntry{Company: "EnergyJobline", Provider: "energyjobline"}, jobURL)
+	if !ok {
+		t.Fatal("detail returned ok=false")
+	}
+	if j.Location != "" {
+		t.Errorf("Location = %q, want empty (no jobLocation entries)", j.Location)
+	}
+	if j.Company != "Real Co" {
+		t.Errorf("Company = %q, want Real Co", j.Company)
+	}
+}
+
+func TestEnergyjoblineJobID(t *testing.T) {
+	cases := map[string]string{
+		"https://www.energyjobline.com/job/controls-engineer-atlanta-31835232": "31835232",
+		"https://www.energyjobline.com/job/welder-kent-27543774/":              "27543774",
+		"https://www.energyjobline.com/":                                       "",
+		"https://www.energyjobline.com/jobs":                                   "",
+		"https://www.energyjobline.com/news-article/oil-and-gas/story":         "",
+		"https://www.energyjobline.com/company/energy-jobline-o-p":             "",
+	}
+	for u, want := range cases {
+		if got := energyjoblineJobID(u); got != want {
+			t.Errorf("energyjoblineJobID(%q) = %q, want %q", u, got, want)
+		}
+	}
+}
+
+func TestEnergyjoblineOneBadDetailDoesNotFailTheCrawl(t *testing.T) {
+	goodURL := "https://www.energyjobline.com/job/good-job-22222222"
+	badURL := "https://www.energyjobline.com/job/bad-job-33333333"
+	good := energyjoblineDetailHTML("Good Job", "Real Co", "d", "2026-10-02", "Kent", "GB")
+
+	fake := (&routedHTTP{}).
+		route("sitemap.xml?page=1", energyjoblineURLSetXML(goodURL, badURL)).
+		route("sitemap.xml", energyjoblineSitemapIndexXML("https://www.energyjobline.com/sitemap.xml?page=1")).
+		route("/job/good-job-22222222", good).
+		routeErr("/job/bad-job-33333333", errors.New("fetch failed"))
+
+	jobs, err := NewEnergyJobline(fake).Fetch(context.Background(), CompanyEntry{
+		Company: "EnergyJobline", Provider: "energyjobline",
+	})
+	if err != nil {
+		t.Fatalf("Fetch: %v", err)
+	}
+	// A plain transport error states nothing about the posting (it might be a timeout, a
+	// transient 5xx — anything short of a confirmed-gone answer), so it must not be
+	// mistaken for the posting having been removed: it survives as an Unreadable stub, the
+	// same contract fetchDetails documents and bayt.go/gulftalent.go already honour.
+	if len(jobs) != 2 {
+		t.Fatalf("got %d jobs, want 2 (the good posting plus an Unreadable stub for the one that failed to fetch)", len(jobs))
+	}
+	markers := unreadableMarkers(jobs)
+	if len(markers) != 1 || markers[0].ExternalID != "33333333" {
+		t.Fatalf("unreadable markers = %v, want one for the posting whose detail fetch errored", markers)
+	}
+	if markers[0].Company != "EnergyJobline" {
+		t.Errorf("marker Company = %q, want the entry's configured company", markers[0].Company)
+	}
+	for _, j := range jobs {
+		if j.ExternalID == "22222222" && j.Title != "Good Job" {
+			t.Errorf("good posting Title = %q, want Good Job", j.Title)
+		}
+	}
+}
+
+// The other half of the distinction (see bayt_test.go's TestBaytGoneDetailDropsThePosting):
+// a 404/410 is the platform's own answer that the posting is gone, so the crawl drops it
+// rather than marking it unreadable.
+func TestEnergyjoblineGoneDetailDropsThePosting(t *testing.T) {
+	goodURL := "https://www.energyjobline.com/job/good-job-44444444"
+	goneURL := "https://www.energyjobline.com/job/gone-job-55555555"
+	good := energyjoblineDetailHTML("Good Job", "Real Co", "d", "2026-10-02", "Kent", "GB")
+
+	fake := (&routedHTTP{}).
+		route("sitemap.xml?page=1", energyjoblineURLSetXML(goodURL, goneURL)).
+		route("sitemap.xml", energyjoblineSitemapIndexXML("https://www.energyjobline.com/sitemap.xml?page=1")).
+		route("/job/good-job-44444444", good).
+		routeErr("/job/gone-job-55555555", &StatusError{Method: "GET", Code: 404, URL: goneURL})
+
+	jobs, err := NewEnergyJobline(fake).Fetch(context.Background(), CompanyEntry{
+		Company: "EnergyJobline", Provider: "energyjobline",
+	})
+	if err != nil {
+		t.Fatalf("Fetch: %v", err)
+	}
+	if len(jobs) != 1 || jobs[0].ExternalID != "44444444" {
+		t.Fatalf("got %v, want only the posting whose detail answered — the 404'd one dropped, not marked", jobs)
+	}
+}
+
+func TestEnergyjoblineProviderAndBoardless(t *testing.T) {
+	s := NewEnergyJobline(nil)
+	if s.Provider() != "energyjobline" {
+		t.Errorf("Provider() = %q, want energyjobline", s.Provider())
+	}
+	if _, ok := s.(boardless); !ok {
+		t.Error("energyjobline must implement boardless")
+	}
+	if _, ok := s.(aggregator); !ok {
+		t.Error("energyjobline must implement aggregator")
+	}
+}
diff --git a/internal/ingest/sources/registry.go b/internal/ingest/sources/registry.go
index 019dff1ba..4e24bdb15 100644
--- a/internal/ingest/sources/registry.go
+++ b/internal/ingest/sources/registry.go
@@ -354,6 +354,7 @@ func All(c HTTPClient) map[string]Source {
 		// listing and detail pages are fully static server-rendered HTML.
 		NewStaffy(c),
 		NewDataArt(c),
+		NewEnergyJobline(c),
 		// JettyCloud: its postings exist only on its own careers site — the employer runs no
 		// ATS a crawl can reach, so this adapter is the only way the catalogue can carry it.
 		NewJettyCloud(c),
diff --git a/openspec/changes/energyjobline-ingest-adapter/.openspec.yaml b/openspec/changes/energyjobline-ingest-adapter/.openspec.yaml
new file mode 100644
index 000000000..a26662f7a
--- /dev/null
+++ b/openspec/changes/energyjobline-ingest-adapter/.openspec.yaml
@@ -0,0 +1,2 @@
+schema: spec-driven
+created: 2026-10-07
diff --git a/openspec/changes/energyjobline-ingest-adapter/design.md b/openspec/changes/energyjobline-ingest-adapter/design.md
new file mode 100644
index 000000000..349e33328
--- /dev/null
+++ b/openspec/changes/energyjobline-ingest-adapter/design.md
@@ -0,0 +1,100 @@
+## Context
+
+Full recon and the Rigzone feasibility spike live in
+`docs/superpowers/specs/2026-10-07-oilgas-job-portal-adapters-design.md`; this design
+covers only the part that ships: the `energyjobline` adapter.
+
+`https://www.energyjobline.com/sitemap.xml` is an open sitemap **index** of 4
+sub-sitemaps (confirmed via plain `curl` with a Googlebot UA — no bot defense observed). A
+live posting, `https://www.energyjobline.com/job/controls-engineer-atlanta-31835232`,
+server-renders three `<script type="application/ld+json">` blocks (`WebSite`,
+`Organization`, `JobPosting`) carrying `title`, `description`, `jobLocation`/`address`,
+`hiringOrganization`, `datePosted`, `employmentType`, `baseSalary`.
+
+The codebase already has two adapters shaped like this exactly:
+
+- `internal/ingest/sources/dataart.go` — sitemap enumeration → bounded-fanout detail
+  fetch → `ldJobPosting` decode, for a **single-company boardless** source.
+- `internal/ingest/sources/bayt.go` / `gulftalent.go` — a **boardless aggregator**:
+  `detail` reads the employer from the posting's own `hiringOrganization.name`
+  (`strings.TrimSpace(p.HiringOrg.Name)`), falling back to `unreadableDetail(id, link,
+  e.Company)` when that name is empty.
+
+EnergyJobline is the first case where both shapes apply at once: sitemap-enumerated (like
+DataArt) *and* a multi-employer aggregator (like Bayt/GulfTalent).
+
+## Goals / Non-Goals
+
+**Goals:**
+- Crawl every EnergyJobline posting via its sitemap index into the catalogue, filed under
+  each posting's real employer.
+- Reuse existing helpers/markers end to end (`sitemapJobLocs`/`resolveSubSitemap`,
+  `fetchDetails`, `defaultDetailWorkers`, `ldJobPosting`, `unreadableDetail`,
+  `boardless`/`aggregator`) — no new shared mechanism.
+
+**Non-Goals:**
+- Rigzone/Oilcareers, NaukriGulf, OilAndGasJobSearch, Laimoon — excluded per the linked
+  design doc; not touched by this change.
+- Any change to `CompanyEntry`, `Hub`/`Tenants`, or the `aggregator`/`boardless` interfaces
+  themselves.
+- A shared "sitemap-index aggregator" base type. Two adapters (Bayt/GulfTalent are
+  listing-paginated, not sitemap-enumerated) do not yet share enough shape to justify
+  extracting one; revisit if a third sitemap-enumerated aggregator shows up.
+
+## Decisions
+
+**Enumeration: sitemap index, not listing pagination.** Unlike Bayt (paginated
+per-country listings), EnergyJobline exposes a sitemap index. Use
+`resolveSubSitemap`/`getSitemap`'s existing index-vs-flat-urlset handling
+(`internal/ingest/sources/sitemap.go`) to walk the 4 sub-sitemaps and collect job URLs via
+a job-URL-shape extractor, the same contract `dataart.go` already uses with
+`sitemapJobLocs`.
+
+**Company resolution: `hiringOrganization.name` + `unreadableDetail` fallback, not a new
+Hub mechanism.** EnergyJobline's `JobPosting` already carries a clean per-posting employer
+name — the same situation Bayt/GulfTalent are in — so this copies their resolution
+exactly rather than inventing a `CompanyEntry.Hub`-based path (an earlier draft of the
+linked design doc proposed that; it was corrected once `bayt.go` was read directly).
+
+**Completeness marker: `aggregator()` only, not `fullBoardListing()`.** `fullBoardListing`
+is Bayt's promise that pagination was walked to a genuinely empty page — a pagination-specific
+guarantee. EnergyJobline's sitemap already lists every URL in one fetch per sub-sitemap, so
+there is no pagination-exhaustion question to prove; the sitemap fetch itself either
+succeeds (SHALL error the board on failure, matching Bayt's "first listing page" rule) or
+it does not.
+
+**Detail-fetch worker count: `defaultDetailWorkers` (8), not a throttled custom
+constant.** Bayt/GulfTalent reduced theirs because Akamai throttling was *observed live*.
+No equivalent throttling signal exists yet for EnergyJobline; inventing a lower constant
+without evidence would be speculative. Revisit with a real constant + comment if a crawl
+run shows throttling.
+
+## Risks / Trade-offs
+
+- **[Unknown job volume]** → the first manual run's job count/duration is checked before
+  the board is added via `cmd/add-board`, the same caution the SuccessFactors hub design
+  raised for an uncounted hub.
+- **[`hiringOrganization.name` has no curation step — a messy-but-present name still gets
+  stored]** → accepted, matching Bayt/GulfTalent's accepted risk for the same reason (it
+  is the only per-posting employer signal the site offers); watch the catalogue after
+  launch.
+- **[Sitemap structure could differ from `dataart.go`'s assumption]** → `getSitemap`
+  already decodes both `<urlset>` and `<sitemapindex>` shapes through one type, so this is
+  a parsing detail, not a design risk — confirmed directly against the live index before
+  implementation.
+
+## Migration Plan
+
+1. Ship the adapter + registry line + tests through normal code review (no schema/data
+   migration involved).
+2. After merge and a first manual run (`go run ./cmd/ingest energyjobline` or equivalent)
+   confirms a sane job count, add the live board via `cmd/add-board --provider=energyjobline
+   --board='www.energyjobline.com' --company='EnergyJobline' --apply` on the prod host.
+3. Rollback is removing the `registry.go` line and retiring the board
+   (`cmd/add-board --retire`) — no other system depends on this source.
+
+## Open Questions
+
+None outstanding — the one real unknown this batch had (Rigzone's bot defense) was
+resolved by the spike in the linked design doc (INVALIDATED, out of scope for this
+change).
diff --git a/openspec/changes/energyjobline-ingest-adapter/proposal.md b/openspec/changes/energyjobline-ingest-adapter/proposal.md
new file mode 100644
index 000000000..64a5ba510
--- /dev/null
+++ b/openspec/changes/energyjobline-ingest-adapter/proposal.md
@@ -0,0 +1,47 @@
+## Why
+
+Oil & gas is a vertical the business is actively growing (ChatGPT traffic, SEO on roles).
+A recent audit of ~40 oil & gas domains found most majors already covered or added, and
+most remaining job portals either already live (Bayt, GulfTalent), dead (Laimoon), or
+unreachable at the network level (NaukriGulf, OilAndGasJobSearch, and — per a live
+feasibility spike — Rigzone). EnergyJobline is the one portal left that is both reachable
+with plain HTTP and offers clean per-posting structured data, so it is the one worth
+building now. Full findings: `docs/superpowers/specs/2026-10-07-oilgas-job-portal-adapters-design.md`.
+
+## What Changes
+
+- Add a new `energyjobline` ingest source adapter
+  (`internal/ingest/sources/energyjobline.go`) that enumerates
+  `https://www.energyjobline.com/sitemap.xml` (a 4-entry sitemap index), fetches each
+  job-detail page, and parses its embedded schema.org `JobPosting` JSON-LD.
+- The adapter is a **boardless aggregator**: one crawl covers the whole site (no
+  per-tenant board id), and each posting's employer comes from the posting's own
+  `hiringOrganization.name` — the same pattern `bayt.go`/`gulftalent.go` already use, reusing
+  the existing `unreadableDetail` helper as the fallback when that name is empty.
+- Register `energyjobline` in `internal/ingest/sources/registry.go`'s `All()`.
+- After the code ships and a first manual run looks sane, add the live board via
+  `cmd/add-board --provider=energyjobline --board='www.energyjobline.com' --company='EnergyJobline' --apply`
+  on the prod host (a manual post-merge step, not part of this change's tests).
+
+## Capabilities
+
+### New Capabilities
+
+- `energyjobline-source`: crawls EnergyJobline's sitemap-enumerated job postings into the
+  catalogue, resolving each posting's employer from its own `JobPosting` JSON-LD as a
+  boardless, multi-company aggregator source.
+
+### Modified Capabilities
+
+(none — this adds a new adapter and does not change the behavior of any existing source,
+the `aggregator`/`boardless` marker interfaces, or `CompanyEntry`)
+
+## Impact
+
+- New file `internal/ingest/sources/energyjobline.go` (+ `energyjobline_test.go`).
+- One new line in `internal/ingest/sources/registry.go`'s `All()`.
+- One new `boards` row added via `cmd/add-board` post-merge (prod data change, not code).
+- No change to any existing adapter, to `CompanyEntry`, or to the `aggregator`/`boardless`
+  marker interfaces — this change only consumes them.
+- Out of scope: Rigzone/Oilcareers, NaukriGulf, OilAndGasJobSearch, Laimoon — see the
+  linked design doc's "Out of scope" section for why each is excluded from this change.
diff --git a/openspec/changes/energyjobline-ingest-adapter/specs/energyjobline-source/spec.md b/openspec/changes/energyjobline-ingest-adapter/specs/energyjobline-source/spec.md
new file mode 100644
index 000000000..bcb0294c8
--- /dev/null
+++ b/openspec/changes/energyjobline-ingest-adapter/specs/energyjobline-source/spec.md
@@ -0,0 +1,68 @@
+## ADDED Requirements
+
+### Requirement: EnergyJobline sitemap-enumerated crawl
+
+The system SHALL provide an `energyjobline` source adapter that enumerates
+`https://www.energyjobline.com/sitemap.xml` — a sitemap **index** of sub-sitemaps — to
+discover every job-detail URL, fetches each detail page, and parses the embedded
+schema.org `JobPosting` JSON-LD. The adapter is **boardless**: one crawl covers the whole
+site, with no per-tenant board id. The crawl is keyless (no API key).
+
+#### Scenario: Sitemap index yields every posting
+
+- **WHEN** the adapter crawls its single configured entry
+- **THEN** it resolves the sitemap index to its sub-sitemaps, collects every job-detail
+  URL across them, and returns one `Job` per URL whose detail page carries a parseable
+  `JobPosting`
+
+#### Scenario: A broken sitemap index errors the crawl
+
+- **WHEN** the top-level sitemap index cannot be fetched or decoded
+- **THEN** `Fetch` returns an error rather than an empty success, so a broken enumeration
+  is a loud signal and not silently treated as "zero jobs today"
+
+### Requirement: Self-contained aggregator company identity
+
+The adapter MUST read each posting's company from the JSON-LD `hiringOrganization.name`
+rather than a configured board company, because EnergyJobline is a multi-company
+aggregator where each posting carries its own employer — the same resolution `bayt.go`/
+`gulftalent.go` already use. The adapter is registered as an aggregator-marker source so
+its jobs are stored under their own company identity and included in the source facet.
+
+#### Scenario: Company comes from the posting
+
+- **WHEN** a detail page's `JobPosting` names a `hiringOrganization`
+- **THEN** that organization's `name` (trimmed) is the job's company
+
+#### Scenario: Posting without a resolvable employer is marked unreadable, not dropped
+
+- **WHEN** a detail page has no resolvable `hiringOrganization.name` (empty, or the
+  `JobPosting` block itself is missing/unparseable)
+- **THEN** the adapter returns an `unreadableDetail` stub for that posting (proving the
+  URL was reached) instead of a job with a guessed or blank company, and instead of
+  silently omitting it
+
+### Requirement: Stable dedup identity
+
+The adapter SHALL derive each job's `ExternalID` from the stable identifier in the
+job-detail URL, so re-crawling the same sitemap dedups to the same catalogue row.
+
+#### Scenario: Re-crawl dedups
+
+- **WHEN** the same posting URL is seen on a later crawl
+- **THEN** it maps to the same `ExternalID` and updates the existing row rather than
+  creating a duplicate; a URL with no extractable id is skipped during enumeration rather
+  than ingested with an empty key
+
+### Requirement: Resilient per-posting parsing
+
+The adapter SHALL fetch job-detail pages through the shared bounded-fan-out helper
+(`fetchDetails`/`defaultDetailWorkers`), isolating a single detail-page failure from the
+rest of the crawl: one unreachable or malformed posting must not abort an otherwise
+healthy run.
+
+#### Scenario: One bad detail page does not fail the crawl
+
+- **WHEN** one job-detail URL fails to fetch or carries no parseable `JobPosting`
+- **THEN** the adapter emits an `unreadableDetail` stub for that one posting and still
+  returns the successfully parsed postings from the rest of the crawl
diff --git a/openspec/changes/energyjobline-ingest-adapter/tasks.md b/openspec/changes/energyjobline-ingest-adapter/tasks.md
new file mode 100644
index 000000000..a018b10a2
--- /dev/null
+++ b/openspec/changes/energyjobline-ingest-adapter/tasks.md
@@ -0,0 +1,53 @@
+## 1. Sitemap enumeration
+
+- [x] 1.1 Write a failing test: given a fixture sitemap-index XML (the top-level
+      `https://www.energyjobline.com/sitemap.xml` shape) and fixture sub-sitemaps, the
+      adapter's enumeration step returns every job-detail URL across all sub-sitemaps.
+- [x] 1.2 Implement the job-URL extractor (matches the `.../job/<slug>-<id>` shape) and
+      wire it through the existing `getSitemap`/sub-sitemap walk so it handles the index
+      shape (reuse, do not reimplement).
+- [x] 1.3 Write a failing test: a sitemap index that fails to fetch/decode makes `Fetch`
+      return an error (not an empty success).
+- [x] 1.4 Implement that error path.
+
+## 2. Per-posting detail parsing
+
+- [x] 2.1 Write a failing test: a fixture job-detail page with `WebSite`, `Organization`,
+      and `JobPosting` ld+json blocks (in that order, matching the live page) decodes to a
+      `Job` with the `JobPosting`'s title/description/location/datePosted — proving
+      `ldJobPosting` is actually wired to skip the non-`JobPosting` blocks for this
+      adapter's own posting struct.
+- [x] 2.2 Implement the posting struct and `detail` function.
+- [x] 2.3 Write a failing test: `hiringOrganization.name` present and non-empty becomes
+      the job's `Company`.
+- [x] 2.4 Implement that resolution.
+- [x] 2.5 Write a failing test: `hiringOrganization.name` empty or the `JobPosting` block
+      missing entirely both yield an `unreadableDetail` stub (not a dropped posting, not a
+      guessed company).
+- [x] 2.6 Implement that fallback.
+- [x] 2.7 Write a failing test: `ExternalID` comes from the job-detail URL and a second
+      fetch of the same URL maps to the same `ExternalID`.
+- [x] 2.8 Implement that id extraction.
+
+## 3. Markers, transport, and registration
+
+- [x] 3.1 Add `boardless()` and `aggregator()` marker methods to the adapter type.
+- [x] 3.2 Wire the adapter through `fetchDetails`/`defaultDetailWorkers` for the detail
+      fan-out (one failing/passing test proving one bad detail page does not fail the
+      whole crawl, per spec).
+- [x] 3.3 Register `energyjobline` in `internal/ingest/sources/registry.go`'s `All()`
+      alongside `dataart` (plain shared client, no fingerprint transport needed).
+
+## 4. Quality pass and review
+
+- [x] 4.1 Run `simplify` over the new/changed files.
+- [x] 4.2 Re-run `go test ./internal/ingest/sources/...` and confirm green.
+- [x] 4.3 Request code review (`requesting-code-review`); address Critical/Important
+      feedback.
+
+## 5. Post-merge (manual, not part of the tests)
+
+- [ ] 5.1 After merge, run a manual crawl of `energyjobline` and sanity-check the job
+      count/duration (see design.md's volume risk).
+- [ ] 5.2 Add the live board on the prod host: `cmd/add-board --provider=energyjobline
+      --board='www.energyjobline.com' --company='EnergyJobline' --apply`.
diff --git a/web/src/lib/generated/contracts.ts b/web/src/lib/generated/contracts.ts
index 738c03102..5a17e9773 100644
--- a/web/src/lib/generated/contracts.ts
+++ b/web/src/lib/generated/contracts.ts
@@ -1495,7 +1495,7 @@ export interface CatalogueMember {
   has_photo: boolean;
 }
 
-export const SOURCE_VALUES = ['telegram', 'workatastartup', 'remoteok', 'arc', '4dayweek', 'adp', 'adpmyjobs', 'adzuna', 'aijobs', 'applicantpro', 'applitrack', 'arbeitnow', 'arbeitsagentur', 'ashby', 'ashbygraphql', 'avature', 'bamboohr', 'bayt', 'betterteam', 'breezy', 'briefhq', 'bullhorn', 'careerplug', 'careerspage', 'catsone', 'cleverstaff', 'clinch', 'comeet', 'compleo', 'cornerstone', 'crelate', 'cryptocurrencyjobs', 'dayforce', 'deel', 'djinni', 'dover', 'earcu', 'echojobs', 'edjoin', 'eightfold', 'enlizt', 'epam', 'erecruiter', 'eures', 'factorial', 'freshteam', 'functionalworks', 'geekhunter', 'geekjob', 'gem', 'getmanfred', 'getmatch', 'getonbrd', 'getro', 'gr8people', 'greenhouse', 'gulftalent', 'gupy', 'gusto', 'habr_career', 'hackernews', 'herp', 'hh', 'hibob', 'himalayas', 'hireology', 'hiringthing', 'hrmdirect', 'hrmos', 'humanbit', 'huntflow', 'hurma', 'icims', 'infojobs', 'inhire', 'instaffo', 'ismartrecruit', 'isolvedhire', 'itechart', 'japandev', 'jazzhr', 'jibe', 'jobappnetwork', 'jobdanmark', 'jobicy', 'jobleads', 'jobnet', 'jobscore', 'jobspresso', 'jobstash', 'jobstreet', 'jobtech', 'jobvite', 'jobylon', 'join', 'joppy', 'keka', 'landingjobs', 'lever', 'likeit', 'loxo', 'luxoft', 'manatal', 'mindsight', 'mycareersfuture', 'neogov', 'nodesk', 'nofluffjobs', 'northstone', 'odoo', 'opencats', 'oracle', 'pageup', 'paycom', 'paycor', 'paylocity', 'peopleforce', 'personio', 'phenom', 'pinpoint', 'powertofly', 'profession', 'pyjamahr', 'quickin', 'radancy', 'rapyd', 'recruitee', 'recruiterflow', 'recruitingsolutions', 'recrutei', 'reed', 'remotedotcom', 'remotive', 'remotli', 'rippling', 'scalis', 'schoolspring', 'seek', 'selfrecruit', 'senior', 'smartrecruiters', 'softgarden', 'solides', 'solidjobs', 'spark', 'speedrun', 'startupandvc', 'successfactors', 'talentadore', 'talenthr', 'talentlyft', 'taleo', 'teamex', 'teamtailor', 'techtree', 'tecla', 'thehub', 'themuse', 'topco', 'traffit', 'trakstar', 'trudvsem', 'tyomarkkinatori', 'ukg', 'ukgready', 'usajobs', 'vagas', 'vention', 'vouch', 'wantapply', 'wellfound', 'werecruit', 'weworkremotely', 'whatjobs', 'whatjobs-ae', 'whatjobs-ar', 'whatjobs-at', 'whatjobs-au', 'whatjobs-be', 'whatjobs-bh', 'whatjobs-br', 'whatjobs-ca', 'whatjobs-ch', 'whatjobs-cl', 'whatjobs-co', 'whatjobs-de', 'whatjobs-dk', 'whatjobs-eg', 'whatjobs-es', 'whatjobs-fi', 'whatjobs-fr', 'whatjobs-gr', 'whatjobs-hk', 'whatjobs-hu', 'whatjobs-id', 'whatjobs-ie', 'whatjobs-in', 'whatjobs-it', 'whatjobs-ke', 'whatjobs-kw', 'whatjobs-lu', 'whatjobs-mx', 'whatjobs-my', 'whatjobs-nl', 'whatjobs-no', 'whatjobs-nz', 'whatjobs-om', 'whatjobs-pe', 'whatjobs-ph', 'whatjobs-pk', 'whatjobs-pl', 'whatjobs-pt', 'whatjobs-py', 'whatjobs-qa', 'whatjobs-sa', 'whatjobs-se', 'whatjobs-sg', 'whatjobs-sv', 'whatjobs-th', 'whatjobs-tr', 'whatjobs-uk', 'whatjobs-ve', 'whatjobs-vn', 'whatjobs-za', 'workable', 'workablemarketplace', 'workday', 'workingnomads', 'workstream', 'wpyoast', 'zohorecruit'] as const;
+export const SOURCE_VALUES = ['telegram', 'workatastartup', 'remoteok', 'arc', '4dayweek', 'adp', 'adpmyjobs', 'adzuna', 'aijobs', 'applicantpro', 'applitrack', 'arbeitnow', 'arbeitsagentur', 'ashby', 'ashbygraphql', 'avature', 'bamboohr', 'bayt', 'betterteam', 'breezy', 'briefhq', 'bullhorn', 'careerplug', 'careerspage', 'catsone', 'cleverstaff', 'clinch', 'comeet', 'compleo', 'cornerstone', 'crelate', 'cryptocurrencyjobs', 'dayforce', 'deel', 'djinni', 'dover', 'earcu', 'echojobs', 'edjoin', 'eightfold', 'energyjobline', 'enlizt', 'epam', 'erecruiter', 'eures', 'factorial', 'freshteam', 'functionalworks', 'geekhunter', 'geekjob', 'gem', 'getmanfred', 'getmatch', 'getonbrd', 'getro', 'gr8people', 'greenhouse', 'gulftalent', 'gupy', 'gusto', 'habr_career', 'hackernews', 'herp', 'hh', 'hibob', 'himalayas', 'hireology', 'hiringthing', 'hrmdirect', 'hrmos', 'humanbit', 'huntflow', 'hurma', 'icims', 'infojobs', 'inhire', 'instaffo', 'ismartrecruit', 'isolvedhire', 'itechart', 'japandev', 'jazzhr', 'jibe', 'jobappnetwork', 'jobdanmark', 'jobicy', 'jobleads', 'jobnet', 'jobscore', 'jobspresso', 'jobstash', 'jobstreet', 'jobtech', 'jobvite', 'jobylon', 'join', 'joppy', 'keka', 'landingjobs', 'lever', 'likeit', 'loxo', 'luxoft', 'manatal', 'mindsight', 'mycareersfuture', 'neogov', 'nodesk', 'nofluffjobs', 'northstone', 'odoo', 'opencats', 'oracle', 'pageup', 'paycom', 'paycor', 'paylocity', 'peopleforce', 'personio', 'phenom', 'pinpoint', 'powertofly', 'profession', 'pyjamahr', 'quickin', 'radancy', 'rapyd', 'recruitee', 'recruiterflow', 'recruitingsolutions', 'recrutei', 'reed', 'remotedotcom', 'remotive', 'remotli', 'rippling', 'scalis', 'schoolspring', 'seek', 'selfrecruit', 'senior', 'smartrecruiters', 'softgarden', 'solides', 'solidjobs', 'spark', 'speedrun', 'startupandvc', 'successfactors', 'talentadore', 'talenthr', 'talentlyft', 'taleo', 'teamex', 'teamtailor', 'techtree', 'tecla', 'thehub', 'themuse', 'topco', 'traffit', 'trakstar', 'trudvsem', 'tyomarkkinatori', 'ukg', 'ukgready', 'usajobs', 'vagas', 'vention', 'vouch', 'wantapply', 'wellfound', 'werecruit', 'weworkremotely', 'whatjobs', 'whatjobs-ae', 'whatjobs-ar', 'whatjobs-at', 'whatjobs-au', 'whatjobs-be', 'whatjobs-bh', 'whatjobs-br', 'whatjobs-ca', 'whatjobs-ch', 'whatjobs-cl', 'whatjobs-co', 'whatjobs-de', 'whatjobs-dk', 'whatjobs-eg', 'whatjobs-es', 'whatjobs-fi', 'whatjobs-fr', 'whatjobs-gr', 'whatjobs-hk', 'whatjobs-hu', 'whatjobs-id', 'whatjobs-ie', 'whatjobs-in', 'whatjobs-it', 'whatjobs-ke', 'whatjobs-kw', 'whatjobs-lu', 'whatjobs-mx', 'whatjobs-my', 'whatjobs-nl', 'whatjobs-no', 'whatjobs-nz', 'whatjobs-om', 'whatjobs-pe', 'whatjobs-ph', 'whatjobs-pk', 'whatjobs-pl', 'whatjobs-pt', 'whatjobs-py', 'whatjobs-qa', 'whatjobs-sa', 'whatjobs-se', 'whatjobs-sg', 'whatjobs-sv', 'whatjobs-th', 'whatjobs-tr', 'whatjobs-uk', 'whatjobs-ve', 'whatjobs-vn', 'whatjobs-za', 'workable', 'workablemarketplace', 'workday', 'workingnomads', 'workstream', 'wpyoast', 'zohorecruit'] as const;
 export type Source = (typeof SOURCE_VALUES)[number];
 export const STAGE_VALUES = ['preparing', 'applied', 'screening', 'responded', 'interview', 'offer', 'accepted', 'rejected', 'withdrawn', 'expired'] as const;
 export type Stage = (typeof STAGE_VALUES)[number];