shakers-cli-beta 0.12.0 → 0.14.0

package/src/onboarding-flow.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { NOOP_FUNNEL, sourceTypeFor, weeklyHours, rateTypes, workSituationValue } = require('./onboarding-funnel');
+
 const FREELANCE_TYPES = ['FREELANCE', 'EMPLOYEE', 'AGENCY', 'POTENTIAL_FREELANCE'];
 const CURRENCIES = ['USD', 'EUR', 'GBP'];
 const PRICE_MIN = 0;
@@ -669,12 +671,33 @@ function interviewDisclaimers(lang) {
   return { infoAccessed: c.interviewInfoAccessed, goalDuration: c.interviewGoalDuration };
 }
 
+function trackImport(funnel, attempted, importRes, durationMs) {
+  const bySource = new Map();
+  const report = importRes.ok && importRes.report ? importRes.report.sources : [];
+  for (const src of report) bySource.set(sourceTypeFor(src.source), src);
+  const connected = [];
+  for (const type of attempted) {
+    const src = bySource.get(type);
+    const ok = importRes.ok && (!src || src.status === 'imported');
+    if (ok) {
+      connected.push(type);
+      funnel.track('source_import_completed', 'import_sources', { source_type: type, duration_ms: durationMs });
+    } else {
+      funnel.track('source_import_failed', 'import_sources', { source_type: type, duration_ms: durationMs, failure_reason: (src && src.code) || importRes.reason });
+    }
+  }
+  return connected;
+}
+
 // Blocking orchestrator used by the CLI (`bin/onboarding.js`).
-async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrowser, onAuthUrl, openProfile } = {}) {
+async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrowser, onAuthUrl, openProfile, funnel = NOOP_FUNNEL } = {}) {
   const { getCatalog } = require('./i18n');
   const c = getCatalog(io.lang).onboarding;
 
+  funnel.begin();
+  funnel.completed('start');
   io.section(c.signupTitle);
+  funnel.viewed('account_creation');
 
   if (method === 'google' || method === 'linkedin') {
     // The provider supplies name/email; freelanceType is derived later from work situation.
@@ -688,6 +711,8 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
       io.error(c.signupError);
       return { ok: false, reason: reg.reason, step: 'signup' };
     }
+    funnel.completed('account_creation', { auth_method: method, is_returning_account: reg.kind === 'account-already-exists' });
+    funnel.identified();
     if (reg.kind === 'account-already-exists') {
       // Existing account: already signed in — stop, no wizard re-run.
       io.warn(c.accountExists);
@@ -713,6 +738,8 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
       io.warn(c.accountExists);
       const logged = await io.login(account.email);
       if (!logged) return { ok: false, reason: 'login-failed', step: 'signup' };
+      funnel.completed('account_creation', { auth_method: 'email', is_returning_account: true });
+      funnel.identified();
       return { ok: true, alreadyRegistered: true };
     }
     const sess = await establishSessionFromCredentials(deps, { email: account.email, password: account.password });
@@ -720,12 +747,19 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
       io.error(c.sessionError);
       return { ok: false, reason: sess.reason, step: 'signup' };
     }
+    funnel.completed('account_creation', { auth_method: 'email', is_returning_account: false });
+    funnel.identified();
     notifyOk(io, c.accountReady);
   }
 
   io.section(c.title);
+  funnel.viewed('import_sources');
   const linkedinUrl = (await io.ask(c.askLinkedin) || '').trim();
-  if (!linkedinUrl) return { ok: false, reason: 'no-linkedin', step: 'import' };
+  if (!linkedinUrl) {
+    funnel.errored('import_sources', 'no-linkedin', { error_field: 'linkedin' });
+    funnel.flush();
+    return { ok: false, reason: 'no-linkedin', step: 'import' };
+  }
   const cvPath = (await io.ask(c.askCv) || '').trim();
   const githubUrl = (await io.ask(c.askGithub) || '').trim();
   const websiteUrl = (await io.ask(c.askWebsite) || '').trim();
@@ -733,45 +767,95 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
   // The hub import is SYNCHRONOUS (the POST returns once it finishes), so show the
   // loader AROUND that wait, then the real outcome. No background job to poll.
   const withProgress = typeof io.withProgress === 'function' ? io.withProgress : (_l, task) => task();
+  const attempted = [linkedinUrl && 'linkedin', cvPath && 'cv', githubUrl && 'github', websiteUrl && 'web_page'].filter(Boolean);
+  for (const type of attempted) funnel.track('source_import_started', 'import_sources', { source_type: type });
+  const importStartedAt = Date.now();
   const importRes = await withProgress(c.importChecking, () =>
     startProfileImport(deps, { linkedinUrl, cvPath, githubUrl, websiteUrl, language: io.lang }));
+  const connected = trackImport(funnel, attempted, importRes, Date.now() - importStartedAt);
+  funnel.completed('import_sources', { sources_attempted: attempted, sources_connected: connected, sources_connected_count: connected.length });
+  funnel.flush();
   if (importRes.ok) notifyOk(io, c.importDone);
   else io.warn(c.importUnavailable);
 
+  // Steps 4-8 are saved out of funnel order: sent together once all are answered.
   io.section(c.professionalTitle);
+  funnel.viewed('work_situation');
   const workSituationInput = await io.askWorkSituation(c);
   const workSituationRes = await saveWorkSituation(deps, workSituationInput);
-  if (!workSituationRes.ok) return { ok: false, reason: workSituationRes.reason, step: 'work-situation' };
+  if (!workSituationRes.ok) {
+    funnel.errored('work_situation', workSituationRes.reason);
+    funnel.flush();
+    return { ok: false, reason: workSituationRes.reason, step: 'work-situation' };
+  }
+  funnel.completed('work_situation', { work_situation: workSituationValue(String(workSituationInput.situation || '').trim().toUpperCase()) });
   notifyOk(io, c.professionalSaved);
 
   io.section(c.pricingTitle);
+  funnel.viewed('rates');
   const pricingInput = await io.askPricing(c);
   const priceRes = await savePricing(deps, pricingInput);
-  if (!priceRes.ok) return { ok: false, reason: priceRes.reason, step: 'pricing' };
+  if (!priceRes.ok) {
+    funnel.errored('rates', priceRes.reason);
+    funnel.flush();
+    return { ok: false, reason: priceRes.reason, step: 'pricing' };
+  }
+  const selectedRates = rateTypes(pricingInput);
+  funnel.completed('rates', {
+    rate_types_selected: selectedRates,
+    rate_type: selectedRates[0],
+    rate_currency: normalizeCurrency(pricingInput.partTimeSelected === true ? pricingInput.partTimeCurrency : pricingInput.fullTimeCurrency) || undefined,
+  });
   notifyOk(io, c.pricingSaved);
 
   // Optional/skippable and fail-soft: a decline or a failed write never aborts the alta.
   io.section(c.availabilityTitle);
+  funnel.viewed('availability');
   if (await io.confirm(c.availabilityAsk)) {
     const availabilityInput = await io.askAvailability(c);
     const availRes = await saveAvailability(deps, availabilityInput);
-    if (availRes.ok) notifyOk(io, c.availabilitySaved); else io.warn(c.availabilityUnavailable);
+    if (availRes.ok) {
+      funnel.completed('availability', { availability_hours_per_week: weeklyHours(normalizeMonthlyHours(availabilityInput.monthlyHours)) });
+      const country = normalizeCountry(availabilityInput.country);
+      const modes = Array.isArray(availabilityInput.workModes) ? availabilityInput.workModes.map((m) => String(m).trim().toUpperCase()) : [];
+      funnel.completed('location', {
+        location_country: country ? country.toLowerCase() : undefined,
+        location_method: 'manual',
+        is_remote_only: modes.length ? modes.every((m) => m === 'REMOTE') : undefined,
+      });
+      notifyOk(io, c.availabilitySaved);
+    } else {
+      funnel.errored('availability', availRes.reason);
+      io.warn(c.availabilityUnavailable);
+    }
     if (availabilityInput.telephoneCode || availabilityInput.telephoneNumber) {
       const phoneRes = await savePhone(deps, availabilityInput);
       if (phoneRes.ok) notifyOk(io, c.phoneSaved); else io.warn(c.phoneUnavailable);
     }
   } else {
+    funnel.skipped('availability');
+    funnel.skipped('location');
     io.notify(c.availabilitySkipped);
   }
 
   io.section(c.languagesTitle);
+  funnel.viewed('languages');
   if (await io.confirm(c.languagesAsk)) {
     const languageRows = await io.askLanguages(c);
     const langRes = await saveLanguages(deps, languageRows);
-    if (langRes.ok) notifyOk(io, c.languagesSaved); else io.warn(c.languagesUnavailable);
+    if (langRes.ok) {
+      const codes = validateLanguageRows(languageRows).rows.map((r) => r.language);
+      funnel.completed('languages', { languages_count: codes.length, languages: codes });
+      notifyOk(io, c.languagesSaved);
+    } else {
+      funnel.errored('languages', langRes.reason);
+      io.warn(c.languagesUnavailable);
+    }
   } else {
+    funnel.skipped('languages');
     io.notify(c.languagesSkipped);
   }
+  funnel.flush();
 
   const prior = await detectPriorUsage(deps);
   let didUsage = false;
@@ -811,24 +895,36 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
     return url;
   };
 
+  const mainRole = async () => {
+    const role = await runMainRoleFinalStep(io, deps);
+    if (role && role.ok && role.chosen) funnel.completed('supercluster', { supercluster: role.chosen });
+    else if (role && role.ok) funnel.skipped('supercluster');
+    funnel.flush();
+  };
+
   io.section(c.interviewTitle);
+  funnel.viewed('pre_interview');
   io.disclaimer(c.interviewInfoAccessed, c.interviewGoalDuration);
   if (!(await io.confirm(c.interviewAccept))) {
-    await runMainRoleFinalStep(io, deps);
+    funnel.completed('pre_interview', { interview_choice: 'skip' });
+    await mainRole();
     const fin = await finalize();
     const url = showProfile();
     return { ok: true, completed: 'skipped-interview', didUsage, profileUrl: url, finalized: fin.ok, registration: fin };
   }
+  funnel.completed('pre_interview', { interview_choice: 'start_now' });
 
-  const interview = await conductLivekitInterview(io, deps);
+  const interview = await conductLivekitInterview(io, deps, { funnel });
   if (!interview.ok) {
-    await runMainRoleFinalStep(io, deps);
+    funnel.errored('interview', interview.reason);
+    await mainRole();
     const fin = await finalize();
     const url = showProfile();
     return { ok: true, completed: 'interview-unavailable', reason: interview.reason, didUsage, profileUrl: url, finalized: fin.ok, registration: fin };
   }
+  funnel.completed('interview', { interview_mode: 'text' });
   notifyOk(io, c.interviewComplete);
-  await runMainRoleFinalStep(io, deps);
+  await mainRole();
   const fin = await finalize();
   const url = showProfile();
   return { ok: true, completed: 'interview', didUsage, profileUrl: url, finalized: fin.ok, registration: fin };
@@ -860,7 +956,7 @@ function livekitTurnBridge(client, transcript) {
 }
 
 // The onboarding/dimension interview over LiveKit text transport. LiveKit Node SDK is an optional lazily-required dep; a `livekit-not-installed` connect prints a hint, not a stack trace. Persists the transcript on session end even when interrupted; a failed PATCH warns, never crashes.
-async function conductLivekitInterview(io, deps, { interviewId = null, language = null, plain = false } = {}) {
+async function conductLivekitInterview(io, deps, { interviewId = null, language = null, plain = false, funnel = null } = {}) {
   const { getCatalog } = require('./i18n');
   const c = getCatalog(io.lang).onboarding;
   const { TranscriptBuffer } = require('./interview-transcript');
@@ -870,6 +966,7 @@ async function conductLivekitInterview(io, deps, { interviewId = null, language
     ? await startLivekitForInterview(deps, { interviewId, language: language || io.lang })
     : await createAndStartLivekitOnboarding(deps, { language: language || io.lang });
   if (!start.ok) return { ok: false, reason: start.reason, step: start.step || 'interview' };
+  if (funnel) funnel.viewed('interview', { interview_mode: 'text' });
 
   const closing = start.closingMessage;
   const isClosing = closing ? (t) => typeof t === 'string' && t.includes(closing) : null;
@@ -920,8 +1017,10 @@ async function runMainRoleFinalStep(io, deps, session = null) {
   const catalog = getCatalog(io.lang);
   try {
     const rolesDeps = typeof deps.makeRolesDeps === 'function' ? deps.makeRolesDeps() : undefined;
-    await deps.runMainRoleStep({ io, session: active, catalog, deps: rolesDeps });
-  } catch { /* the alta stands even if the role step fails */ }
+    return await deps.runMainRoleStep({ io, session: active, catalog, deps: rolesDeps });
+  } catch {
+    return null;
+  }
 }
 
 // Overwrite-repeat: PATCH /interviews/onboarding/restart. Per contract the Bearer is

package/src/onboarding-funnel.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { getConfigDir } = require('./config-dir');
+
+// Names and values mirror works-frontend onboarding-funnel-enums.ts.
+
+const FLOW_VERSION = 'signup_new_works_v1';
+
+const STEP_INDEX = Object.freeze({
+  start: 1,
+  account_creation: 2,
+  import_sources: 3,
+  work_situation: 4,
+  availability: 5,
+  rates: 6,
+  languages: 7,
+  location: 8,
+  profile_summary: 9,
+  pre_interview: 10,
+  interview: 11,
+  supercluster: 12,
+});
+
+const EVENT_TYPES = Object.freeze([
+  'onboarding_step_viewed',
+  'onboarding_step_completed',
+  'onboarding_step_skipped',
+  'onboarding_step_errored',
+  'onboarding_step_exited',
+  'source_import_started',
+  'source_import_completed',
+  'source_import_failed',
+]);
+
+const SURFACES = Object.freeze(['cli', 'mcp']);
+const MCP_CLIENTS = Object.freeze(['claude', 'chatgpt', 'cursor', 'other']);
+const SOURCE_TYPES = Object.freeze(['linkedin', 'cv', 'github', 'web_page']);
+const ERROR_TYPES = Object.freeze(['validation', 'server', 'timeout', 'auth', 'import']);
+
+const WORK_SITUATION_VALUES = Object.freeze({
+  FREELANCE: 'freelance',
+  EMPLOYED: 'employed',
+  BETWEEN_JOBS: 'between-jobs',
+  STUDYING: 'studying',
+  OTHER: 'other',
+});
+
+const ONCE_PER_STEP = new Set(['onboarding_step_viewed', 'onboarding_step_completed']);
+const MAX_EVENTS_PER_REQUEST = 50;
+const SEND_TIMEOUT_MS = 3000;
+const DEVICE_FILE_NAME = 'analytics-device.json';
+
+function mcpClientFor(clientName) {
+  const name = typeof clientName === 'string' ? clientName.toLowerCase() : '';
+  if (name.includes('claude')) return 'claude';
+  if (name.includes('chatgpt') || name.includes('openai')) return 'chatgpt';
+  if (name.includes('cursor')) return 'cursor';
+  return 'other';
+}
+
+function sourceTypeFor(source) {
+  if (source === 'linkedin' || source === 'cv' || source === 'github') return source;
+  return 'web_page';
+}
+
+function workSituationValue(code) {
+  return WORK_SITUATION_VALUES[code] || null;
+}
+
+// Same ÷4 as the web; '> 160' has no number.
+function weeklyHours(monthlyHours) {
+  const n = Number(monthlyHours);
+  return monthlyHours != null && monthlyHours !== '' && Number.isFinite(n) ? Math.round(n / 4) : null;
+}
+
+// As on the web: part-time project price is hourly, full-time is annual.
+function rateTypes({ partTimeSelected, fullTimeSelected } = {}) {
+  return [partTimeSelected === true && 'hourly', fullTimeSelected === true && 'annual'].filter(Boolean);
+}
+
+function errorTypeFor(reason) {
+  const r = String(reason || '');
+  if (r === 'no-session' || r === 'no-hub-token' || r === 'http-401' || r === 'http-403') return 'auth';
+  if (r === 'timeout') return 'timeout';
+  if (r === 'no-endpoint') return 'server';
+  if (r.startsWith('bad-') || r.startsWith('no-') || r === 'duplicate-language' || r === 'unresolved-languages') return 'validation';
+  return 'server';
+}
+
+function cleanProperties(properties) {
+  const ok = (v) => typeof v === 'string' || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v))
+    || (Array.isArray(v) && v.every((x) => typeof x === 'string'));
+  return Object.fromEntries(Object.entries(properties || {}).filter(([, v]) => ok(v)));
+}
+
+function deviceFilePath(env) {
+  return path.join(getConfigDir(env), DEVICE_FILE_NAME);
+}
+
+function loadOrCreateDeviceId(env = process.env, { fs: fsImpl = fs } = {}) {
+  const target = deviceFilePath(env);
+  try {
+    const parsed = JSON.parse(fsImpl.readFileSync(target, 'utf8'));
+    if (parsed && typeof parsed.deviceId === 'string' && parsed.deviceId) return parsed.deviceId;
+  } catch { /* create one */ }
+  const deviceId = crypto.randomUUID();
+  const dir = path.dirname(target);
+  const tmp = path.join(dir, `.${DEVICE_FILE_NAME}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  let fd = null;
+  try {
+    fsImpl.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fd = fsImpl.openSync(tmp, 'wx', 0o600);
+    fsImpl.writeFileSync(fd, `${JSON.stringify({ deviceId }, null, 2)}\n`);
+    try { fsImpl.fsyncSync(fd); } catch { /* e.g. EINVAL on some filesystems */ }
+    fsImpl.closeSync(fd);
+    fd = null;
+    fsImpl.renameSync(tmp, target);
+    return deviceId;
+  } catch {
+    if (fd !== null) { try { fsImpl.closeSync(fd); } catch { /* already closed */ } }
+    try { fsImpl.unlinkSync(tmp); } catch { /* never existed */ }
+    return null;
+  }
+}
+
+async function defaultSend({ endpoint, events, hubAccessToken }) {
+  const { postJsonWithTimeout } = require('./backend-request');
+  const res = await postJsonWithTimeout(endpoint, { events }, SEND_TIMEOUT_MS, 'POST', null, { Authorization: `Bearer ${hubAccessToken}` });
+  return { ok: res.status >= 200 && res.status < 300, status: res.status };
+}
+
+function defaultHubToken() {
+  const { loadAuthSession, sessionStatus } = require('./auth-session-store');
+  const session = loadAuthSession();
+  return sessionStatus(session) === 'active' && session && session.hubAccessToken ? session.hubAccessToken : null;
+}
+
+function createFunnel({
+  surface,
+  hubToken = defaultHubToken,
+  deviceId = () => loadOrCreateDeviceId(),
+  endpoint = () => require('./config').getOnboardingEventsEndpoint(),
+  send = defaultSend,
+  now = () => Date.now(),
+  uuid = () => crypto.randomUUID(),
+} = {}) {
+  if (!SURFACES.includes(surface)) throw new Error(`unknown funnel surface: ${surface}`);
+  let pending = [];
+  let lastTime = 0;
+  let seq = 0;
+  let ready = false;
+  let account = null;
+  let active = false;
+  let mcpClient = null;
+  let cachedDeviceId;
+  const seen = new Set();
+  const inflight = new Set();
+
+  function track(eventType, stepName, properties = {}) {
+    if (!active || !EVENT_TYPES.includes(eventType) || !STEP_INDEX[stepName]) return false;
+    if (ONCE_PER_STEP.has(eventType)) {
+      const key = `${eventType}:${stepName}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+    }
+    const common = { step_name: stepName, step_index: STEP_INDEX[stepName], flow_version: FLOW_VERSION, surface };
+    if (surface === 'mcp') common.mcp_client = mcpClient || 'other';
+    pending.push({ eventType, insertId: uuid(), at: now(), seq: seq++, properties: { ...cleanProperties(properties), ...common } });
+    return true;
+  }
+
+  // Funnel order, each time strictly after the previous one sent.
+  function stamp(batch) {
+    const ordered = [...batch].sort((a, b) => a.properties.step_index - b.properties.step_index || a.seq - b.seq);
+    const id = cachedDeviceId === undefined ? (cachedDeviceId = safe(deviceId)) : cachedDeviceId;
+    return ordered.map((e) => {
+      lastTime = Math.max(e.at, lastTime + 1);
+      return { event_type: e.eventType, insert_id: e.insertId, time: lastTime, ...(id ? { device_id: id } : {}), properties: e.properties };
+    });
+  }
+
+  function flush() {
+    if (!ready || !pending.length) return Promise.resolve();
+    const token = safe(hubToken);
+    const url = safe(endpoint);
+    // Never send under another account signed in since.
+    if (!token || !url || accountOf(token) !== account) return Promise.resolve();
+    const events = stamp(pending);
+    pending = [];
+    const sends = [];
+    for (let i = 0; i < events.length; i += MAX_EVENTS_PER_REQUEST) {
+      sends.push(Promise.resolve().then(() => send({ endpoint: url, events: events.slice(i, i + MAX_EVENTS_PER_REQUEST), hubAccessToken: token })).catch(() => null));
+    }
+    const done = Promise.all(sends).then(() => undefined, () => undefined);
+    inflight.add(done);
+    done.then(() => inflight.delete(done));
+    return done;
+  }
+
+  return {
+    surface,
+    begin() {
+      seen.clear();
+      active = true;
+    },
+    get active() { return active; },
+    setMcpClient(clientName) { mcpClient = mcpClientFor(clientName); },
+    track,
+    viewed: (step, props) => track('onboarding_step_viewed', step, props),
+    completed: (step, props) => track('onboarding_step_completed', step, props),
+    skipped: (step, props) => track('onboarding_step_skipped', step, props),
+    errored: (step, reason, props = {}) => track('onboarding_step_errored', step, { error_type: errorTypeFor(reason), ...props }),
+    identified() {
+      const token = safe(hubToken);
+      if (!token) return Promise.resolve();
+      account = accountOf(token);
+      ready = true;
+      return flush();
+    },
+    flush,
+    idle: () => Promise.all([...inflight]).then(() => undefined),
+  };
+}
+
+// A refreshed token keeps the same account.
+function accountOf(token) {
+  const payload = require('./auth-session-store').decodeJwtPayload(token);
+  return (payload && (payload.sub || payload.email)) || token;
+}
+
+function safe(fn) {
+  try { return fn(); } catch { return null; }
+}
+
+const NOOP_FUNNEL = Object.freeze({
+  surface: null,
+  begin() {},
+  active: false,
+  setMcpClient() {},
+  track: () => false,
+  viewed: () => false,
+  completed: () => false,
+  skipped: () => false,
+  errored: () => false,
+  identified: () => Promise.resolve(),
+  flush: () => Promise.resolve(),
+  idle: () => Promise.resolve(),
+});
+
+module.exports = {
+  FLOW_VERSION,
+  STEP_INDEX,
+  EVENT_TYPES,
+  SURFACES,
+  MCP_CLIENTS,
+  SOURCE_TYPES,
+  ERROR_TYPES,
+  MAX_EVENTS_PER_REQUEST,
+  DEVICE_FILE_NAME,
+  NOOP_FUNNEL,
+  createFunnel,
+  mcpClientFor,
+  sourceTypeFor,
+  workSituationValue,
+  weeklyHours,
+  rateTypes,
+  errorTypeFor,
+  loadOrCreateDeviceId,
+};

package/src/profile-client.js

@@ -113,10 +113,21 @@ async function fetchLanguages(deps = {}, { hubAccessToken, timeoutMs = DEFAULT_T
   });
 }
 
+// `works/users/me` -> the stored phone, null when hub has none.
+async function fetchTelephone(deps = {}, { hubAccessToken, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const getEndpoint = deps.getUserMeEndpoint || require('./config').getUserMeEndpoint;
+  const req = deps.getMapped || getMapped;
+  return req(getEndpoint(), hubAccessToken, timeoutMs, (d) => {
+    const t = d && d.telephone;
+    return { telephone: t && str(t.code) && str(t.number) ? { code: str(t.code), number: str(t.number) } : null };
+  });
+}
+
 module.exports = {
   requestAiProfile,
   fetchAiProfile,
   fetchMeProfile,
   fetchTalentMeProfile,
   fetchLanguages,
+  fetchTelephone,
 };

package/src/share.js

@@ -2,7 +2,7 @@
 
 const crypto = require('crypto');
 
-const { getIngestEndpoint, isTalentProfile } = require('./config');
+const { getIngestEndpoint } = require('./config');
 const { requestBackend } = require('./backend-request');
 const { recordBackendAcceptance } = require('./report-store');
 const {
@@ -53,8 +53,9 @@ async function autoShare(report, maturity, { root, bypassThrottle = false } = {}
   if (!state.email) {
     return { ok: false, skipped: true, reason: 'no-email' };
   }
-  // ADR-006: never SEND under an email whose ownership wasn't proven.
-  if (state.emailVerified === false && isTalentProfile()) {
+  // ADR-006: never SEND under an email whose ownership wasn't proven — every
+  // profile, `external` included (legal requirement), must have verified.
+  if (state.emailVerified === false) {
     return { ok: false, skipped: true, reason: 'email-unverified' };
   }
   if (!bypassThrottle && isThrottled(state)) {