/* screens-enrichment.jsx - provider-agnostic data enrichment (simulated).
The model is TWO layers: a BASE data provider (person/company/firmographics/hiring signals off a bulk
dataset) feeding a CONTACT WATERFALL (email/phone, tried in order, first hit wins), plus a region-specific
COMPLIANCE path that stays off until its lawful basis is verified. The UI names the LAYER, not the vendor -
the seeded lineup in D.enrichProviders is a configurable default, not a commitment.
Enriching candidate PII is a first-order compliance problem, so a run checks consent/suppression per
candidate (window.candidateEnrichConsent) and SKIPS anyone suppressed or opted-out, saying so out loud.
R108 T3 (real write path + provenance precedence): confirming a suggestion (hub review queue, per-panel
suggested updates, bulk) now dispatches the SHARED store.js apply-field executor via window.enrichApplyField
- the value lands on the record row through E8Store.set, persists across reload, and is undoable (a toast
with Undo; the bulk confirm composes ONE undo). A candidate confirm also stamps candidateMeta.fieldProv
(source = provider) WITHOUT touching R106 freshness. Precedence (window.enrichPrecedence): enrichment fills
blanks / re-enriches its own guesses freely, but a candidate-verified or recruiter-entered field is HELD as
a conflict needing an explicit "Override with vendor value" vs "Keep current". useEnrichActed now only
tracks which rows have left the queue (confirmed/dismissed dedupe) - the value write is a real store op. */
const DSenr = window.Stand8DesignSystem_b5c975;
/* Layer presentation: label, one-line role, an icon + a semantic tone. Data lives in D.enrichProviders. */
const ENR_LAYER_META = {
base: { n: 'Layer 1', label: 'Base data provider', tone: 'info', icon: 'dataset',
desc: 'Resolves the person, company, firmographics and hiring signals off a bulk dataset.' },
waterfall: { n: 'Layer 2', label: 'Contact waterfall', tone: 'accent', icon: 'call_split',
desc: 'Finds email and phone - tried in order, first hit wins across sub-providers.' },
compliance: { n: '', label: 'Compliance / EMEA path', tone: 'warning', icon: 'gavel',
desc: 'A region-specific path, off by default until its lawful basis is verified.' },
};
/* The demo cohort for the candidate run - two allowed, two blocked (one opted-out, one suppressed) so the
consent gate is visible. Names are display labels; consent is resolved live from candidateMeta. */
const ENR_CAND_COHORT = [
{ id: 'c-okafor', name: 'Daniel Okafor', role: 'Sr. Software Engineer' },
{ id: 'c-patel', name: 'Aisha Patel', role: 'Backend Engineer' },
{ id: 'c-silva', name: 'Beatriz Silva', role: 'Data Engineer' },
{ id: 'c-marsh', name: 'Felix Marsh', role: 'Business Analyst' },
];
/* Which suggestions have left the queue - persisted so a confirmed/dismissed row does not reappear on
reload. The VALUE write is now a real store op (window.enrichApplyField); this tracks only queue dedupe:
markConfirmed/unmarkConfirmed (paired with the apply/undo) and dismiss. */
function enrichReadActed() {
try { return JSON.parse(localStorage.getItem('e8-enrich-acted-v1')) || { confirmed: [], dismissed: [] }; }
catch (e) { return { confirmed: [], dismissed: [] }; }
}
function useEnrichActed() {
const [acted, setActed] = React.useState(enrichReadActed);
const write = (next) => { try { localStorage.setItem('e8-enrich-acted-v1', JSON.stringify(next)); } catch (e) {} return next; };
const markConfirmed = (ids) => setActed((prev) => {
const set = prev.confirmed.slice();
ids.forEach((id) => { if (set.indexOf(id) < 0) set.push(id); });
return write({ confirmed: set, dismissed: prev.dismissed });
});
const unmarkConfirmed = (ids) => setActed((prev) => write({ confirmed: prev.confirmed.filter((id) => ids.indexOf(id) < 0), dismissed: prev.dismissed }));
const dismiss = (id) => setActed((prev) => (prev.dismissed.indexOf(id) >= 0 ? prev : write({ confirmed: prev.confirmed, dismissed: prev.dismissed.concat([id]) })));
return { acted, markConfirmed, unmarkConfirmed, dismiss };
}
/* Relative "verified 3 days ago" for the conflict provenance line (screens-core's e8AgoLabel is module-
local, so a small local one keeps this file self-contained). */
function enrAgo(ts) {
if (ts == null) return 'earlier';
const d = Math.max(0, Math.round((Date.now() - ts) / 864e5));
if (d <= 0) return 'today';
if (d === 1) return 'yesterday';
if (d < 30) return d + ' days ago';
const mo = Math.round(d / 30);
return mo + (mo === 1 ? ' month ago' : ' months ago');
}
/* One suggestion object -> the apply-field target (candidate rows carry candId so the write also stamps
fieldProv). Queue rows use newVal; the client dossier's suggested entries use value. */
function enrichTarget(s) {
return { coll: s.coll, targetId: s.targetId, field: s.fieldKey, value: (s.newVal != null ? s.newVal : s.value), provider: s.provider, candId: s.candId };
}
/* A candidate suggestion whose field is candidate-verified or recruiter-entered is HELD - never applied on
a plain confirm; it needs an explicit override. Blank / enrichment-owned fields (and every non-candidate
row) apply freely. */
function enrichIsHeld(s) {
if (!s.candId || !window.enrichPrecedence) return false;
const p = window.enrichPrecedence(s.candId, s.fieldKey);
return p === 'candidate' || p === 'human';
}
/* A candidate-targeted suggestion whose candidate is suppressed or opted-out must NEVER receive vendor
data - the record-level consent gate (window.candidateEnrichConsent, T2) applies to the review queue and
the confirm path too, not just the hub bulk RUN. Non-candidate rows (client / contact firmographic) are
unaffected. */
function enrichConsentBlocked(s) {
if (!s.candId || !window.candidateEnrichConsent) return false;
return !window.candidateEnrichConsent(s.candId).allowed;
}
/* Confirm one suggestion for real: dispatch apply-field (persist + undo), hide the row, raise an Undo toast
that composes the value revert with un-hiding the row. ctx = { markConfirmed, unmarkConfirmed, showToast }.
A suppressed / opted-out candidate row is blocked before any write. */
function enrichConfirmOne(s, label, ctx) {
if (enrichConsentBlocked(s)) return;
const res = window.enrichApplyField(enrichTarget(s));
ctx.markConfirmed([s.id]);
if (ctx.showToast) ctx.showToast(label, 'Undo', () => { res.undo(); ctx.unmarkConfirmed([s.id]); });
}
/* Bulk confirm: apply each, hide all, compose ONE Undo that reverts every write and un-hides every row.
Suppressed / opted-out candidate rows are dropped from the set so no vendor value lands on them. */
function enrichConfirmMany(list, ctx) {
const eligible = list.filter((s) => !enrichConsentBlocked(s));
if (!eligible.length) return;
const undos = eligible.map((s) => window.enrichApplyField(enrichTarget(s)));
const ids = eligible.map((s) => s.id);
ctx.markConfirmed(ids);
if (ctx.showToast) ctx.showToast(eligible.length + ' updates applied to records', 'Undo', () => { undos.forEach((u) => u.undo()); ctx.unmarkConfirmed(ids); });
}
/* A small provider-agnostic mark for the panel headers (replaces the old vendor letter-mark). */
function EnrichMark() {
return auto_awesome;
}
/* The contact-waterfall chain: providers tried in order, stops at the first hit. */
function EnrichWaterfall({ label, waterfall, value }) {
return (
{label ? {label} : null}
{waterfall.map((s, i) => (
{i > 0 ? {'->'} : null}
{s.provider}{s.hit ? ' ' + (value || 'found') : ''}
))}
);
}
function EnrichProvChip({ provider }) { return via {provider}; }
function EnrichFieldRow({ f }) {
return (
{f.label}
{f.value}
{f.confidence}
);
}
/* Compact per-record readout: the enabled providers backing this record + an estimated cost + the honest,
always-visible vendor-reported caveat. `layers` picks which layers apply (a client dossier is base-only;
a contact/candidate uses base + the contact waterfall). Reads the global enabled set (window.enrichLayer). */
function EnrichCostReadout({ layers }) {
const names = (layer) => window.enrichLayer(layer).map((p) => p.name);
const cost = (layer) => window.enrichLayer(layer).reduce((a, p) => a + (p.costPerRecord || 0), 0);
const base = names('base');
const wf = layers.indexOf('waterfall') >= 0 ? names('waterfall') : [];
// First-hit-wins: a typical record pays the base scan + the first waterfall step, not every step.
const wfFirst = window.enrichLayer('waterfall')[0];
const est = cost('base') + (layers.indexOf('waterfall') >= 0 && wfFirst ? (wfFirst.costPerRecord || 0) : 0);
return (
Base data
{base.join(', ') || 'none enabled'}
{layers.indexOf('waterfall') >= 0 ? (
Contact waterfall
{wf.join(' -> ') || 'none enabled'}
) : null}
Est. cost
~{est} credits/record
Coverage and cost figures are vendor-reported, not independently audited.
);
}
/* ---- A: company / account intelligence on the client dossier (base layer) ---- */
function EnrichDossierCard({ clientId }) {
const D = window.E8DATA;
const data = (D.enrichClients || {})[clientId];
const { showToast } = React.useContext(E8Ctx);
const { acted, markConfirmed, unmarkConfirmed, dismiss } = useEnrichActed();
const ctx = { markConfirmed, unmarkConfirmed, showToast };
const [running, setRunning] = React.useState(false);
if (!data) {
return (
);
}
const enrich = () => { setRunning(true); setTimeout(() => { setRunning(false); if (showToast) showToast('Enrichment run - ' + data.firmographics.length + ' fields refreshed'); }, 1100); };
const intentTone = (t) => t === 'surging' ? 'var(--ui-success-text)' : t === 'rising' ? 'var(--ui-warning-text)' : 'var(--ui-text-tertiary)';
const suggested = (data.suggested || []).filter((s) => acted.confirmed.indexOf(s.id) < 0 && acted.dismissed.indexOf(s.id) < 0);
return (
Enrichment
Last run {data.lastRun} · {(D.enrichCredits.total - D.enrichCredits.used).toLocaleString()} credits left
{running ? 'Enriching…' : 'Run enrichment'}
Firmographics · base data provider
{data.firmographics.map((f) => )}
Tech stack
Buying-intent signals
{data.intent.map((s) => (
{s.topic}
{s.trend}
))}
{suggested.length ? (
Suggested updates · confirm to save
{suggested.map((s) => (
{s.field}: {s.value} · via {s.provider} · {s.confidence}% confidence
dismiss(s.id)}>Dismiss
enrichConfirmOne(s, s.field + ' saved to the record', ctx)}>Confirm
))}
) : null}
);
}
/* ---- B: contact / buyer enrichment on the contact record (base + contact waterfall) ---- */
function EnrichContactPanel({ contactId }) {
const D = window.E8DATA;
const c = (D.enrichContacts || {})[contactId];
const { showToast } = React.useContext(E8Ctx);
const [running, setRunning] = React.useState(false);
if (!c) {
return (
);
}
const enrich = () => { setRunning(true); setTimeout(() => { setRunning(false); if (showToast) showToast('Found a direct dial + work email'); }, 1100); };
return (
Enrichment
{running ? 'Enriching…' : 'Enrich'}
Direct dial{c.directDial.value}{c.directDial.confidence}
Seniority{c.seniority}
Buying role{c.buyingRole}
);
}
/* ---- B2: candidate enrichment on the candidate record (base + contact waterfall, consent-gated) ---- */
function EnrichCandidatePanel({ candidateId }) {
const D = window.E8DATA;
const c = (D.enrichCandidates || {})[candidateId];
const { showToast } = React.useContext(E8Ctx);
const [running, setRunning] = React.useState(false);
const consent = (window.candidateEnrichConsent ? window.candidateEnrichConsent(candidateId) : { allowed: true, state: 'allowed', reason: '' });
// Consent gate at the record level: a suppressed / opted-out candidate is never enriched.
if (!consent.allowed) {
return (
Enrichment
{consent.state === 'suppressed' ? 'Suppressed' : 'Opted out'}
block
Enrichment skipped
{consent.reason}. No provider is called for this candidate.
);
}
if (!c) {
return (
);
}
const enrich = () => { setRunning(true); setTimeout(() => { setRunning(false); if (showToast) showToast('Found a personal email + mobile'); }, 1100); };
return (
Enrichment
{running ? 'Enriching…' : 'Enrich'}
Mobile{c.mobile.value}{c.mobile.confidence}
Current role{c.currentRole}
Inferred skills
);
}
/* ---- Hub: the two-layer provider stack + enable/disable config (hub-local state; T3 seam to a store op) ---- */
function EnrichProviderStack({ providers, onToggle }) {
return (
Layers name the job, not the vendor. Toggle a provider to preview the configured stack. Coverage figures are vendor-reported.
{['base', 'waterfall', 'compliance'].map((layer) => {
const meta = ENR_LAYER_META[layer];
const rows = providers.filter((p) => p.layer === layer);
const on = rows.filter((p) => p.enabled).length;
let wfOrder = 0;
return (
{meta.icon}
{meta.n ? meta.n + ' - ' : ''}{meta.label}
{meta.desc}
{on} of {rows.length} on
{rows.map((p) => {
if (layer === 'waterfall' && p.enabled) wfOrder += 1;
return (
{layer === 'waterfall' && p.enabled ? {wfOrder} : null}
{p.name}
{p.region && p.region !== 'Global' ? {p.region} : null}
{p.role}
{p.coverage ? p.coverage + ' · ' : ''}{p.coverageNote}
{p.costPerRecord} credits/rec
onToggle(p.id)} aria-label={(p.enabled ? 'Disable ' : 'Enable ') + p.name} />
);
})}
);
})}
);
}
/* ---- Hub: compliance posture (honest + factual, no scare copy) ---- */
function EnrichCompliancePosture({ providers }) {
const D = window.E8DATA;
const meta = D.candidateMeta || {};
let suppressed = 0, optedOut = 0;
Object.keys(meta).forEach((id) => { const m = meta[id] || {}; if (m.suppressed) suppressed += 1; else if (m.consent === false) optedOut += 1; });
const posture = [
{ k: 'Opt-out honored', icon: 'verified_user', v: 'Suppressed and opted-out candidates are skipped before any provider is called - never silently dropped.' },
{ k: 'Suppression / DSAR', icon: 'block', v: (suppressed + optedOut) + ' on the suppression list (' + suppressed + ' suppressed, ' + optedOut + ' opted out). An erasure request holds the record from processing.' },
{ k: 'Coverage figures', icon: 'info', v: 'Vendor-reported, not independently audited. At 1M scale all move to negotiated enterprise contracts.' },
];
return (
{posture.map((r) => (
{r.icon}
{r.k}
{r.v}
))}
Lawful basis per provider
{providers.map((p) => {
const refuted = String(p.lawfulBasis || '').indexOf('Refuted') >= 0;
return (
{p.name}
{p.lawfulBasis}
{refuted ? 'Refuted' : 'Unverified'}
);
})}
Candidate contact enrichment
{cohort.length} candidates in this cohort · consent is checked before any provider is called.
{running ? 'Running…' : 'Run enrichment'}
{result ? {result.enriched.length} enriched : null}
{result ? (
{result.skipped.length ? (
{result.skipped.length} skipped - opted out or suppressed
{result.skipped.map((s) => (
block
{s.c.name}
{s.g.reason}
{s.g.state === 'suppressed' ? 'Suppressed' : 'Opted out'}
))}
) :
No candidates skipped - all had a lawful basis on record.
}
) : null}
);
}
/* ---- One review-queue row. A candidate row is classified live by provenance precedence: a candidate-
verified or recruiter-entered field is HELD (both values + provenance shown, explicit override vs keep);
a blank / enrichment-owned field (and every non-candidate row) confirms straight to the record. ---- */
function EnrichQueueItem({ q, ctx, onDismiss }) {
const D = window.E8DATA;
const isCand = !!q.candId;
// Consent gate on the review queue: a candidate-targeted row whose candidate is suppressed / opted-out is
// blocked here exactly as the per-record panel is - no Confirm, no vendor value written. Reuses the T2
// window.candidateEnrichConsent helper + the per-record panel's .e8-enr-blocked styling.
const consent = isCand && window.candidateEnrichConsent ? window.candidateEnrichConsent(q.candId) : { allowed: true, state: 'allowed', reason: '' };
if (isCand && !consent.allowed) {
const suppressed = consent.state === 'suppressed';
return (
{q.record}
block
{q.field} not enriched · {suppressed ? 'suppressed' : 'opted out'}
{consent.reason}. No provider value is written to this candidate.
{suppressed ? 'Suppressed' : 'Opted out'}
);
}
const prof = isCand ? (D.matches || []).find((m) => m.id === q.candId) : null;
const curVal = isCand ? (prof ? prof[q.fieldKey] : q.oldVal) : q.oldVal;
const held = enrichIsHeld(q);
if (held) {
const prec = window.enrichPrecedence(q.candId, q.fieldKey);
const prov = (((D.candidateMeta || {})[q.candId] || {}).fieldProv || {})[q.fieldKey] || {};
const isCandOwned = prec === 'candidate';
const who = isCandOwned ? 'The candidate verified this' : 'A recruiter entered this';
return (
shield_person
{q.record}
{q.field}
{isCandOwned ? 'Candidate verified' : 'Recruiter entered'}
{who} {enrAgo(prov.verifiedAt)} - {q.provider} disagrees. Held for an explicit override.
Current{isCandOwned ? ' · candidate' : ' · recruiter'}
{String(curVal == null || curVal === '' ? '-' : curVal)}
arrow_forward
{q.provider} · {q.confidence}%
{q.newVal}
onDismiss(q.id)}>Keep current
enrichConfirmOne(q, 'Overrode ' + q.record + ' ' + q.field + ' with the vendor value', ctx)}>Override with vendor value
);
}
return (
{q.record}
{q.field} {String(curVal == null || curVal === '' ? '-' : curVal)} {q.newVal}
{q.confidence}%
onDismiss(q.id)}>Dismiss
enrichConfirmOne(q, q.record + ' ' + q.field + ' saved to the record', ctx)}>Confirm
);
}
/* ---- C: the central enrichment hub ---- */
function EnrichHubScreen() {
const D = window.E8DATA;
const { showToast } = React.useContext(E8Ctx);
const { acted, markConfirmed, unmarkConfirmed, dismiss } = useEnrichActed();
const ctx = { markConfirmed, unmarkConfirmed, showToast };
// Provider config = hub-local state seeded from D.enrichProviders. Toggling previews the configured stack;
// T3 can promote this to a replayable store op so it persists across reload.
const [providers, setProviders] = React.useState(() => (D.enrichProviders || []).map((p) => ({ ...p })));
// Toggle a provider. The toast is raised from the EVENT HANDLER (not inside the setProviders updater,
// which React runs during render) so it never triggers a setState-in-render on App.
const toggleProvider = (id) => {
const cur = providers.find((p) => p.id === id);
if (!cur) return;
const willEnable = !cur.enabled;
setProviders((prev) => prev.map((p) => (p.id === id ? { ...p, enabled: !p.enabled } : p)));
if (showToast) showToast(cur.name + (willEnable ? ' enabled' : ' disabled') + ' for the ' + ENR_LAYER_META[cur.layer].label.toLowerCase());
};
const credits = D.enrichCredits;
const left = credits.total - credits.used;
const queue = (D.enrichQueue || []).filter((q) => acted.confirmed.indexOf(q.id) < 0 && acted.dismissed.indexOf(q.id) < 0);
return (
showToast && showToast('Full run history')}>Export usage} />
Enrichment
Provider-agnostic data enrichment · {queue.length} updates to review
Credits this month
{credits.used.toLocaleString()} of {credits.total.toLocaleString()} used
Resets {credits.resets} · ~{left.toLocaleString()} enrichments left
{queue.length === 0 ?
: (
{queue.map((q) =>
)}
enrichConfirmMany(queue.filter((q) => q.confidence >= 80 && !enrichIsHeld(q) && !enrichConsentBlocked(q)), ctx)}>Confirm all high-confidence
{queue.some((q) => enrichIsHeld(q)) ? Fields a candidate verified or a recruiter entered are held for an explicit override, not bulk-applied. : null}
);
}
Object.assign(window, { EnrichDossierCard, EnrichContactPanel, EnrichCandidatePanel, EnrichHubScreen, EnrichWaterfall });