shakers-cli-beta 0.13.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/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)) {

package/src/signup-copy.js

@@ -52,6 +52,16 @@ function joinParts(parts) {
   return parts.filter((p) => p !== null && p !== undefined && String(p).trim() !== '').join(' · ');
 }
 
+function countryName(lang, code) {
+  if (typeof code !== 'string' || !/^[A-Za-z]{2}$/.test(code.trim())) return null;
+  const upper = code.trim().toUpperCase();
+  try {
+    return new Intl.DisplayNames([LOCALES[toSignupLanguage(lang) || 'en']], { type: 'region' }).of(upper) || upper;
+  } catch {
+    return upper;
+  }
+}
+
 function amount(lang, value) {
   return new Intl.NumberFormat(LOCALES[lang], { maximumFractionDigits: 0 }).format(Number(value));
 }
@@ -95,11 +105,21 @@ const COPY = {
     existingNo: 'No, déjalo como está',
     existingKept: 'Perfecto, dejo tu perfil como está.',
     keptLabels: { workSituation: 'Situación laboral', availability: 'Disponibilidad', languages: 'Idiomas', phone: 'Teléfono' },
+    situationLabels: { FREELANCE: 'Freelance', EMPLOYED: 'Empleado/a', BETWEEN_JOBS: 'Entre proyectos', STUDYING: 'Estudiando', OTHER: 'Otro' },
+    participationLabels: { FULL_TIME: 'jornada completa', PART_TIME: 'media jornada' },
     existingUnchanged: (items) => `Estos datos de tu perfil no los he cambiado, se quedan como estaban: ${items.join(' · ')}. Si quieres otros valores, cámbialos en la web.`,
     aiUsageQuestion: '¿Quieres que analice cómo trabajas con IA? Es opcional y tarda 1-2 min. Solo veo qué herramientas usas, tu código y tus prompts no salen de tu máquina. Miro el uso de IA de todo este equipo, que doy por tuyo. Te ayuda a destacar en proyectos de IA.',
     aiUsageYes: 'Sí, analízalo',
     aiUsageSkip: 'Saltar este paso',
     aiUsageSkipped: "Sin problema, seguimos sin él. Te aviso de que es lo que más pesa para que te lleguen proyectos: lo puedes lanzar cuando quieras diciéndome 'analiza mi uso de IA'.",
+    consent: {
+      yes: 'Sí, adelante',
+      no: 'No',
+      cvSearch: 'Shakers buscará en este ordenador archivos que puedan ser tu CV: mira los nombres de los archivos PDF y Word de tus carpetas Escritorio, Documentos, Descargas e iCloud Drive, y lee tu zona horaria y el nombre, el email y el usuario de GitHub que guardan tus herramientas de programación. No abre esos archivos y no envía nada. ¿Continuamos?',
+      cvRead: (file) => `Shakers leerá el archivo ${file} para preparar el borrador de tu perfil. Todavía no se envía nada. ¿Continuamos?`,
+      cvSend: (file) => `Shakers enviará el archivo ${file} a tu cuenta de Shakers para completar tu perfil. ¿Continuamos?`,
+      project: (p) => `Shakers añadirá el proyecto de la carpeta ${p.folder} a tu portfolio y enviará ${listOf('es', [`el nombre "${p.name}"`, p.url && `la dirección web ${p.url}`, p.startDate && p.endDate ? `las fechas del ${p.startDate} al ${p.endDate}` : (p.startDate || p.endDate) && `la fecha ${p.startDate || p.endDate}`, p.client && `el cliente ${p.client}`, p.description && 'la descripción que acordaste'].filter(Boolean))}. ¿Continuamos?`,
+    },
     importSources: { linkedin: 'tu LinkedIn', cv: 'tu CV', github: 'tu GitHub', web: 'tu web' },
     importFailed: (names) => `No he podido importar ${names.join(' y ')} ahora mismo. El resto de tu perfil está guardado; lo que falte lo puedes añadir en la web.`,
     interviewWhereQuestion: '¿Hacemos la entrevista de onboarding aquí ahora o luego en la web?',
@@ -169,11 +189,21 @@ const COPY = {
     existingNo: 'No, leave it as it is',
     existingKept: 'Sure, I am leaving your profile as it is.',
     keptLabels: { workSituation: 'Work situation', availability: 'Availability', languages: 'Languages', phone: 'Phone' },
+    situationLabels: { FREELANCE: 'Freelance', EMPLOYED: 'Employed', BETWEEN_JOBS: 'Between jobs', STUDYING: 'Studying', OTHER: 'Other' },
+    participationLabels: { FULL_TIME: 'full-time', PART_TIME: 'part-time' },
     existingUnchanged: (items) => `I did not change these details of your profile; they stay as they were: ${items.join(' · ')}. If you want other values, change them on the web.`,
     aiUsageQuestion: 'Do you want me to analyse how you work with AI? It is optional and takes 1-2 min. I only see which tools you use; your code and your prompts do not leave your machine. I look at the AI usage across this whole machine, which I take to be yours. It helps you stand out for AI projects.',
     aiUsageYes: 'Yes, analyse it',
     aiUsageSkip: 'Skip this step',
     aiUsageSkipped: "No problem, we carry on without it. Heads-up: it is what weighs most for projects to reach you. You can run it whenever you like by telling me 'analyse my AI usage'.",
+    consent: {
+      yes: 'Yes, go ahead',
+      no: 'No',
+      cvSearch: 'Shakers will look on this computer for files that may be your CV: it lists the names of the PDF and Word files in your Desktop, Documents, Downloads and iCloud Drive folders, and reads your time zone and the name, email and GitHub user saved by your coding tools. It does not open those files and nothing is sent. Continue?',
+      cvRead: (file) => `Shakers will read the file ${file} to prepare your profile draft. Nothing is sent yet. Continue?`,
+      cvSend: (file) => `Shakers will send the file ${file} to your Shakers account to fill in your profile. Continue?`,
+      project: (p) => `Shakers will add the project in the folder ${p.folder} to your portfolio and send ${listOf('en', [`the name "${p.name}"`, p.url && `the web address ${p.url}`, p.startDate && p.endDate ? `the dates ${p.startDate} to ${p.endDate}` : (p.startDate || p.endDate) && `the date ${p.startDate || p.endDate}`, p.client && `the client ${p.client}`, p.description && 'the description you agreed on'].filter(Boolean))}. Continue?`,
+    },
     importSources: { linkedin: 'your LinkedIn', cv: 'your CV', github: 'your GitHub', web: 'your website' },
     importFailed: (names) => `I couldn't import ${names.join(' and ')} right now. The rest of your profile is saved; you can add what is missing on the web.`,
     interviewWhereQuestion: 'Shall we do the onboarding interview here now or later on the web?',
@@ -243,11 +273,21 @@ const COPY = {
     existingNo: 'No, lascialo così',
     existingKept: 'Perfetto, lascio il tuo profilo così com’è.',
     keptLabels: { workSituation: 'Situazione lavorativa', availability: 'Disponibilità', languages: 'Lingue', phone: 'Telefono' },
+    situationLabels: { FREELANCE: 'Freelance', EMPLOYED: 'Dipendente', BETWEEN_JOBS: "Tra un lavoro e l'altro", STUDYING: 'Studente', OTHER: 'Altro' },
+    participationLabels: { FULL_TIME: 'tempo pieno', PART_TIME: 'part-time' },
     existingUnchanged: (items) => `Questi dati del tuo profilo non li ho cambiati, restano com'erano: ${items.join(' · ')}. Se vuoi altri valori, cambiali sul sito.`,
     aiUsageQuestion: "Vuoi che analizzi come lavori con l'IA? È facoltativo e richiede 1-2 min. Vedo solo quali strumenti usi, il tuo codice e i tuoi prompt non escono dalla tua macchina. Guardo l'uso dell'IA su tutto questo computer, che considero tuo. Ti aiuta a distinguerti nei progetti di IA.",
     aiUsageYes: 'Sì, analizzalo',
     aiUsageSkip: 'Salta questo passaggio',
     aiUsageSkipped: "Nessun problema, andiamo avanti senza. Ti avviso che è ciò che pesa di più perché ti arrivino progetti: puoi lanciarlo quando vuoi dicendomi 'analizza il mio uso dell'IA'.",
+    consent: {
+      yes: 'Sì, procedi',
+      no: 'No',
+      cvSearch: "Shakers cercherà su questo computer i file che potrebbero essere il tuo CV: guarda i nomi dei file PDF e Word nelle cartelle Scrivania, Documenti, Download e iCloud Drive, e legge il tuo fuso orario e il nome, l'email e l'utente GitHub salvati dai tuoi strumenti di programmazione. Non apre quei file e non invia nulla. Continuiamo?",
+      cvRead: (file) => `Shakers leggerà il file ${file} per preparare la bozza del tuo profilo. Per ora non viene inviato nulla. Continuiamo?`,
+      cvSend: (file) => `Shakers invierà il file ${file} al tuo account Shakers per completare il tuo profilo. Continuiamo?`,
+      project: (p) => `Shakers aggiungerà il progetto della cartella ${p.folder} al tuo portfolio e invierà ${listOf('it', [`il nome "${p.name}"`, p.url && `l'indirizzo web ${p.url}`, p.startDate && p.endDate ? `le date dal ${p.startDate} al ${p.endDate}` : (p.startDate || p.endDate) && `la data ${p.startDate || p.endDate}`, p.client && `il cliente ${p.client}`, p.description && 'la descrizione che hai concordato'].filter(Boolean))}. Continuiamo?`,
+    },
     importSources: { linkedin: 'il tuo LinkedIn', cv: 'il tuo CV', github: 'il tuo GitHub', web: 'il tuo sito' },
     importFailed: (names) => `Non sono riuscito a importare ${names.join(' e ')} in questo momento. Il resto del tuo profilo è salvato; quello che manca puoi aggiungerlo sul sito.`,
     interviewWhereQuestion: 'Facciamo il colloquio di onboarding qui adesso o più tardi sul sito?',
@@ -317,11 +357,21 @@ const COPY = {
     existingNo: 'Não, deixe como está',
     existingKept: 'Perfeito, deixo o seu perfil como está.',
     keptLabels: { workSituation: 'Situação profissional', availability: 'Disponibilidade', languages: 'Idiomas', phone: 'Telefone' },
+    situationLabels: { FREELANCE: 'Freelancer', EMPLOYED: 'Por conta de outrem', BETWEEN_JOBS: 'Entre trabalhos', STUDYING: 'A estudar', OTHER: 'Outra' },
+    participationLabels: { FULL_TIME: 'tempo inteiro', PART_TIME: 'tempo parcial' },
     existingUnchanged: (items) => `Estes dados do seu perfil não os alterei, ficam como estavam: ${items.join(' · ')}. Se quiser outros valores, altere-os na web.`,
     aiUsageQuestion: 'Quer que analise como trabalha com IA? É opcional e demora 1-2 min. Só vejo que ferramentas usa; o seu código e os seus prompts não saem da sua máquina. Analiso o uso de IA em todo este computador, que considero seu. Ajuda-o a destacar-se em projetos de IA.',
     aiUsageYes: 'Sim, analise',
     aiUsageSkip: 'Saltar este passo',
     aiUsageSkipped: "Sem problema, seguimos sem ele. Aviso-o de que é o que mais pesa para lhe chegarem projetos: pode lançá-lo quando quiser dizendo-me 'analisa o meu uso de IA'.",
+    consent: {
+      yes: 'Sim, avançar',
+      no: 'Não',
+      cvSearch: 'A Shakers vai procurar neste computador ficheiros que possam ser o seu CV: vê os nomes dos ficheiros PDF e Word das pastas Secretária, Documentos, Transferências e iCloud Drive, e lê o seu fuso horário e o nome, o email e o utilizador de GitHub guardados pelas suas ferramentas de programação. Não abre esses ficheiros e não envia nada. Continuamos?',
+      cvRead: (file) => `A Shakers vai ler o ficheiro ${file} para preparar o rascunho do seu perfil. Ainda não é enviado nada. Continuamos?`,
+      cvSend: (file) => `A Shakers vai enviar o ficheiro ${file} para a sua conta Shakers para completar o seu perfil. Continuamos?`,
+      project: (p) => `A Shakers vai adicionar o projeto da pasta ${p.folder} ao seu portfólio e enviar ${listOf('pt', [`o nome "${p.name}"`, p.url && `o endereço web ${p.url}`, p.startDate && p.endDate ? `as datas de ${p.startDate} a ${p.endDate}` : (p.startDate || p.endDate) && `a data ${p.startDate || p.endDate}`, p.client && `o cliente ${p.client}`, p.description && 'a descrição que combinou'].filter(Boolean))}. Continuamos?`,
+    },
     importSources: { linkedin: 'o seu LinkedIn', cv: 'o seu CV', github: 'o seu GitHub', web: 'o seu site' },
     importFailed: (names) => `Não consegui importar ${names.join(' e ')} neste momento. O resto do seu perfil está guardado; o que faltar pode acrescentá-lo na web.`,
     interviewWhereQuestion: 'Fazemos a entrevista de onboarding aqui agora ou mais tarde na web?',
@@ -372,8 +422,12 @@ function legalCopy(lang) {
 function renderDraft(lang, d = {}) {
   const c = signupCopy(lang);
   const has = (v) => v !== null && v !== undefined && String(v).trim() !== '';
+  const place = [d.city, countryName(lang, d.country)].filter(has).join(', ');
+  const situation = c.situationLabels[d.situation];
+  const participation = d.situation === 'EMPLOYED' ? c.participationLabels[d.participation] : null;
   const lines = [
-    joinParts([d.name, d.role, d.city]),
+    joinParts([d.name, d.role, place]),
+    situation ? `${c.keptLabels.workSituation}: ${participation ? `${situation} (${participation})` : situation}` : '',
     joinParts([has(d.yearsOfExperience) ? c.years(d.yearsOfExperience) : null, d.stack]),
     joinParts([d.languages, d.workMode, has(d.monthlyHours) ? c.hours(d.monthlyHours) : null]),
     has(d.hourlyRate) || has(d.annualRate) ? c.rates(has(d.hourlyRate) ? d.hourlyRate : null, has(d.annualRate) ? d.annualRate : null, d.ratesFromTalent !== true) : '',