shakers-cli-beta 0.9.0 → 0.10.0

package/src/onboarding-client.js

@@ -1,11 +1,9 @@
 'use strict';
 
-const fs = require('fs');
-const path = require('path');
 const { postJsonWithTimeout, postMultipartWithTimeout } = require('./backend-request');
 const { WORKS_CODE_TO_REASON } = require('./skills-client');
 const { toLowerLang, toUpperLang } = require('./lang-codes');
-const { expandHome } = require('./env-paths');
+const { readLocalCv } = require('./cv-file');
 
 const DEFAULT_TIMEOUT_MS = 20000;
 const IMPORT_KICKOFF_TIMEOUT_MS = 90000;
@@ -42,46 +40,48 @@ function envelopeData(raw) {
   return json.data;
 }
 
-function buildImportSources({ linkedinUrl, cvPath, githubUrl, websiteUrl, language } = {}) {
+function buildImportSources({ linkedinUrl, cvPath, githubUrl, websiteUrl, language, userQuery, fillEmptyOnly } = {}) {
   const sources = { language: toLowerLang(language) };
   if (typeof linkedinUrl === 'string' && linkedinUrl) sources.linkedinUrl = linkedinUrl;
   if (typeof cvPath === 'string' && cvPath) sources.cvPath = cvPath;
   if (typeof githubUrl === 'string' && githubUrl) sources.githubUrl = githubUrl;
   if (typeof websiteUrl === 'string' && websiteUrl) sources.websiteUrl = websiteUrl;
+  if (typeof userQuery === 'string' && userQuery) sources.userQuery = userQuery;
+  if (fillEmptyOnly === true) sources.fillEmptyOnly = true;
   return sources;
 }
 
-// The CV formats and size hub accepts on import-profile.
-const CV_CONTENT_TYPES = {
-  '.pdf': 'application/pdf',
-  '.doc': 'application/msword',
-  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-};
-const CV_MAX_BYTES = 10 * 1024 * 1024;
+// Hub answers import-profile synchronously with a per-source report; null when the AI omitted it.
+function importReportFrom(data) {
+  const report = data && typeof data === 'object' ? data.importReport : null;
+  if (!report || !Array.isArray(report.sources)) return null;
+  return {
+    outcome: typeof report.outcome === 'string' ? report.outcome : null,
+    sources: report.sources
+      .filter((src) => src && typeof src.source === 'string')
+      .map((src) => ({
+        source: src.source,
+        status: typeof src.status === 'string' ? src.status : null,
+        ...(typeof src.code === 'string' ? { code: src.code } : {}),
+        ...(typeof src.retryable === 'boolean' ? { retryable: src.retryable } : {}),
+      })),
+  };
+}
 
+// The CV formats hub accepts on import-profile.
 function readCvUpload(input) {
-  const cvPath = expandHome(input);
-  const contentType = CV_CONTENT_TYPES[path.extname(cvPath).toLowerCase()];
-  if (!contentType) return { ok: false, reason: 'cv-bad-format' };
-  let data;
-  try {
-    data = fs.readFileSync(cvPath);
-  } catch {
-    return { ok: false, reason: 'cv-not-found' };
-  }
-  if (data.length > CV_MAX_BYTES) return { ok: false, reason: 'cv-too-large' };
-  return { ok: true, file: { filename: path.basename(cvPath), contentType, data } };
+  return readLocalCv(input, { extensions: ['.pdf', '.doc', '.docx'], badFormat: 'cv-bad-format' });
 }
 
 async function requestImportProfile(
-  { linkedinUrl, cvPath, githubUrl, websiteUrl, language, accessToken, hubAccessToken } = {},
+  { linkedinUrl, cvPath, githubUrl, websiteUrl, language, userQuery, fillEmptyOnly, accessToken, hubAccessToken } = {},
   { endpoint, timeoutMs = IMPORT_KICKOFF_TIMEOUT_MS } = {},
 ) {
   if (!endpoint) return { ok: false, reason: 'no-endpoint' };
-  if (!linkedinUrl) return { ok: false, reason: 'no-linkedin' };
+  if (!linkedinUrl && !cvPath && !githubUrl && !websiteUrl) return { ok: false, reason: 'no-source' };
   if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
 
-  const body = buildImportSources({ linkedinUrl, cvPath, githubUrl, websiteUrl, language });
+  const body = buildImportSources({ linkedinUrl, cvPath, githubUrl, websiteUrl, language, userQuery, fillEmptyOnly });
   let res;
   try {
     if (body.cvPath) {
@@ -90,7 +90,8 @@ async function requestImportProfile(
       const cv = readCvUpload(body.cvPath);
       if (!cv.ok) return cv;
       const { cvPath: _localPath, ...fields } = body;
-      res = await postMultipartWithTimeout(endpoint, { ...fields, cv: cv.file }, timeoutMs, 'POST', hubHeaders({ hubAccessToken }));
+      const form = { ...fields, fillEmptyOnly: fields.fillEmptyOnly ? 'true' : undefined };
+      res = await postMultipartWithTimeout(endpoint, { ...form, cv: cv.file }, timeoutMs, 'POST', hubHeaders({ hubAccessToken }));
     } else {
       res = await postJsonWithTimeout(endpoint, body, timeoutMs, 'POST', null, hubHeaders({ hubAccessToken }));
     }
@@ -101,31 +102,7 @@ async function requestImportProfile(
 
   const data = envelopeData(res.raw);
   if (data === undefined) return { ok: false, reason: 'bad-response' };
-  const jobId = data && typeof data === 'object' && (data.jobId || data.importId || data.id) || null;
-  const state = data && typeof data === 'object' && typeof data.state === 'string' ? data.state : 'running';
-  return { ok: true, jobId, state };
-}
-
-async function requestImportStatus(
-  { jobId, accessToken, hubAccessToken } = {},
-  { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
-) {
-  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
-  if (!jobId) return { ok: false, reason: 'no-job' };
-
-  const url = `${endpoint.replace(/\/+$/, '')}/${encodeURIComponent(jobId)}`;
-  let res;
-  try {
-    res = await postJsonWithTimeout(url, null, timeoutMs, 'GET', null, hubHeaders({ hubAccessToken }));
-  } catch (e) {
-    return { ok: false, reason: (e && e.kind) || 'network-error' };
-  }
-  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
-
-  const data = envelopeData(res.raw);
-  if (data === undefined || !data || typeof data !== 'object') return { ok: false, reason: 'bad-response' };
-  const state = typeof data.state === 'string' ? data.state : 'running';
-  return { ok: true, state };
+  return { ok: true, report: importReportFrom(data) };
 }
 
 async function requestSetProfessionalDetails(
@@ -380,7 +357,6 @@ async function requestCompleteTextSession(
 
 module.exports = {
   requestImportProfile,
-  requestImportStatus,
   requestSetProfessionalDetails,
   requestSetPricingRate,
   requestSetAvailability,

package/src/onboarding-flow.js

@@ -241,120 +241,6 @@ function validateAvailability(input = {}) {
   return { ok: true, availability: body };
 }
 
-// Fields the talent must ALWAYS confirm explicitly — never inferred/invented by
-// the model (a wrong price or motivation is worse than a gap).
-const MUST_CONFIRM_FIELDS = ['pricing', 'workSituation.changeMotivators'];
-
-// PURE preview of a (possibly partial) register payload: what WOULD be written,
-// what is still missing, and what is invalid — reusing the same validators the
-// write path uses. Touches no network and needs no session, so the model can show
-// the talent a review before the single `register` write.
-function buildRegisterPreview(args = {}) {
-  const wouldWrite = [];
-  const missingFields = [];
-  const warnings = [];
-  const addMissing = (field, required) => missingFields.push({ field, required });
-
-  // --- account (always written at registration; password never in the payload) ---
-  const account = {
-    name: args.name,
-    lastName: args.lastName,
-    email: args.email,
-    freelanceType: args.freelanceType,
-  };
-  if (!isNonEmptyString(account.name)) addMissing('name', true);
-  if (!isNonEmptyString(account.lastName)) addMissing('lastName', true);
-  if (!isNonEmptyString(account.email)) addMissing('email', true);
-  const ftype = normalizeFreelanceType(account.freelanceType);
-  if (!ftype) {
-    if (isNonEmptyString(account.freelanceType)) warnings.push({ field: 'freelanceType', reason: 'bad-freelance-type' });
-    else addMissing('freelanceType', true);
-  }
-  wouldWrite.push({
-    section: 'account',
-    endpoint: 'hub: auth/sign-up/email + works/auth/complete-registration',
-    data: {
-      name: isNonEmptyString(account.name) ? account.name : null,
-      lastName: isNonEmptyString(account.lastName) ? account.lastName : null,
-      email: isNonEmptyString(account.email) ? account.email : null,
-      freelanceType: ftype || null,
-      preferredLanguage: isNonEmptyString(args.preferredLanguage) ? args.preferredLanguage : null,
-      newsletterConsent: args.newsletterConsent === true,
-    },
-    note: 'password is never part of this payload — the talent types it in the local sign-up window',
-  });
-
-  // --- profile import (linkedinUrl is the required source) ---
-  const profile = args.profile && typeof args.profile === 'object' ? args.profile : {};
-  if (!isNonEmptyString(profile.linkedinUrl)) addMissing('profile.linkedinUrl', true);
-  else {
-    const pdata = { linkedinUrl: profile.linkedinUrl };
-    for (const k of ['githubUrl', 'websiteUrl', 'cvPath']) if (isNonEmptyString(profile[k])) pdata[k] = profile[k];
-    wouldWrite.push({ section: 'profile', endpoint: 'hub: works/me/import-profile', data: pdata });
-  }
-
-  // --- work situation (situation required) ---
-  const ws = args.workSituation && typeof args.workSituation === 'object' ? args.workSituation : {};
-  if (!isNonEmptyString(ws.situation)) addMissing('workSituation.situation', true);
-  else {
-    const vws = validateWorkSituation(ws);
-    if (!vws.ok) warnings.push({ field: 'workSituation', reason: vws.reason });
-    else wouldWrite.push({ section: 'workSituation', endpoint: 'hub: works/me/professional-details', data: vws.professionalDetails });
-  }
-
-  // --- pricing (at least one variant; ALWAYS confirm) ---
-  const pricing = args.pricing && typeof args.pricing === 'object' ? args.pricing : {};
-  const pricingEmpty = pricing.fullTimeSelected !== true && pricing.partTimeSelected !== true
-    && pricing.fullTimeAmount == null && pricing.partTimeAmount == null;
-  if (pricingEmpty) addMissing('pricing', true);
-  else {
-    const vp = validatePricing(pricing);
-    if (!vp.ok) warnings.push({ field: 'pricing', reason: vp.reason });
-    else wouldWrite.push({ section: 'pricing', endpoint: 'hub: works/talents/me/work-details/pricing-rate', data: vp.pricing });
-  }
-
-  // --- availability (optional; suggest the sub-fields the talent did not give) ---
-  if (args.availability && typeof args.availability === 'object') {
-    const va = validateAvailability(args.availability);
-    if (!va.ok) warnings.push({ field: 'availability', reason: va.reason });
-    else {
-      wouldWrite.push({ section: 'availability', endpoint: 'hub: works/talents/me/work-details/availability', data: va.availability });
-      for (const k of ['available', 'monthlyHours', 'workModes', 'country', 'timezone']) {
-        if (!(k in va.availability)) addMissing(`availability.${k}`, false);
-      }
-    }
-  } else {
-    addMissing('availability', false);
-  }
-
-  // --- languages (optional; ids resolve at write-time, so the preview shows codes) ---
-  if (Array.isArray(args.languages) && args.languages.length > 0) {
-    const vl = validateLanguageRows(args.languages);
-    if (!vl.ok) warnings.push({ field: 'languages', reason: vl.reason });
-    else wouldWrite.push({ section: 'languages', endpoint: 'hub: works/talents/me/work-details/languages', data: vl.rows, note: 'language codes resolve to ids at write time' });
-  } else {
-    addMissing('languages', false);
-  }
-
-  // --- phone (optional) ---
-  if (args.phone && typeof args.phone === 'object') {
-    const vph = validatePhone(args.phone);
-    if (!vph.ok) warnings.push({ field: 'phone', reason: vph.reason });
-    else wouldWrite.push({ section: 'phone', endpoint: 'hub: works/me', data: { telephoneCode: vph.telephoneCode, telephoneNumber: vph.telephoneNumber } });
-  } else {
-    addMissing('phone', false);
-  }
-
-  return {
-    ok: true,
-    provenance: 'self-declared',
-    wouldWrite,
-    missingFields,
-    warnings,
-    mustConfirm: MUST_CONFIRM_FIELDS,
-  };
-}
-
 function makeDeps(overrides = {}) {
   const config = require('./config');
   const client = require('./onboarding-client');
@@ -392,7 +278,6 @@ function makeDeps(overrides = {}) {
     getTalentProfileUrl: config.getTalentProfileUrl,
     getUsageDiscoveredInventoryEndpoint: config.getUsageDiscoveredInventoryEndpoint,
     requestImportProfile: client.requestImportProfile,
-    requestImportStatus: client.requestImportStatus,
     requestSetProfessionalDetails: client.requestSetProfessionalDetails,
     requestSetPricingRate: client.requestSetPricingRate,
     requestSetAvailability: client.requestSetAvailability,
@@ -434,19 +319,6 @@ function isAcceptablePassword(password) {
   return typeof password === 'string' && password.length >= 8;
 }
 
-function isNonEmptyString(value) {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-function validateRegisterFields(fields = {}) {
-  if (!isNonEmptyString(fields.name)) return { ok: false, reason: 'missing-name' };
-  if (!isNonEmptyString(fields.lastName)) return { ok: false, reason: 'missing-last-name' };
-  if (!isNonEmptyString(fields.email)) return { ok: false, reason: 'missing-email' };
-  const type = normalizeFreelanceType(fields.freelanceType);
-  if (!type) return { ok: false, reason: 'bad-freelance-type' };
-  return { ok: true };
-}
-
 async function signUp(deps, fields = {}) {
   // The CLI no longer asks freelanceType at signup → transient default (corrected later from the work situation via professional-details).
   if (!isAcceptablePassword(fields.password)) return { ok: false, reason: 'weak-password' };
@@ -465,6 +337,7 @@ async function signUp(deps, fields = {}) {
       newsletterConsent: fields.newsletterConsent === true,
       freelanceType: normalizeFreelanceType(fields.freelanceType) || DEFAULT_SIGNUP_FREELANCE_TYPE,
       freelanceIntent: fields.freelanceIntent,
+      claimCode: fields.claimCode || null,
     },
     { signUpEndpoint, completeRegistrationEndpoint },
   );
@@ -548,17 +421,6 @@ async function startProfileImport(deps, sources = {}) {
   );
 }
 
-async function pollProfileImport(deps, { jobId } = {}) {
-  const gate = await requireActiveSession(deps);
-  if (!gate.ok) return gate;
-  const endpoint = deps.getImportProfileEndpoint();
-  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
-  return deps.requestImportStatus(
-    { jobId, accessToken: gate.session.accessToken, hubAccessToken: gate.session.hubAccessToken },
-    { endpoint },
-  );
-}
-
 // A: anchor the ingest identity to THIS talent's session email so a stale
 // consent.json from a prior alta doesn't misattribute the footprint. Never throws.
 function reattachConsentIdentity(deps) {
@@ -798,14 +660,12 @@ function profileUrl(deps) {
 }
 
 function usageDisclaimers(lang) {
-  const { getCatalog } = require('./i18n');
-  const c = getCatalog(lang).onboarding;
+  const c = require('./signup-copy').legalCopy(lang);
   return { infoAccessed: c.usageInfoAccessed, goalDuration: c.usageGoalDuration };
 }
 
 function interviewDisclaimers(lang) {
-  const { getCatalog } = require('./i18n');
-  const c = getCatalog(lang).onboarding;
+  const c = require('./signup-copy').legalCopy(lang);
   return { infoAccessed: c.interviewInfoAccessed, goalDuration: c.interviewGoalDuration };
 }
 
@@ -1165,9 +1025,6 @@ module.exports = {
   validateAvailability,
   buildPricingUpsert,
   isAcceptablePassword,
-  validateRegisterFields,
-  buildRegisterPreview,
-  MUST_CONFIRM_FIELDS,
   deriveCurrentEmploymentStatus,
   showsFreelanceOpinion,
   deriveFreelanceIntent,
@@ -1180,7 +1037,6 @@ module.exports = {
   establishSessionFromCredentials,
   registerWithSocialAccount,
   startProfileImport,
-  pollProfileImport,
   reattachConsentIdentity,
   saveWorkSituation,
   savePricing,

package/src/onboarding-status-client.js

@@ -39,4 +39,19 @@ async function requestOnboardingStatus({ accessToken } = {}, { endpoint, timeout
   return { ok: true, completed: data.completed === true };
 }
 
-module.exports = { requestOnboardingStatus };
+// GET <certs>/interviews/:id/finalization -> COLLECTING | PROCESSING | READY | FAILED for a completed interview's evaluation.
+async function requestInterviewFinalization({ interviewId, accessToken } = {}, { base, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!base || !interviewId) return { ok: false, reason: 'no-endpoint' };
+  let res;
+  try {
+    res = await postJsonWithTimeout(`${base}/${encodeURIComponent(interviewId)}/finalization`, null, timeoutMs, 'GET', null, authHeaders({ accessToken }));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: `http-${res.status}` };
+  const json = parseJson(res.raw);
+  const status = json && json.data && typeof json.data.status === 'string' ? json.data.status : null;
+  return status ? { ok: true, status } : { ok: false, reason: 'bad-response' };
+}
+
+module.exports = { requestOnboardingStatus, requestInterviewFinalization };

package/src/register-context.js

@@ -123,21 +123,6 @@ function findCvCandidates(home, personName) {
     .map(({ path: cvPath, nameMatch, generic }) => ({ path: tildify(cvPath, { SHAKERS_CLI_HOME_DIR: home }), nameMatch, generic }));
 }
 
-// Which backend this install talks to, so the AI never calls a test sign-up
-// "production".
-function detectEnvironment(env) {
-  let base = '';
-  try {
-    base = String(require('./config').getHubBase(env) || '');
-  } catch {
-    return 'unknown';
-  }
-  if (/localhost|127\.0\.0\.1/.test(base)) return 'local';
-  if (/staging/.test(base)) return 'staging';
-  if (/\.dev\.|new-works/.test(base)) return 'development';
-  return base ? 'production' : 'unknown';
-}
-
 // Returns the signals found, each clearly a SUGGESTION to confirm. `talentName`
 // (what the AI already knows) sharpens the CV match beyond the git name.
 function readRegisterContextSuggestions({ cwd, env = process.env, talentName } = {}) {
@@ -146,7 +131,6 @@ function readRegisterContextSuggestions({ cwd, env = process.env, talentName } =
   const gitName = gitConfig('user.name', cwd);
   const personName = [talentName, gitName].filter((n) => typeof n === 'string' && n.trim()).join(' ');
   return {
-    environment: detectEnvironment(env),
     timezone: detectTimezone(),
     gitName,
     gitEmail: gitConfig('user.email', cwd),
@@ -156,4 +140,4 @@ function readRegisterContextSuggestions({ cwd, env = process.env, talentName } =
   };
 }
 
-module.exports = { readRegisterContextSuggestions, detectTimezone, findCvCandidates, detectGithubUser, isGenericCvName, detectEnvironment, nameTokens, fold };
+module.exports = { readRegisterContextSuggestions, detectTimezone, findCvCandidates, detectGithubUser, isGenericCvName, nameTokens, fold };

package/src/roles-client.js

@@ -34,10 +34,12 @@ function normalizeRole(r) {
   if (!clusterId) return null;
   return {
     clusterId,
-    name: typeof r.name === 'string' ? r.name : null,
+    // Hub's assigned-clusters rows name the role in clusterName.
+    name: typeof r.name === 'string' ? r.name : (typeof r.clusterName === 'string' ? r.clusterName : null),
     category: typeof r.category === 'string' ? r.category : null,
     proposalKind: typeof r.proposalKind === 'string' ? r.proposalKind : null,
     type: typeof r.type === 'string' ? r.type : null,
+    source: typeof r.source === 'string' ? r.source : null,
   };
 }
 

package/src/signup-client.js

@@ -29,36 +29,48 @@ function buildRegistrationContext({ preferredLanguage, newsletterConsent, freela
   return context;
 }
 
-// Shared complete-registration call: authenticated by the email `cookie` or the device flow `bearerToken`.
-async function requestCompleteRegistration(
-  context = {},
-  { endpoint, cookie = null, bearerToken = null, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
-) {
-  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
-  const headers = {};
-  if (cookie) headers.Cookie = cookie;
-  if (bearerToken) headers.Authorization = `Bearer ${bearerToken}`;
+// Hub refuses these claims with a coded error and creates nothing, so registering without the code is safe.
+const UNCLAIMABLE_CODES = new Set(['auth-engine.claim_code_invalid', 'users.unregistered_talent_not_claimable']);
+
+function codeFrom(raw) {
+  const body = parseJson(raw);
+  return body && typeof body.code === 'string' ? body.code : null;
+}
+
+async function postCompleteRegistration(body, { endpoint, headers, timeoutMs }) {
   let complete;
   try {
-    complete = await postJsonWithTimeout(
-      endpoint,
-      { userType: 'WORKS_TALENT', context },
-      timeoutMs,
-      'POST',
-      null,
-      Object.keys(headers).length ? headers : null,
-    );
+    complete = await postJsonWithTimeout(endpoint, body, timeoutMs, 'POST', null, Object.keys(headers).length ? headers : null);
   } catch (e) {
     return { ok: false, reason: (e && e.kind) || 'network-error' };
   }
   if (complete.status < 200 || complete.status >= 300) {
-    return { ok: false, reason: `complete-registration-http-${complete.status}`, status: complete.status, message: messageFrom(complete.raw) };
+    return { ok: false, reason: `complete-registration-http-${complete.status}`, status: complete.status, code: codeFrom(complete.raw), message: messageFrom(complete.raw) };
   }
   return { ok: true };
 }
 
+// Shared complete-registration call. With a claimCode it claims the MCP sign-up's UNREGISTERED profile; an unclaimable code still registers the account, with claimed:false.
+async function requestCompleteRegistration(
+  context = {},
+  { endpoint, cookie = null, bearerToken = null, claimCode = null, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  const headers = {};
+  if (cookie) headers.Cookie = cookie;
+  if (bearerToken) headers.Authorization = `Bearer ${bearerToken}`;
+  const base = { userType: 'WORKS_TALENT', context };
+  if (typeof claimCode !== 'string' || !claimCode) return postCompleteRegistration(base, { endpoint, headers, timeoutMs });
+
+  const claimed = await postCompleteRegistration({ ...base, claimCode }, { endpoint, headers, timeoutMs });
+  if (claimed.ok) return { ok: true, claimed: true };
+  if (!UNCLAIMABLE_CODES.has(claimed.code)) return claimed;
+  const plain = await postCompleteRegistration(base, { endpoint, headers, timeoutMs });
+  return plain.ok ? { ok: true, claimed: false, claimError: claimed.code } : plain;
+}
+
 async function requestSignUp(
-  { name, lastName, email, password, preferredLanguage, newsletterConsent, freelanceType, freelanceIntent } = {},
+  { name, lastName, email, password, preferredLanguage, newsletterConsent, freelanceType, freelanceIntent, claimCode = null } = {},
   { signUpEndpoint, completeRegistrationEndpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
 ) {
   if (!signUpEndpoint) return { ok: false, reason: 'no-endpoint' };
@@ -83,9 +95,9 @@ async function requestSignUp(
   if (!completeRegistrationEndpoint) return { ok: false, reason: 'no-endpoint' };
 
   const context = buildRegistrationContext({ preferredLanguage, newsletterConsent, freelanceType, freelanceIntent });
-  const complete = await requestCompleteRegistration(context, { endpoint: completeRegistrationEndpoint, cookie, timeoutMs });
+  const complete = await requestCompleteRegistration(context, { endpoint: completeRegistrationEndpoint, cookie, claimCode, timeoutMs });
   if (!complete.ok) return complete;
-  return { ok: true, accountExists: false };
+  return claimCode ? { ok: true, accountExists: false, claimed: complete.claimed === true } : { ok: true, accountExists: false };
 }
 
 module.exports = { requestSignUp, requestCompleteRegistration, buildRegistrationContext };