shakers-cli 0.16.0 → 0.18.0

package/src/onboarding-flow.js

@@ -249,7 +249,6 @@ function makeDeps(overrides = {}) {
   const ai = require('./ai');
   const inventory = require('./inventory-client');
   const auth = require('./auth-session-store');
-  const authClient = require('./auth-client');
   const signup = require('./signup-client');
   const livekit = require('./onboarding-livekit-client');
   return {
@@ -257,17 +256,14 @@ function makeDeps(overrides = {}) {
     sessionStatus: auth.sessionStatus,
     saveAuthSession: auth.saveAuthSession,
     ensureFreshSession: require('./session-refresh').ensureFreshSession,
-    getSignUpEndpoint: config.getSignUpEndpoint,
     getCompleteRegistrationEndpoint: config.getCompleteRegistrationEndpoint,
-    getLoginEndpoint: config.getLoginEndpoint,
     getAuthTokenEndpoint: config.getAuthTokenEndpoint,
     getDeviceAuthorizeEndpoint: config.getDeviceAuthorizeEndpoint,
     getDeviceTokenEndpoint: config.getDeviceTokenEndpoint,
     runDeviceLogin: require('./device-login').runDeviceLogin,
     requestCompleteRegistration: signup.requestCompleteRegistration,
     buildRegistrationContext: signup.buildRegistrationContext,
-    requestSignUp: signup.requestSignUp,
-    requestLogin: authClient.requestLogin,
+    buildRegistrationConsent: signup.buildRegistrationConsent,
     getImportProfileEndpoint: config.getImportProfileEndpoint,
     getProfessionalDetailsEndpoint: config.getProfessionalDetailsEndpoint,
     getPricingRateEndpoint: config.getPricingRateEndpoint,
@@ -305,7 +301,6 @@ function makeDeps(overrides = {}) {
   };
 }
 
-// Refreshes the email session's hub JWT from its stored cookie when the cached one has lapsed (session-refresh.js), then gates on the durable session status.
 async function requireActiveSession(deps) {
   const session = typeof deps.ensureFreshSession === 'function'
     ? await deps.ensureFreshSession(process.env, { loadAuthSession: deps.loadAuthSession, saveAuthSession: deps.saveAuthSession })
@@ -316,79 +311,26 @@ async function requireActiveSession(deps) {
   return { ok: true, session };
 }
 
-function isAcceptablePassword(password) {
-  return typeof password === 'string' && password.length >= 8;
-}
-
-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' };
-  const signUpEndpoint = deps.getSignUpEndpoint();
-  if (!signUpEndpoint) return { ok: false, reason: 'no-endpoint' };
-  const completeRegistrationEndpoint = typeof deps.getCompleteRegistrationEndpoint === 'function'
-    ? deps.getCompleteRegistrationEndpoint()
-    : null;
-  return deps.requestSignUp(
-    {
-      name: fields.name,
-      lastName: fields.lastName,
-      email: fields.email,
-      password: fields.password,
-      preferredLanguage: fields.preferredLanguage,
-      newsletterConsent: fields.newsletterConsent === true,
-      freelanceType: normalizeFreelanceType(fields.freelanceType) || DEFAULT_SIGNUP_FREELANCE_TYPE,
-      freelanceIntent: fields.freelanceIntent,
-      claimCode: fields.claimCode || null,
-    },
-    { signUpEndpoint, completeRegistrationEndpoint },
-  );
-}
-
-async function establishSessionFromCredentials(deps, { email, password } = {}) {
-  const signInEndpoint = deps.getLoginEndpoint();
-  if (!signInEndpoint) return { ok: false, reason: 'no-endpoint' };
-  const tokenEndpoint = typeof deps.getAuthTokenEndpoint === 'function' ? deps.getAuthTokenEndpoint() : null;
-  const result = await deps.requestLogin({ email, password }, { signInEndpoint, tokenEndpoint });
-  if (!result.ok) return { ok: false, reason: result.reason || 'login-failed', status: result.status || null };
-  try {
-    // For an email session the durable credential is the cookie; `accessToken` is
-    // the fresh JWT and `expiresAt` its own exp (stored as the refresh horizon).
-    deps.saveAuthSession({
-      accessToken: result.accessToken,
-      expiresAt: result.expiresAt,
-      accessTokenExpiresAt: result.expiresAt,
-      cookie: result.cookie || null,
-      cookieExpiresAt: result.cookieExpiresAt || null,
-      email: result.email || email || null,
-      hubAccessToken: result.hubAccessToken || null,
-    });
-  } catch {
-    return { ok: false, reason: 'session-persist-failed' };
-  }
-  return { ok: true };
-}
-
-// Register a talent via a social provider (device flow, RFC 8628); a live session results either way.
-async function registerWithSocialAccount(deps, { provider = 'google', freelanceType, language } = {}, { openBrowser, onAuthUrl } = {}) {
-  const { appendProviderParam, deviceSessionRecord } = require('./device-login');
+async function registerWithDeviceFlow(deps, { provider = 'email', freelanceType, language, newsletterConsent = false } = {}, { openBrowser, onAuthUrl } = {}) {
+  const { withDeviceParams, deviceSessionRecord } = require('./device-login');
   const authorizeEndpoint = deps.getDeviceAuthorizeEndpoint();
   const tokenEndpoint = deps.getDeviceTokenEndpoint();
   const authTokenEndpoint = typeof deps.getAuthTokenEndpoint === 'function' ? deps.getAuthTokenEndpoint() : null;
   const completeRegistrationEndpoint = typeof deps.getCompleteRegistrationEndpoint === 'function' ? deps.getCompleteRegistrationEndpoint() : null;
   if (!authorizeEndpoint || !tokenEndpoint || !authTokenEndpoint) return { ok: false, reason: 'no-endpoint' };
 
-  // freelanceType is a transient default (corrected later); feeds complete-registration for a new account.
   const registrationContext = deps.buildRegistrationContext({
     preferredLanguage: language,
-    newsletterConsent: false,
+    newsletterConsent: newsletterConsent === true,
     freelanceType: normalizeFreelanceType(freelanceType) || DEFAULT_SIGNUP_FREELANCE_TYPE,
   });
+  const consent = deps.buildRegistrationConsent({ newsletterConsent: newsletterConsent === true });
 
   const result = await deps.runDeviceLogin(
-    { authorizeEndpoint, tokenEndpoint, authTokenEndpoint, completeRegistrationEndpoint, registrationContext },
+    { authorizeEndpoint, tokenEndpoint, authTokenEndpoint, completeRegistrationEndpoint, registrationContext, consent },
     {
       onPrompt: ({ verificationUriComplete, userCode }) => {
-        const url = appendProviderParam(verificationUriComplete, provider);
+        const url = withDeviceParams(verificationUriComplete, { provider, mode: 'register', surface: 'cli' });
         if (typeof onAuthUrl === 'function') onAuthUrl(url, userCode);
         if (typeof openBrowser === 'function') { try { openBrowser(url); } catch { /* printed URL covers it */ } }
       },
@@ -402,7 +344,6 @@ async function registerWithSocialAccount(deps, { provider = 'google', freelanceT
     return { ok: false, reason: 'session-persist-failed' };
   }
 
-  // isNewUser distinguishes a fresh registration from signing an existing account in.
   return { ok: true, kind: result.isNewUser ? 'registered' : 'account-already-exists', email: result.email || null };
 }
 
@@ -669,18 +610,15 @@ 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`).
@@ -689,9 +627,10 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
   const c = getCatalog(io.lang).onboarding;
 
   funnel.begin();
+  funnel.viewed('start');
   funnel.completed('start');
   io.section(c.signupTitle);
-  funnel.viewed('account_creation');
+  funnel.viewed('account_creation', { auth_methods_offered: require('./auth-methods').methodIdsForFlow('register') });
   funnel.flush();
   const accountFailed = (reason) => {
     funnel.errored('account_creation', reason);
@@ -699,61 +638,30 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
     return { ok: false, reason, step: 'signup' };
   };
 
-  if (method === 'google' || method === 'linkedin') {
-    // The provider supplies name/email; freelanceType is derived later from work situation.
-    await io.askGoogleSignUp(c);
-    const reg = await registerWithSocialAccount(
-      deps,
-      { provider: method, language: io.lang },
-      { openBrowser, onAuthUrl },
-    );
-    if (!reg.ok) {
-      io.error(c.signupError);
-      return accountFailed(reg.reason);
-    }
-    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);
-      return { ok: true, alreadyRegistered: true };
-    }
-    notifyOk(io, c.accountReady);
-  } else {
-    const account = await io.askSignUp(c);
-    if (!account || !account.email) return accountFailed('missing-fields');
-    if (!isAcceptablePassword(account.password)) {
-      io.error(c.weakPassword);
-      return accountFailed('weak-password');
-    }
-
-    const su = await signUp(deps, { ...account, preferredLanguage: account.preferredLanguage || io.lang });
-    if (!su.ok) {
-      io.error(su.message || c.signupError);
-      return accountFailed(su.reason);
-    }
-
-    if (su.accountExists) {
-      // Existing account: sign them in, then STOP — no wizard re-run.
-      io.warn(c.accountExists);
-      const logged = await io.login(account.email);
-      if (!logged) return accountFailed('login-failed');
-      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 });
-    if (!sess.ok) {
-      io.error(c.sessionError);
-      return accountFailed(sess.reason);
-    }
-    funnel.completed('account_creation', { auth_method: 'email', is_returning_account: false });
-    funnel.identified();
-    notifyOk(io, c.accountReady);
+  const terms = await io.askTerms(c);
+  if (!terms.accepted) {
+    io.warn(c.termsDeclined);
+    return accountFailed('terms-declined');
+  }
+  const reg = await registerWithDeviceFlow(
+    deps,
+    { provider: method, language: io.lang, newsletterConsent: terms.newsletterConsent },
+    { openBrowser, onAuthUrl },
+  );
+  if (!reg.ok) {
+    io.error(c.signupError);
+    return accountFailed(reg.reason);
+  }
+  funnel.completed('account_creation', { auth_method: method, auth_attempts: 1, is_returning_account: reg.kind === 'account-already-exists' });
+  funnel.identified({ newAccount: reg.kind !== 'account-already-exists' });
+  if (reg.kind === 'account-already-exists') {
+    io.warn(c.accountExists);
+    return { ok: true, alreadyRegistered: true };
   }
+  notifyOk(io, c.accountReady);
 
   io.section(c.title);
-  funnel.viewed('import_sources');
+  funnel.viewed('import_sources', { sources_offered: ['linkedin', 'cv', 'github', 'web_page'] });
   const linkedinUrl = (await io.ask(c.askLinkedin) || '').trim();
   if (!linkedinUrl) {
     funnel.errored('import_sources', 'no-linkedin', { error_field: 'linkedin' });
@@ -772,15 +680,15 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
   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 });
+  trackImport(funnel, attempted, importRes, Date.now() - importStartedAt);
+  funnel.completed('import_sources', { sources_attempted: attempted, sources_connected: attempted, sources_connected_count: attempted.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');
+  funnel.viewed('work_situation', { is_prefilled: false });
   const workSituationInput = await io.askWorkSituation(c);
   const workSituationRes = await saveWorkSituation(deps, workSituationInput);
   if (!workSituationRes.ok) {
@@ -788,11 +696,11 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
     funnel.flush();
     return { ok: false, reason: workSituationRes.reason, step: 'work-situation' };
   }
-  funnel.completed('work_situation', { work_situation: workSituationValue(String(workSituationInput.situation || '').trim().toUpperCase()) });
+  funnel.completed('work_situation', { work_situation: workSituationValue(String(workSituationInput.situation || '').trim().toUpperCase()), was_edited: true });
   notifyOk(io, c.professionalSaved);
 
   io.section(c.pricingTitle);
-  funnel.viewed('rates');
+  funnel.viewed('rates', { suggested_rate_shown: false });
   const pricingInput = await io.askPricing(c);
   const priceRes = await savePricing(deps, pricingInput);
   if (!priceRes.ok) {
@@ -805,23 +713,31 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
     rate_types_selected: selectedRates,
     rate_type: selectedRates[0],
     rate_currency: normalizeCurrency(pricingInput.partTimeSelected === true ? pricingInput.partTimeCurrency : pricingInput.fullTimeCurrency) || undefined,
+    was_edited: true,
   });
   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');
+  funnel.viewed('availability', { is_prefilled: false });
   if (await io.confirm(c.availabilityAsk)) {
-    const availabilityInput = await io.askAvailability(c);
+    let availabilityTime;
+    const availabilityInput = await io.askAvailability(c, {
+      onLocation: () => {
+        availabilityTime = funnel.stepTime('availability');
+        funnel.viewed('location', { is_prefilled: false });
+      },
+    });
     const availRes = await saveAvailability(deps, availabilityInput);
     if (availRes.ok) {
-      funnel.completed('availability', { availability_hours_per_week: weeklyHours(normalizeMonthlyHours(availabilityInput.monthlyHours)) });
+      funnel.completed('availability', { availability_hours_per_week: weeklyHours(normalizeMonthlyHours(availabilityInput.monthlyHours)), time_on_step_ms: availabilityTime, was_edited: true });
       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,
+        was_edited: true,
       });
       notifyOk(io, c.availabilitySaved);
     } else {
@@ -839,13 +755,13 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
   }
 
   io.section(c.languagesTitle);
-  funnel.viewed('languages');
+  funnel.viewed('languages', { is_prefilled: false });
   if (await io.confirm(c.languagesAsk)) {
     const languageRows = await io.askLanguages(c);
     const langRes = await saveLanguages(deps, languageRows);
     if (langRes.ok) {
       const codes = validateLanguageRows(languageRows).rows.map((r) => r.language);
-      funnel.completed('languages', { languages_count: codes.length, languages: codes });
+      funnel.completed('languages', { languages_count: codes.length, languages: codes, was_edited: true });
       notifyOk(io, c.languagesSaved);
     } else {
       funnel.errored('languages', langRes.reason);
@@ -888,20 +804,35 @@ async function runOnboarding(io, deps = makeDeps(), { method = 'email', openBrow
   // Every ending points the Talent at their profile, and opens it when a browser is at hand.
   const showProfile = () => {
     const url = profileUrl(deps);
+    funnel.viewed('profile_summary');
     notifyOk(io, url ? c.profileReadyUrl(url) : c.profileReadyNoUrl);
     if (url && typeof openProfile === 'function') {
       try { openProfile(url); } catch { /* the printed link covers it */ }
     }
+    funnel.completed('profile_summary');
+    funnel.flush();
     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');
+    let shown = null;
+    const role = await runMainRoleFinalStep(io, deps, {
+      onRolesShown: (info) => {
+        shown = info;
+        funnel.viewed('supercluster', { suggested_superclusters: info.suggested, suggestion_source: 'assigned_clusters', suggestions_count: info.suggested.length });
+      },
+    });
+    if (role && role.ok && role.chosen) {
+      funnel.completed('supercluster', {
+        supercluster: role.chosen,
+        clusters_count: shown ? shown.clustersCount : undefined,
+        was_suggestion_accepted: shown ? shown.suggested.includes(role.chosen) : undefined,
+      });
+    } else if (role && role.ok) funnel.skipped('supercluster');
     funnel.flush();
   };
 
+  funnel.holdUntil('profile_summary');
   io.section(c.interviewTitle);
   funnel.viewed('pre_interview');
   io.disclaimer(c.interviewInfoAccessed, c.interviewGoalDuration);
@@ -1010,28 +941,26 @@ async function conductLivekitInterview(io, deps, { interviewId = null, language
 }
 
 // Runs the final main-role step, degrading softly (never aborts the flow / never throws).
-async function runMainRoleFinalStep(io, deps, session = null) {
-  const active = session || (typeof deps.loadAuthSession === 'function' ? deps.loadAuthSession() : null);
+async function runMainRoleFinalStep(io, deps, { onRolesShown } = {}) {
+  const active = typeof deps.loadAuthSession === 'function' ? deps.loadAuthSession() : null;
   if (typeof deps.runMainRoleStep !== 'function' || !active) return;
   const { getCatalog } = require('./i18n');
   const catalog = getCatalog(io.lang);
   try {
     const rolesDeps = typeof deps.makeRolesDeps === 'function' ? deps.makeRolesDeps() : undefined;
-    return await deps.runMainRoleStep({ io, session: active, catalog, deps: rolesDeps });
+    return await deps.runMainRoleStep({ io, session: active, catalog, deps: rolesDeps, onRolesShown });
   } catch {
     return null;
   }
 }
 
-// Overwrite-repeat: PATCH /interviews/onboarding/restart. Per contract the Bearer is
-// the talent hub JWT (same token roles use); falls back to accessToken when equal.
+// Overwrite-repeat: PATCH /interviews/onboarding/restart. Candidate certs JWT, like its onboarding siblings.
 async function restartOnboarding(deps) {
   const gate = await requireActiveSession(deps);
   if (!gate.ok) return gate;
   const endpoint = deps.getOnboardingRestartEndpoint();
   if (!endpoint) return { ok: false, reason: 'no-endpoint' };
-  const token = gate.session.hubAccessToken || gate.session.accessToken;
-  return deps.requestRestartOnboardingInterview({ accessToken: token }, { endpoint });
+  return deps.requestRestartOnboardingInterview({ accessToken: gate.session.accessToken }, { endpoint });
 }
 
 // `shakers onboarding --repeat`: warn + explicit confirm, then overwrite the prior
@@ -1123,7 +1052,6 @@ module.exports = {
   validatePricing,
   validateAvailability,
   buildPricingUpsert,
-  isAcceptablePassword,
   deriveCurrentEmploymentStatus,
   showsFreelanceOpinion,
   deriveFreelanceIntent,
@@ -1132,9 +1060,7 @@ module.exports = {
   validateLanguageRows,
   validatePhone,
   makeDeps,
-  signUp,
-  establishSessionFromCredentials,
-  registerWithSocialAccount,
+  registerWithDeviceFlow,
   startProfileImport,
   reattachConsentIdentity,
   saveWorkSituation,

package/src/onboarding-funnel.js

@@ -196,8 +196,17 @@ function createFunnel({
   let active = false;
   let mcpClient = null;
   let cachedDeviceId;
+  let begunAt = null;
+  let lastCompletedAt = null;
+  let heldFrom = null;
   const seen = new Set();
   const inflight = new Set();
+  const viewedAt = new Map();
+
+  function stepTime(stepName) {
+    const since = viewedAt.has(stepName) ? viewedAt.get(stepName) : (lastCompletedAt ?? begunAt);
+    return since === null ? undefined : Math.max(0, now() - since);
+  }
 
   function track(eventType, stepName, properties = {}) {
     if (!active || !EVENT_TYPES.includes(eventType) || !STEP_INDEX[stepName]) return false;
@@ -206,9 +215,20 @@ function createFunnel({
       if (seen.has(key)) return false;
       seen.add(key);
     }
+    const at = now();
+    const own = cleanProperties(properties);
+    if (eventType === 'onboarding_step_viewed') viewedAt.set(stepName, at);
+    if (eventType === 'onboarding_step_completed') {
+      if (own.time_on_step_ms === undefined) {
+        const elapsed = stepTime(stepName);
+        if (elapsed !== undefined) own.time_on_step_ms = elapsed;
+      }
+      lastCompletedAt = at;
+    }
+    if (heldFrom === STEP_INDEX[stepName] && (eventType === 'onboarding_step_completed' || eventType === 'onboarding_step_skipped')) heldFrom = null;
     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 } });
+    pending.push({ eventType, insertId: uuid(), at, seq: seq++, properties: { ...own, ...common } });
     return true;
   }
 
@@ -220,9 +240,16 @@ function createFunnel({
   // 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);
-    return ordered.map((item) => {
+    const latest = [];
+    let next = Infinity;
+    for (let i = ordered.length - 1; i >= 0; i--) {
+      const item = ordered[i];
+      latest[i] = item.time !== undefined ? item.time : Math.min(item.at, next - 1);
+      next = latest[i];
+    }
+    return ordered.map((item, i) => {
       if (item.time === undefined) {
-        lastTime = Math.max(item.at, lastTime + 1);
+        lastTime = Math.max(latest[i], lastTime + 1);
         item.time = lastTime;
       }
       return { item, time: item.time };
@@ -246,8 +273,9 @@ function createFunnel({
     const url = safe(endpoint);
     // Never send under another account signed in since.
     if (!token || !url || accountOf(token) !== account) return Promise.resolve();
-    const batch = pending;
-    pending = [];
+    const batch = heldFrom === null ? pending : pending.filter((e) => e.properties.step_index < heldFrom);
+    if (!batch.length) return Promise.resolve();
+    pending = pending.filter((e) => !batch.includes(e));
     const id = currentDeviceId();
     const toWire = ({ item, time }) => ({ event_type: item.eventType, insert_id: item.insertId, time, ...(id ? { device_id: id } : {}), properties: item.properties });
     return post(stamp(batch), toWire, (events) => send({ endpoint: url, events, hubAccessToken: token })).then(() => undefined);
@@ -288,6 +316,10 @@ function createFunnel({
     surface,
     begin() {
       seen.clear();
+      viewedAt.clear();
+      lastCompletedAt = null;
+      heldFrom = null;
+      begunAt = now();
       active = true;
     },
     get active() { return active; },
@@ -296,8 +328,13 @@ function createFunnel({
     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),
+    stepTime: (step) => (active ? stepTime(step) : undefined),
+    holdUntil(step) {
+      if (active && STEP_INDEX[step]) heldFrom = STEP_INDEX[step];
+    },
     errored: (step, reason, props = {}) => track('onboarding_step_errored', step, { error_type: errorTypeFor(reason), ...props }),
-    identified() {
+    identified({ newAccount = true } = {}) {
+      if (!newAccount) pending = pending.filter((e) => !(e.eventType === 'onboarding_step_completed' && STEP_INDEX[e.properties.step_name] <= STEP_INDEX.account_creation));
       const token = safe(hubToken);
       if (!token) return Promise.resolve();
       account = accountOf(token);
@@ -307,6 +344,7 @@ function createFunnel({
     flush,
     idle,
     settle(capMs = EXIT_FLUSH_CAP_MS) {
+      heldFrom = null;
       flush();
       let timer;
       const cap = new Promise((resolve) => { timer = setTimeout(resolve, capMs); });
@@ -334,6 +372,8 @@ const NOOP_FUNNEL = Object.freeze({
   viewed: () => false,
   completed: () => false,
   skipped: () => false,
+  stepTime: () => undefined,
+  holdUntil() {},
   errored: () => false,
   identified: () => Promise.resolve(),
   flush: () => Promise.resolve(),

package/src/opencode-sessions.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { getHomeDir } = require('./env-paths');
+
+function loadSqlite() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = (warning, ...rest) => {
+    const type = typeof rest[0] === 'string' ? rest[0] : rest[0] && rest[0].type;
+    if (type === 'ExperimentalWarning' && /sqlite/i.test(String(warning))) return;
+    emitWarning.call(process, warning, ...rest);
+  };
+  try {
+    return require('node:sqlite');
+  } catch {
+    return null;
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+}
+
+function opencodeDbPath(env = process.env) {
+  const dataDir = env.XDG_DATA_HOME
+    ? path.join(env.XDG_DATA_HOME, 'opencode')
+    : path.join(getHomeDir(env), '.local', 'share', 'opencode');
+  if (env.OPENCODE_DB) return path.isAbsolute(env.OPENCODE_DB) ? env.OPENCODE_DB : path.join(dataDir, env.OPENCODE_DB);
+  return path.join(dataDir, 'opencode.db');
+}
+
+const SESSIONS_SQL = 'SELECT id, directory, parent_id AS parentId, agent FROM session ORDER BY time_created DESC LIMIT ?';
+const MESSAGES_SQL = `SELECT id, time_created AS createdAt, json_extract(data, '$.role') AS role, json_extract(data, '$.agent') AS agent
+  FROM message WHERE session_id = ? ORDER BY time_created, id`;
+const PARTS_SQL = `SELECT p.message_id AS messageId, json_extract(p.data, '$.type') AS type, json_extract(p.data, '$.text') AS text,
+  json_extract(p.data, '$.tool') AS tool, json_extract(p.data, '$.synthetic') AS synthetic
+  FROM part p JOIN message m ON m.id = p.message_id WHERE m.session_id = ? ORDER BY p.id`;
+
+function isoOf(ms) {
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : null;
+}
+
+function sessionObjects(db, session) {
+  const parts = new Map();
+  for (const p of db.prepare(PARTS_SQL).all(session.id)) {
+    if (!parts.has(p.messageId)) parts.set(p.messageId, []);
+    parts.get(p.messageId).push(p);
+  }
+  const head = {};
+  if (typeof session.directory === 'string' && session.directory) head.cwd = session.directory;
+  if (session.agent === 'plan') head.planMode = true;
+  const objects = [head];
+  for (const m of db.prepare(MESSAGES_SQL).all(session.id)) {
+    const timestamp = isoOf(Number(m.createdAt));
+    const own = parts.get(m.id) || [];
+    if (m.agent === 'plan') head.planMode = true;
+    if (m.role === 'user') {
+      const text = own.filter((p) => p.type === 'text' && !p.synthetic && typeof p.text === 'string').map((p) => p.text).join('').trim();
+      if (text) {
+        objects.push({ type: 'user', timestamp, message: { role: 'user', content: [{ type: 'text', text }] } });
+        continue;
+      }
+    }
+    const uses = own.filter((p) => p.type === 'tool' && typeof p.tool === 'string' && p.tool).map((p) => ({ type: 'tool_use', name: p.tool }));
+    const o = timestamp ? { timestamp } : {};
+    if (uses.length) o.message = { role: 'assistant', content: uses };
+    if (o.timestamp || o.message) objects.push(o);
+  }
+  return objects;
+}
+
+function readOpencodeSessions(env, limit) {
+  const file = opencodeDbPath(env);
+  if (!fs.existsSync(file)) return [];
+  const sqlite = loadSqlite();
+  const Database = sqlite && (sqlite.DatabaseSync || sqlite.Database);
+  if (!Database) return [];
+  let db;
+  try {
+    db = new Database(file, { readOnly: true });
+    return db.prepare(SESSIONS_SQL).all(limit).map((session) => ({
+      file: `${file}#${session.id}`,
+      objects: sessionObjects(db, session),
+      subagent: Boolean(session.parentId),
+    }));
+  } catch {
+    return [];
+  } finally {
+    if (db) db.close();
+  }
+}
+
+module.exports = { readOpencodeSessions, opencodeDbPath };

package/src/profile-agents.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { requestListAgents } = require('./agents-client');
+const { getAgentsListEndpoint } = require('./config');
+const { ensureFreshSession } = require('./session-refresh');
+
+const TALENT_ADDED_SOURCES = new Set(['DECLARED_BY_TALENT', 'CLI_DETECTED']);
+
+async function fetchProfileAgentNames(env = process.env, deps = {}) {
+  const {
+    refresh = ensureFreshSession,
+    list = requestListAgents,
+    endpoint = getAgentsListEndpoint(env),
+  } = deps;
+  try {
+    const session = await refresh(env);
+    if (!session || !session.hubAccessToken) return [];
+    const listed = await list({ accessToken: session.accessToken, hubAccessToken: session.hubAccessToken }, { endpoint });
+    if (!listed || !listed.ok || !Array.isArray(listed.agents)) return [];
+    return listed.agents.filter((a) => a && TALENT_ADDED_SOURCES.has(a.source) && a.name).map((a) => a.name);
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { fetchProfileAgentNames, TALENT_ADDED_SOURCES };

package/src/render-report-text.js

@@ -14,7 +14,7 @@ function renderFullReportText(report, maturity, aiProfile, { lang = 'en', gate }
   );
   let terminal = '';
   try {
-    terminal = stripAnsi(renderTerminal(report, maturity, lang, { gate: gate || reportGateForIdentity() }))
+    terminal = stripAnsi(renderTerminal(report, maturity, lang, { gate: { ...(gate || reportGateForIdentity()), showRoadmap: false } }))
       .replace(/[ \t]+$/gm, '')
       .replace(/\n{3,}/g, '\n\n')
       .trim();