shakers-cli-beta 0.8.0-beta.5 → 0.10.0

package/src/mcp-register-tools.js

@@ -1,163 +1,9 @@
 'use strict';
 
-const {
-  FREELANCE_TYPES, WORK_SITUATIONS, EMPLOYMENT_PARTICIPATIONS, FREELANCE_OPINIONS,
-  CHANGE_MOTIVATORS, WORK_MODES, MONTHLY_HOURS, LANGUAGE_CODES, LANGUAGE_LEVELS,
-} = require('./onboarding-flow');
-const { getCatalog } = require('./i18n');
 const { TranscriptBuffer } = require('./interview-transcript');
+const { askChoice } = require('./mcp-choice');
 
-const MONTHLY_HOURS_QUOTED = MONTHLY_HOURS.map((h) => `'${h}'`).join(', ');
-const MONTHLY_HOURS_SLASHED = MONTHLY_HOURS.join('/');
-
-// "Friendly label (CODE)" list from an i18n label map: the talent sees the label, the model passes the canonical code.
-function labelledOptions(codes, labels) {
-  return codes.map((code) => `${labels[code] || code} (${code})`).join(', ');
-}
-
-function buildSchemas(lang) {
-  const L = getCatalog(lang).onboarding;
-  const showLabel = 'Show the talent the label, pass the code';
-
-  const ACCOUNT_FIELDS = {
-    name: { type: 'string', description: "The talent's first name, as they give it in the chat." },
-    lastName: { type: 'string', description: "The talent's last name, as they give it in the chat." },
-    email: { type: 'string', description: "The talent's own email address, used as their account login. They give it in the chat." },
-    preferredLanguage: { type: 'string', enum: ['ES', 'EN', 'IT', 'PT', 'FR'], description: 'Preferred language as an UPPERCASE ISO code. Optional — defaults to the session language.' },
-    newsletterConsent: { type: 'boolean', description: 'Whether the talent agrees to receive the newsletter. Optional, defaults to false.' },
-    freelanceType: { type: 'string', enum: FREELANCE_TYPES, description: `How the talent is set up to work. ${showLabel}: ${labelledOptions(FREELANCE_TYPES, L.freelanceTypeLabels)}. Distinct from workSituation below (that is the CURRENT freelance/employed/etc situation).` },
-  };
-
-  const WORK_SITUATION_SCHEMA = {
-    type: 'object',
-    description: "The talent's current work situation (ADR-036), asked once after account creation — the same question the web's registration flow asks. NOT the same thing as freelanceType above.",
-    properties: {
-      situation: { type: 'string', enum: WORK_SITUATIONS, description: `Current work situation. ${showLabel}: ${labelledOptions(WORK_SITUATIONS, L.workSituationLabels)}. 'EMPLOYED' requires participation below.` },
-      participation: { type: 'string', enum: EMPLOYMENT_PARTICIPATIONS, description: `Only when situation is 'EMPLOYED'. ${showLabel}: ${labelledOptions(EMPLOYMENT_PARTICIPATIONS, L.employmentParticipationLabels)}.` },
-      opinion: { type: 'string', enum: FREELANCE_OPINIONS, description: `The talent's opinion on freelancing. ${showLabel}: ${labelledOptions(FREELANCE_OPINIONS, L.freelanceOpinionLabels)}. Required unless situation is 'FREELANCE' (implied ALREADY_FREELANCE).` },
-      changeMotivators: { type: 'string', enum: CHANGE_MOTIVATORS, description: `What motivates the talent about freelancing/Shakers. ${showLabel}: ${labelledOptions(CHANGE_MOTIVATORS, L.changeMotivatorLabels)}. Required only when the talent is or is considering freelance (situation 'FREELANCE', or opinion 'WAS_FREELANCE_BEFORE'/'OPEN_TO_FREELANCE'); omit when opinion is 'NOT_INTERESTED'.` },
-    },
-    required: ['situation'],
-  };
-
-  const LANGUAGES_SCHEMA = {
-    type: 'array',
-    description: `Languages the talent speaks (ADR-036). ALWAYS ask this — it must not be skipped. ${showLabel}. Language options: ${labelledOptions(LANGUAGE_CODES, L.languageNames)}; and for each language a level: ${labelledOptions(LANGUAGE_LEVELS, L.languageLevelLabels)}. Bulk upsert — send the talent’s FULL language list. Omit only if the talent explicitly declines.`,
-    items: {
-      type: 'object',
-      properties: {
-        language: { type: 'string', enum: LANGUAGE_CODES, description: `Language code. ${showLabel}: ${labelledOptions(LANGUAGE_CODES, L.languageNames)}.` },
-        level: { type: 'string', enum: LANGUAGE_LEVELS, description: `Language level. ${showLabel}: ${labelledOptions(LANGUAGE_LEVELS, L.languageLevelLabels)}.` },
-      },
-      required: ['language', 'level'],
-    },
-  };
-
-  const AVAILABILITY_SCHEMA = {
-    type: 'object',
-    description: `Availability AND location (ADR-028). ALWAYS ask this — it must not be skipped. There is NO separate location field: the talent's LOCATION (country, timezone, region) lives here. Offer the options: available (yes/no); monthlyHours must be one of ${MONTHLY_HOURS_QUOTED}; workModes is a MULTI-VALUE array, any combination of ${WORK_MODES.join('/')} (the talent can pick several); longFullTimeProjects (yes/no — open to long full-time projects). For location, ask the talent their country and timezone (region is optional). All fields optional/nullable, but collect what you can. monthlyHours is a STRICT enum string (not an int). city is not collected here.`,
-    properties: {
-      available: { type: 'boolean', description: 'Whether the talent is currently available (yes/no).' },
-      monthlyHours: { type: 'string', enum: MONTHLY_HOURS, description: `Monthly hours the talent can work, exactly one of: ${MONTHLY_HOURS_QUOTED} (send '> 160' verbatim, with the space).` },
-      workModes: { type: 'array', items: { type: 'string', enum: WORK_MODES }, description: `Work modes the talent accepts — a combinable array, any subset of ${WORK_MODES.join('/')} (e.g. ['REMOTE','HYBRID']). Only REMOTE means the talent will not see hybrid or on-site projects.` },
-      country: { type: 'string', description: 'LOCATION — ISO-2 country code, 2 letters (e.g. ES, US, GB).' },
-      timezone: { type: 'string', description: 'LOCATION — IANA timezone (e.g. Europe/Madrid, America/New_York). Max 100 chars.' },
-      subdivision: { type: 'string', description: 'LOCATION — optional region/state code (e.g. ES-CT). Max 10 chars.' },
-      longFullTimeProjects: { type: 'boolean', description: 'Whether the talent is open to long full-time projects (yes/no).' },
-    },
-  };
-
-  const REGISTER_SCHEMA = {
-    type: 'object',
-    properties: {
-      ...ACCOUNT_FIELDS,
-      profile: PROFILE_SCHEMA,
-      workSituation: WORK_SITUATION_SCHEMA,
-      pricing: PRICING_SCHEMA,
-      availability: AVAILABILITY_SCHEMA,
-      languages: LANGUAGES_SCHEMA,
-      phone: PHONE_SCHEMA,
-    },
-    required: ['name', 'lastName', 'email', 'freelanceType', 'profile', 'workSituation', 'pricing'],
-  };
-
-  // Same shape as REGISTER_SCHEMA but NOTHING is required: the preview accepts a
-  // partial, pre-filled payload and reports what is still missing.
-  const PREVIEW_SCHEMA = {
-    type: 'object',
-    description: 'A partial, pre-filled register payload to REVIEW before writing. Every field is optional — fill only what the talent has said or what is verifiable from context, omit the rest. Returns what WOULD be written, what is still missing to ask, and any invalid values. Writes nothing.',
-    properties: { ...REGISTER_SCHEMA.properties },
-  };
-
-  return { ACCOUNT_FIELDS, WORK_SITUATION_SCHEMA, LANGUAGES_SCHEMA, AVAILABILITY_SCHEMA, REGISTER_SCHEMA, PREVIEW_SCHEMA };
-}
-
-// The register tool's own long description, per language: the batched
-// collection guide with friendly labels inline for every choice field.
-function buildRegisterDescription(lang) {
-  const L = getCatalog(lang).onboarding;
-  return "The talent registers THEMSELVES on Shakers (self-service; no prior session needed). Your job is to relay the non-secret profile details the talent gives you in the chat as arguments. Credentials never touch the chat or any tool argument: the tool opens a sign-up window on the talent's own machine (127.0.0.1) where they either Continue with Google (no password at all) or type an email and password directly into that local window.\n\nGO STRAIGHT TO A FILLED DRAFT — never open with a questionnaire or a list of what you do not know. (1) Your FIRST reply is one short question: may you search for and read their CV on this machine to fill everything in? (skip it if they already said yes). (2) With their yes: call suggest_register_context with talentName = the name you know, then read_cv the candidates (nameMatch first, then generic ones like cv.pdf) with talentConsent:true and talentName, until one returns mentionsTalent:true; a CV with mentionsTalent:false belongs to someone else: drop it and never show or use anything from it. From their CV take LinkedIn/GitHub (links), experience, education, languages and location; pass paths exactly as given (the short ~/ form is fine). If they say no, there is no CV, or none of the CVs is theirs, do NOT fall back to questions: build the same draft from everything else you know about them — your memory of past conversations, a search of those conversations if you have that tool, this conversation and any context or memory files you can see; the CV adds facts, it is never a precondition. (3) Pre-fill EVERY field: identity from git/your memory/the CV; workSituation from what you know (a company email or employer in memory or CV means employed there — propose it); `pricing` ALWAYS as a concrete per-project estimate from their role, seniority, stack and location, labelled as your estimate (ask only if you know nothing about their work); `workSituation.changeMotivators` as your best match; availability, languages and country from context. What you know about the person outranks git: if the git identity is someone else, ignore it. (4) Call register_preview and show ONE summary that says where each value comes from, for the talent to confirm or correct in one reply. Required fields you truly have no basis for go in one short question at the end; optional unknowns (phone, website, newsletter) in a single 'si quieres' line, never as missing items. (5) After their confirmation, call register. The sign-up goes to suggest_register_context's `environment` (local/development/staging/production): name it correctly and never call a test environment production. All of this is self-declared profile data.\n\nFor whatever you still have to ASK (only what you could not infer), ask in ONE grouped message, not one field at a time, and for every CHOICE field PRESENT THE VALID OPTIONS so the talent just picks one. For every choice field SHOW THE TALENT THE FRIENDLY LABEL, never the raw code (e.g. show 'Nativo', not 'NATIVE'), and pass the code as the value. Fields, grouped:\n1. Identity — name, lastName, email (optional: preferredLanguage, newsletterConsent).\n2. Profile — `profile.linkedinUrl` (required source; optional GitHub/website/CV path).\n3. Work — freelanceType (offer: "
-    + labelledOptions(FREELANCE_TYPES, L.freelanceTypeLabels)
-    + ") and `workSituation` (offer situation: "
-    + labelledOptions(WORK_SITUATIONS, L.workSituationLabels)
-    + "; participation "
-    + labelledOptions(EMPLOYMENT_PARTICIPATIONS, L.employmentParticipationLabels)
-    + " only when EMPLOYED; opinion "
-    + labelledOptions(FREELANCE_OPINIONS, L.freelanceOpinionLabels)
-    + " unless FREELANCE; changeMotivators "
-    + labelledOptions(CHANGE_MOTIVATORS, L.changeMotivatorLabels)
-    + " when the talent is or is considering freelance).\n4. Pricing — per-PROJECT price; currency USD, EUR or GBP.\n5. Availability + languages — `availability` (offer monthlyHours "
-    + MONTHLY_HOURS_SLASHED
-    + ", workModes as a combinable array of " + WORK_MODES.join('/') + ", longFullTimeProjects yes/no, and LOCATION: country as ISO-2 e.g. ES, timezone as IANA e.g. Europe/Madrid) and `languages` (offer "
-    + labelledOptions(LANGUAGE_CODES, L.languageNames)
-    + ", each with a level "
-    + labelledOptions(LANGUAGE_LEVELS, L.languageLevelLabels)
-    + ").\n6. Contact — `phone` (telephoneCode e.g. +34 and telephoneNumber).\n\nALWAYS ask for availability (including location), languages and phone — they are expected, not optional extras; only omit one if the talent explicitly declines. There is NO separate location field: location (country/timezone/region) is part of `availability`.\n\nOnce the window completes the account exists and the session is set; the tool then starts the background profile import, saves the work situation, per-PROJECT pricing (ADR-024), and any availability/languages/phone provided. If the account already exists, the tool returns { accountAlreadyExists: true } — switch to the login tool (method 'google') instead. Returns { importJobId, next, disclaimers, profileUrl }. `next` is 'ai_usage' when the talent has no prior AI-usage evidence (offer step 4, the ai_usage tool) or 'onboarding_interview_start' when they already do (step 4 is skipped). When you run ai_usage as this step, pass the returned `usageRepoScope` ({ mode: 'all' }) — registration always measures the whole machine, never a single repo. Before running ai_usage OR onboarding_interview_start, show the talent the matching `disclaimers` block, its two parts (info accessed, goal+duration) separately. Poll register_status with the importJobId to track the import. Always finish any path by calling onboarding_finish (whether or not the talent takes steps 4 and 5) — that is what marks the onboarding complete and moves the talent's registration level.";
-}
-
-const PHONE_SCHEMA = {
-  type: 'object',
-  description: "Phone (ADR-036). ALWAYS ask this — it must not be skipped. Two parts: telephoneCode = the international dialling code (e.g. +34, +1, +44), telephoneNumber = the local number. Omit only if the talent explicitly declines to share it.",
-  properties: {
-    telephoneCode: { type: 'string', description: "International dialling code, e.g. '+34', '+1', '+44'. Max 10 chars." },
-    telephoneNumber: { type: 'string', description: 'Local phone number. Max 20 chars.' },
-  },
-  required: ['telephoneCode', 'telephoneNumber'],
-};
-
-const PROFILE_SCHEMA = {
-  type: 'object',
-  properties: {
-    linkedinUrl: { type: 'string', description: "The talent's LinkedIn URL. Required — it is the mandatory profile source." },
-    cvPath: { type: 'string', description: 'Path to the CV (PDF/DOC/DOCX, max 10 MB) on this machine, absolute or ~/... (optional). Only a CV the talent confirmed is theirs. The FILE is uploaded to Shakers with the profile import.' },
-    githubUrl: { type: 'string', description: 'GitHub URL (optional).' },
-    websiteUrl: { type: 'string', description: 'Personal website URL (optional).' },
-  },
-  required: ['linkedinUrl'],
-};
-
-const PRICING_SCHEMA = {
-  type: 'object',
-  description: 'Per-PROJECT pricing (ADR-024). NOT hourly or annual. Amounts are the whole project price as a plain number, no thousands separators, at most 2 decimals, 0..999999.99. Currency is USD, EUR or GBP. The full-time (standard) price is the primary one and should always be captured, exactly as the CLI asks it; part-time is an additional modality. At least one variant must be selected.',
-  properties: {
-    fullTimeSelected: { type: 'boolean', description: 'Whether the talent offers full-time projects. This standard/full-time price is the primary one — capture it by default.' },
-    fullTimeAmount: { type: 'number', description: 'Full-time (standard) per-project price, plain number without thousands separators (e.g. 60000).' },
-    fullTimeCurrency: { type: 'string', enum: ['USD', 'EUR', 'GBP'], description: 'Currency for the full-time price.' },
-    partTimeSelected: { type: 'boolean', description: 'Whether the talent also offers part-time projects (additional modality).' },
-    partTimeAmount: { type: 'number', description: 'Part-time per-project price, plain number without thousands separators (e.g. 50).' },
-    partTimeCurrency: { type: 'string', enum: ['USD', 'EUR', 'GBP'], description: 'Currency for the part-time price.' },
-  },
-};
-
-// Default (English) static exports for callers/tests that read the module-level
-// schemas directly. The live tools rebuild these per session language.
-const { ACCOUNT_FIELDS, WORK_SITUATION_SCHEMA, LANGUAGES_SCHEMA, AVAILABILITY_SCHEMA, REGISTER_SCHEMA, PREVIEW_SCHEMA } = buildSchemas('en');
-
-const STATUS_SCHEMA = {
-  type: 'object',
-  properties: { jobId: { type: 'string', description: 'The importJobId returned by register — an internal handle for polling; never shown or mentioned to the talent.' } },
-  required: ['jobId'],
-};
+const ANSWER_MODES = ['drafted', 'own', 'full'];
 
 const INTERVIEW_START_SCHEMA = {
   type: 'object',
@@ -166,7 +12,17 @@ const INTERVIEW_START_SCHEMA = {
     language: { type: 'string', enum: ['es', 'en'] },
     disclaimerAcknowledged: {
       type: 'boolean',
-      description: 'Must be true. Set it only after showing the talent BOTH interview disclaimers separately (info accessed AND goal+duration) from the register response, and getting their agreement.',
+      description: 'Must be true. Set it only after showing the talent both interview disclaimers word for word, each as its own block (from signup_status or from this tool called without it), and getting their agreement.',
+    },
+    where: {
+      type: 'string',
+      enum: ['here', 'later'],
+      description: "The talent's pick to 'here now or later on the web?'. Omit it to have the tool ask: in a dialog when the client has one, otherwise it returns the question with its options.",
+    },
+    answerMode: {
+      type: 'string',
+      enum: ANSWER_MODES,
+      description: "The talent's pick to the answer-mode question: drafted = you propose each answer and they approve or edit it, own = they answer themselves, full = you answer every question yourself. Required with disclaimerAcknowledged:true; omit it to have the tool ask, in a dialog or as options it returns.",
     },
     confirmRepeat: {
       type: 'boolean',
@@ -180,7 +36,7 @@ const INTERVIEW_TURN_SCHEMA = {
   type: 'object',
   properties: {
     interviewId: { type: 'string', description: 'Internal handle for this interview — for calling the interview tools ONLY; never shown or mentioned to the talent.' },
-    message: { type: 'string', description: "The talent's answer to the current question: in conduit mode their REAL, VERBATIM words; in AI-drafted mode (only if the talent opted in) the answer they APPROVED after seeing your draft, with their edits. Never a value they have not seen and confirmed. If they have not answered or approved yet, do NOT call this." },
+    message: { type: 'string', description: "The talent's answer to the current question: in 'own' mode their REAL, VERBATIM words; in 'drafted' mode the answer they APPROVED or edited after seeing your proposal; in 'full' mode (or once they explicitly asked you to answer the rest yourself) your own answer built only from what they confirmed. Outside 'full' mode never a value they have not seen and confirmed: if they have not answered or approved yet, do NOT call this." },
   },
   required: ['interviewId', 'message'],
 };
@@ -193,26 +49,37 @@ const INTERVIEW_COMPLETE_SCHEMA = {
 
 const FINISH_SCHEMA = { type: 'object', properties: {} };
 
+const LIVEKIT_LOAD_FAILURES = new Set(['livekit-not-installed', 'livekit-no-text-streams']);
+
+// No telemetry ships in this package: stderr reaches the MCP client's server log, with what is needed to size the gap.
+function defaultReportLivekitFailure(kind, error) {
+  const cause = error && error.cause && error.cause.message ? error.cause.message : (error && error.message) || '';
+  process.stderr.write(`  [mcp] livekit-unavailable kind=${kind} os=${process.platform} arch=${process.arch} node=${process.version} cause=${JSON.stringify(cause.slice(0, 300))}\n`);
+}
+
+// The last interview this process completed: the main-role step waits for its evaluation.
+let lastCompletedInterview = null;
+
+function completedOnboardingInterview() {
+  return lastCompletedInterview;
+}
+
 function makeRegisterTools(deps = {}) {
   const flow = require('./onboarding-flow');
   const resolved = flow.makeDeps(deps.flowDeps || {});
   const lang = deps.lang || 'en';
-  const schemas = buildSchemas(lang);
-  const registerDescription = buildRegisterDescription(lang);
   // Same confirmation copy the CLI prints ("Price saved.", …), reused verbatim.
   const catalog = require('./i18n').getCatalog(lang).onboarding;
-  const runLoopbackAuth = deps.runLoopbackAuth || require('./mcp-auth-form').runLoopbackAuth;
+  // The talent's sign-up language, for what this tool asks them in the chat.
+  const textLang = () => require('./signup-language').signupLanguage(lang);
+  const copy = () => require('./signup-copy').signupCopy(textLang());
   const checkCompleted = deps.checkOnboardingCompleted || require('./onboarding-availability').checkOnboardingCompleted;
 
   // The LiveKit room is a live WebRTC connection that must survive between the
   // separate start/turn/complete JSON-RPC calls of this long-lived stdio server.
   const interviewSessions = new Map();
 
-  function connectHint(kind) {
-    if (kind === 'livekit-not-installed') return catalog.livekitMissing;
-    if (kind === 'livekit-no-text-streams') return catalog.livekitOld;
-    return catalog.livekitConnectError;
-  }
+  const reportLivekitFailure = deps.reportLivekitFailure || defaultReportLivekitFailure;
 
   async function teardownInterview(interviewId, { persist = false } = {}) {
     const sess = interviewSessions.get(interviewId);
@@ -231,112 +98,29 @@ function makeRegisterTools(deps = {}) {
     return saved;
   }
 
-  async function register(args = {}) {
-    const registerFields = {
-      name: args.name,
-      lastName: args.lastName,
-      email: args.email,
-      preferredLanguage: args.preferredLanguage,
-      newsletterConsent: args.newsletterConsent === true,
-      freelanceType: args.freelanceType,
-    };
-    const check = flow.validateRegisterFields(registerFields);
-    if (!check.ok) return { ok: false, step: 'signup', reason: check.reason };
-
-    const created = await runLoopbackAuth({ mode: 'register', deps: resolved, lang, registerFields });
-    if (created.viaGoogle) {
-      // Social registration is the device flow (start/poll tools), not this single blocking call.
-      return {
-        ok: false,
-        step: 'signup',
-        reason: 'use-device-flow',
-        next: 'social_signin_start',
-        mode: 'register',
-        message: `To register with a social provider, call social_signin_start (provider "google" or "linkedin", mode "register", freelanceType "${registerFields.freelanceType || ''}") to get a URL and code to show the talent, then social_signin_poll. Once it returns authorized, run the profile steps (import, work situation, pricing).`,
-      };
-    }
-    if (!created.ok) {
-      return { ok: false, step: 'signup', reason: created.reason };
-    }
-
-    const profile = args.profile || {};
-    const importRes = await flow.startProfileImport(resolved, {
-      linkedinUrl: profile.linkedinUrl,
-      cvPath: profile.cvPath,
-      githubUrl: profile.githubUrl,
-      websiteUrl: profile.websiteUrl,
-      language: lang,
-    });
-    const importOutcome = importRes.ok
-      ? { ok: true, jobId: importRes.jobId, state: importRes.state }
-      : { ok: false, reason: importRes.reason, warning: 'Profile import is unavailable right now; registration continues and the import can be retried later.' };
-
-    const workSituationRes = await flow.saveWorkSituation(resolved, args.workSituation || {});
-    if (!workSituationRes.ok) return { ok: false, step: 'work-situation', reason: workSituationRes.reason };
-
-    const priceRes = await flow.savePricing(resolved, args.pricing || {});
-    if (!priceRes.ok) return { ok: false, step: 'pricing', reason: priceRes.reason };
-
-    let availabilityOutcome = { skipped: true };
-    if (args.availability && typeof args.availability === 'object') {
-      const availRes = await flow.saveAvailability(resolved, args.availability);
-      availabilityOutcome = availRes.ok
-        ? { ok: true }
-        : { ok: false, reason: availRes.reason, warning: 'Availability could not be saved; registration continues and it can be set later.' };
-    }
-
-    let languagesOutcome = { skipped: true };
-    if (Array.isArray(args.languages) && args.languages.length > 0) {
-      const langRes = await flow.saveLanguages(resolved, args.languages);
-      languagesOutcome = langRes.ok
-        ? { ok: true }
-        : { ok: false, reason: langRes.reason, unresolved: langRes.unresolved, warning: 'Languages could not be saved; registration continues and they can be added later.' };
-    }
-
-    let phoneOutcome = { skipped: true };
-    if (args.phone && typeof args.phone === 'object') {
-      const phoneRes = await flow.savePhone(resolved, args.phone);
-      phoneOutcome = phoneRes.ok
-        ? { ok: true }
-        : { ok: false, reason: phoneRes.reason, warning: 'Phone could not be saved; registration continues and it can be set later.' };
-    }
-
-    const prior = await flow.detectPriorUsage(resolved);
-    const hasEvidence = prior.ok ? prior.hasEvidence : null;
-
-    // Human-readable confirmations, identical to the CLI step notices.
-    const confirmations = [catalog.accountReady, catalog.professionalSaved, catalog.pricingSaved];
-    if (importOutcome.ok) confirmations.push(catalog.importDone);
-    if (availabilityOutcome.ok) confirmations.push(catalog.availabilitySaved);
-    if (languagesOutcome.ok) confirmations.push(catalog.languagesSaved);
-    if (phoneOutcome.ok) confirmations.push(catalog.phoneSaved);
+  function interviewLater() {
+    return { ok: false, reason: 'interview-later', message: 'The talent does the interview later on the web: skip it here and go on with the main role, then open_web.' };
+  }
 
-    return {
-      ok: true,
-      message: catalog.accountReady,
-      confirmations,
-      import: importOutcome,
-      importJobId: importOutcome.jobId || null,
-      availability: availabilityOutcome,
-      languages: languagesOutcome,
-      phone: phoneOutcome,
-      priorUsage: { hasEvidence },
-      next: hasEvidence === true ? 'onboarding_interview_start' : 'ai_usage',
-      usageRepoScope: { mode: 'all' },
-      disclaimers: {
-        usage: flow.usageDisclaimers(lang),
-        interview: flow.interviewDisclaimers(lang),
-      },
-      profileUrl: flow.profileUrl(resolved),
-    };
+  async function askWhere(args, ctx) {
+    if (args.where === 'here') return { here: true };
+    if (args.where === 'later') return { here: false };
+    const c = copy();
+    const asked = await askChoice(ctx, { question: c.interviewWhereQuestion, options: [c.interviewHere, c.interviewLater] });
+    if (asked.answer) return { here: asked.answer === c.interviewHere };
+    return { chat: asked.chat, dismissed: asked.dismissed };
   }
 
-  async function registerStatus(args = {}) {
-    const res = await flow.pollProfileImport(resolved, { jobId: args.jobId });
-    return res.ok ? { ok: true, state: res.state } : { ok: false, reason: res.reason };
+  async function askAnswerMode(args, ctx) {
+    if (ANSWER_MODES.includes(args.answerMode)) return { mode: args.answerMode };
+    const c = copy();
+    const labels = { drafted: c.answerModeDrafted, own: c.answerModeOwn, full: c.answerModeFull };
+    const asked = await askChoice(ctx, { question: c.answerModeQuestion, options: ANSWER_MODES.map((m) => labels[m]) });
+    if (asked.answer) return { mode: ANSWER_MODES.find((m) => labels[m] === asked.answer) };
+    return { chat: asked.chat, dismissed: asked.dismissed };
   }
 
-  async function interviewStart(args = {}) {
+  async function interviewStart(args = {}, ctx = {}) {
     let alreadyCompleted = false;
     try {
       alreadyCompleted = await checkCompleted({});
@@ -353,18 +137,39 @@ function makeRegisterTools(deps = {}) {
       };
     }
     if (args.disclaimerAcknowledged !== true) {
+      const where = await askWhere(args, ctx);
+      if (where.here === false) return interviewLater();
+      const disclaimers = flow.interviewDisclaimers(textLang());
+      const show = 'show the talent each relayVerbatim text word for word, each as its own block, with no titles, labels or bold of your own, then call again with disclaimerAcknowledged:true.';
       return {
         ok: false,
         reason: 'disclaimers-not-acknowledged',
-        disclaimers: flow.interviewDisclaimers(lang),
-        message: 'Show the talent BOTH interview disclaimers separately (info accessed AND goal+duration), then call again with disclaimerAcknowledged:true.',
+        relayVerbatim: [disclaimers.infoAccessed, disclaimers.goalDuration],
+        ...(where.chat ? { where: where.chat } : {}),
+        ...(where.dismissed ? { dismissed: where.dismissed } : {}),
+        message: where.chat
+          ? `First ask \`where.question\` with its \`where.options\` (your native choice buttons if you have them, otherwise a short numbered list; accept the number or the text). If they pick the web, call again with where:"later". If they pick here, ${show}`
+          : `The talent does it here: ${show}`,
+      };
+    }
+    const answer = await askAnswerMode(args, ctx);
+    if (answer.chat) {
+      return {
+        ok: false,
+        reason: 'answer-mode-required',
+        ...(answer.dismissed ? { dismissed: answer.dismissed } : {}),
+        ...answer.chat,
+        message: `${answer.chat.choiceMessage} Then call again with disclaimerAcknowledged:true and answerMode: drafted for the first option, own for the second, full for the third.`,
       };
     }
     const start = await flow.createAndStartLivekitOnboarding(resolved, {
       candidateId: args.candidateId,
       language: args.language || lang,
     });
-    if (!start.ok) return { ok: false, step: start.step || 'start', reason: start.reason };
+    if (!start.ok) {
+      const out = { ok: false, step: start.step || 'start', reason: start.reason };
+      return start.reason === 'interview-already-started' ? { ...out, next: 'open_web' } : out;
+    }
 
     const closing = start.closingMessage;
     const isClosing = closing ? (t) => typeof t === 'string' && t.includes(closing) : null;
@@ -376,7 +181,9 @@ function makeRegisterTools(deps = {}) {
     } catch (e) {
       try { await client.disconnect(); } catch { /* nothing joined */ }
       const kind = (e && e.kind) || 'connect-failed';
-      return { ok: false, step: 'connect', reason: kind, message: connectHint(kind) };
+      if (LIVEKIT_LOAD_FAILURES.has(kind)) reportLivekitFailure(kind, e);
+      // Whatever kept the room from opening here, the same interview runs on the web.
+      return { ok: false, step: 'connect', reason: kind, relayVerbatim: copy().livekitUnavailable, message: 'Show relayVerbatim word for word, then open_web.', next: 'open_web' };
     }
 
     let opening;
@@ -388,7 +195,7 @@ function makeRegisterTools(deps = {}) {
     }
     buffer.recordAgent(opening.text);
     interviewSessions.set(start.interviewId, { client, buffer, connectAt: Date.now(), ended: opening.ended === true });
-    return { ok: true, interviewId: start.interviewId, greeting: opening.text, ended: opening.ended === true };
+    return { ok: true, interviewId: start.interviewId, answerMode: answer.mode, greeting: opening.text, ended: opening.ended === true };
   }
 
   async function interviewTurn(args = {}) {
@@ -418,6 +225,7 @@ function makeRegisterTools(deps = {}) {
     }
     const saved = await teardownInterview(args.interviewId, { persist: true });
     if (!saved.ok) return { ok: false, reason: saved.reason || 'complete-failed' };
+    lastCompletedInterview = { interviewId: args.interviewId, completedAt: Date.now() };
     return { ok: true, state: 'taken', message: catalog.interviewComplete };
   }
 
@@ -426,7 +234,7 @@ function makeRegisterTools(deps = {}) {
     const reset = await flow.restartOnboarding(resolved);
     if (!reset.ok) {
       if (reset.reason === 'onboarding-not-found') {
-        return { ok: false, reason: 'onboarding-not-found', message: 'The talent has no onboarding interview yet — run the normal onboarding first (register + onboarding_interview_start), nothing to repeat.' };
+        return { ok: false, reason: 'onboarding-not-found', message: 'The talent has no onboarding interview yet: nothing to repeat. Offer onboarding_interview_start instead.' };
       }
       return { ok: false, reason: reset.reason };
     }
@@ -454,11 +262,6 @@ function makeRegisterTools(deps = {}) {
     };
   }
 
-  // PURE preview: reuses the write-path validators, touches no network, no session.
-  async function registerPreview(args = {}) {
-    return flow.buildRegisterPreview(args || {});
-  }
-
   // Content-free context the model may PROPOSE to the talent (never auto-write).
   async function suggestContext(args = {}) {
     const read = deps.readRegisterContextSuggestions || require('./register-context').readRegisterContextSuggestions;
@@ -477,27 +280,15 @@ function makeRegisterTools(deps = {}) {
   }
 
   return [
-    {
-      name: 'register',
-      description: registerDescription,
-      inputSchema: schemas.REGISTER_SCHEMA,
-      handler: register,
-    },
-    {
-      name: 'register_preview',
-      description: "REVIEW a (partial) register payload BEFORE writing — the preferred way to register with the least typing. Fill every field you can reasonably infer, then call this. It writes NOTHING; it returns { wouldWrite: the normalized data per hub endpoint, missingFields: what is still needed (required:true) or just suggested (required:false) to ASK the talent, warnings: any value that is invalid, mustConfirm }. Show the talent a short human summary of wouldWrite and the missing items, let them confirm or correct, then call `register` with the final payload. Pre-fill every field you can reasonably infer (memory, chat, context), including pricing and changeMotivators; omit only what you have no basis for. The talent confirms the whole summary once; fields in `mustConfirm` just need to be visible in that summary, not asked separately. All register data is self-declared profile data.",
-      inputSchema: schemas.PREVIEW_SCHEMA,
-      handler: registerPreview,
-    },
     {
       name: 'suggest_register_context',
-      description: "Local SUGGESTIONS to fill the registration (no network, no file contents): `environment` the sign-up goes to (local/development/staging/production — name it correctly, never call a test environment production), timezone, git name/email, the GitHub login of the gh CLI (githubUser/githubUrl), and cvCandidates — PDF/DOC/DOCX files in Desktop, Documents, Downloads and iCloud Drive whose NAME looks like a CV or carries the talent's full name, each with nameMatch and generic flags (people who hire keep other people's CVs, so a candidate is only a lead: confirm it with read_cv). Pass talentName = the talent's name as you know it to sharpen the match. Propose values, never write without the talent's confirmation.",
+      description: "SUGGESTIONS for the sign-up read on this machine (no network, no file contents): timezone, git name/email, the gh CLI GitHub login, and cvCandidates: PDF/DOC/DOCX files in Desktop, Documents, Downloads and iCloud Drive whose NAME looks like a CV or carries the talent's name, each with nameMatch and generic flags. A candidate is only a lead (people who hire keep other people's CVs): confirm it with read_cv. Pass talentName to sharpen the match. Use it when the talent said you may look for their CV on this machine.",
       inputSchema: { type: 'object', properties: { talentName: { type: 'string', description: "The talent's full name as you know it (memory, chat); improves CV matching." } } },
       handler: suggestContext,
     },
     {
       name: 'read_cv',
-      description: "Read the TEXT of a CV file (PDF, DOC, DOCX) on this machine to fill the register and the onboarding from it. Call it once the talent has allowed you to search and read their CV (talentConsent:true), with talentName set. Returns { mentionsTalent, links: { linkedin, github, emails, phones }, text } for the talent's own CV; for a CV that does not name them it returns only mentionsTalent:false — it is someone else's: drop it, never describe it, try the next candidate. Local only: nothing is uploaded by this tool (the CV is sent to Shakers only as profile.cvPath in a confirmed register). On failure ask the talent to attach the CV to the chat.",
+      description: "Read the TEXT of a CV file (PDF, DOC, DOCX) on this machine, with the talent's permission (talentConsent:true) and talentName set. Returns { mentionsTalent, links: { linkedin, github, emails, phones }, text } for the talent's own CV; a CV that does not name them returns only mentionsTalent:false: it is someone else's, drop it, never describe it, try the next candidate. Nothing is uploaded by this tool: pass the confirmed path to signup_start (or import_profile) as cvPath, use the text for userQuery and the email, and links.linkedin as their LinkedIn URL.",
       inputSchema: {
         type: 'object',
         properties: {
@@ -509,15 +300,9 @@ function makeRegisterTools(deps = {}) {
       },
       handler: readCv,
     },
-    {
-      name: 'register_status',
-      description: 'Check the state of the background profile import started by register. Pass the importJobId (an internal handle — never shown to the talent). Returns { state } (e.g. running | done | failed).',
-      inputSchema: STATUS_SCHEMA,
-      handler: registerStatus,
-    },
     {
       name: 'onboarding_interview_start',
-      description: "Start the onboarding interview (step 5, optional). Runs over LiveKit: the server joins a live room and the agent conducts it, transparently resolving the branch (role/dedication only when AI-usage evidence exists, otherwise the AI-usage blocks too) — the client does NOT decide the branch. You MUST first show the talent BOTH interview disclaimers separately (from register's disclaimers.interview) and only then call with disclaimerAcknowledged:true. Returns { interviewId, greeting, ended }: relay the greeting to the talent VERBATIM, then drive the interview with onboarding_interview_turn. ANSWER MODE — before calling this, ASK the talent once: do they want you to draft their answers from what you already know about them (your memory of past conversations, the chat, the register data), so they only confirm, correct or add their opinion? (1) If they say YES (AI-drafted mode): FIRST gather everything you can know about them — your memory, a search of your past conversations with them if you have such a tool, their CV (read_cv, with their permission, if not read yet), their AI-usage report and the register data — and show ONE short sheet 'esto es lo que sé de ti' (roles and projects with the concrete facts, stack, languages, what they want next). Let them correct it once; those corrections override your memory for every later answer. Then for every interview question show the question VERBATIM and your proposed answer in the first person: one or two short sentences in their plain voice, built only from facts on the confirmed sheet — no embellishment, no adjectives, metrics or claims they did not give, no repeating a fact already said unless asked. If the sheet does not cover the question, do not guess a fact: ask them briefly. Ask them to confirm, edit or add their view. Send ONLY the version they approve — their edits and opinions included — never a draft they have not seen. For questions about wishes, preferences or opinions, give your best guess but make clear it is a guess. (2) If they say NO: you are a pure CONDUIT — show every question VERBATIM and pass only the talent's REAL, VERBATIM words back; do not opine, guide or answer for them. In both modes never reword, summarize or translate the interview's questions. `interviewId` is an internal handle for the interview tools only — never show or mention it to the talent. If it returns reason 'livekit-not-installed', relay the `message` (it tells the talent how to install the optional @livekit/rtc-node package). If the talent declines the interview, do not call this — instead run the final main-role step (list_my_roles + set_main_role) and offer them their profile URL from register. If the talent has ALREADY completed onboarding this refuses with an already-completed notice unless confirmRepeat:true; note a completed onboarding interview cannot actually be restarted (it returns reason 'interview-already-started') — in that case just run set_main_role.",
+      description: "Start the onboarding interview, here in the chat. Offer it only when signup_status says onboardingInterview.completed is not true. Call it first without disclaimerAcknowledged: it asks 'here now or later on the web?' (in a dialog when the client has one, otherwise it returns `where` with the question and its options to ask; default here) and returns the two interview disclaimers. reason 'interview-later' means they chose the web: skip the interview. If it returns reason 'interview-already-started' (begun elsewhere and not finished), call open_web so they continue on the web. It runs over LiveKit and the server agent conducts it; the client does not decide its branch. You MUST show the talent both interview disclaimers word for word, each as its own block, never paraphrased or relabelled, and only then call with disclaimerAcknowledged:true and answerMode (without answerMode it asks the answer-mode question in a dialog, or returns it with its options: ask it and call again). Returns { interviewId, answerMode, greeting, ended }: relay the greeting VERBATIM, then drive it with onboarding_interview_turn. ANSWER MODES. For drafted and full, first gather everything you know (memory, a search of past conversations if you have that tool, their CV, the ai_usage report, the sign-up data) and show ONE short sheet 'esto es lo que se de ti' (roles and projects with concrete facts, stack, languages, what they want next); let them correct it once; those corrections override your memory. Your answers are first person, one or two short sentences in their plain voice, built only from facts on the confirmed sheet: no embellishment, no adjectives, metrics or claims they did not give, no repeating a fact already said unless asked; for wishes, preferences or opinions give your best guess and say it is a guess. (1) drafted: show each question VERBATIM with your proposed answer and send it only after the talent approves or edits it; if the sheet does not cover a question, ask them briefly instead of guessing. Only if the talent explicitly asks you to answer everything yourself (for example 'hazla entera' or 'contéstalas tú todas'), answer the remaining questions without asking for each approval, as in full. (2) full (they chose it, or asked for it as above): answer every question yourself without per-answer approval, still showing each question and your answer, and when the interview ends tell them in one line that you answered those questions yourself. (3) own: you are a pure CONDUIT: show every question VERBATIM and pass back only their REAL, VERBATIM words. In every mode never reword, summarize or translate the questions. `interviewId` is internal: never show it. If it fails with next:'open_web', relay `message` and call open_web so they do the interview on the web.",
       inputSchema: INTERVIEW_START_SCHEMA,
       handler: interviewStart,
       available: async () => {
@@ -530,25 +315,25 @@ function makeRegisterTools(deps = {}) {
     },
     {
       name: 'onboarding_interview_turn',
-      description: "Send the talent's answer to the current onboarding-interview question and get the next one. Follow the ANSWER MODE the talent chose at onboarding_interview_start. AI-drafted mode: `message` is the answer the talent APPROVED after seeing your draft (with their edits/opinion); never send a draft they have not confirmed. Conduit mode: `message` is ONLY the talent's REAL, VERBATIM answer — never invent, infer or complete it. In both modes, if the talent has not answered or approved yet, do NOT call this, wait for them. Relay the returned `response` (the next question) to the talent VERBATIM — do not reword, summarize or translate it. Keep calling with their next `message` until `ended` is true, then call onboarding_interview_complete. Do NOT show or mention `interviewId` to the talent (internal handle). If it returns reason 'unknown-interview' (the server was restarted and the live room is gone), start again with onboarding_interview_start.",
+      description: "Send the talent's answer to the current onboarding-interview question and get the next one. Follow the answerMode the talent chose at onboarding_interview_start. drafted: `message` is the answer the talent APPROVED or edited after seeing your proposal; never send one they have not confirmed, unless they explicitly asked you to answer the rest yourself ('hazla entera', 'contéstalas tú todas'): from then on, as in full, send your own answers without per-answer approval. full: send your own answer to each question, built only from what they confirmed, and when it ends tell them you answered those questions yourself. own: `message` is ONLY the talent's REAL, VERBATIM answer — never invent, infer or complete it. Outside full, if the talent has not answered or approved yet, do NOT call this, wait for them. Relay the returned `response` (the next question) to the talent VERBATIM — do not reword, summarize or translate it. Keep calling with their next `message` until `ended` is true, then call onboarding_interview_complete. Do NOT show or mention `interviewId` to the talent (internal handle). If it returns reason 'unknown-interview' (the server was restarted and the live room is gone), start again with onboarding_interview_start.",
       inputSchema: INTERVIEW_TURN_SCHEMA,
       handler: interviewTurn,
     },
     {
       name: 'onboarding_interview_complete',
-      description: "Close the onboarding interview once the turns report ended:true: the buffered transcript is saved and the live room is disconnected. `interviewId` is an internal handle for the interview tools only — never show or mention it to the talent. Returns { state:'taken' }. If it returns reason 'unknown-interview' the room was already gone (server restart) — nothing to complete. After this, if this is first-time REGISTRATION, run the final registration step — offer the talent their main role with list_my_roles + set_main_role — then call onboarding_finish. If you got here from repeat_onboarding_interview (a re-run, not registration), SKIP the main-role step and go straight to onboarding_finish. To change the main role outside registration, the talent uses change-role.",
+      description: "Close the onboarding interview once the turns report ended:true: the buffered transcript is saved and the live room is disconnected. `interviewId` is internal: never show it. Returns { state:'taken' }. If it returns reason 'unknown-interview' the room was already gone (server restart): nothing to complete. In the sign-up flow, go on to the main role (list_my_roles with waitSeconds, then set_main_role) and finish with open_web; do NOT call onboarding_finish there.",
       inputSchema: INTERVIEW_COMPLETE_SCHEMA,
       handler: interviewComplete,
     },
     {
       name: 'repeat_onboarding_interview',
-      description: "OVERWRITE-repeat the onboarding interview: resets the talent's completed onboarding interview IN PLACE — the previous evaluation is DISCARDED and CANNOT be recovered. You MUST clearly warn the talent that this overwrites their previous onboarding and is irreversible, and get their explicit go-ahead, BEFORE calling this. On success run the interview again (onboarding_interview_start → onboarding_interview_turn until ended → onboarding_interview_complete), then onboarding_finish. This is a RE-RUN, not registration: do NOT run the main-role step (list_my_roles/set_main_role) afterwards — to change the main role outside registration the talent uses change-role. Returns { interviewId, language } or reason 'onboarding-not-found' (the talent has no onboarding yet — do the normal onboarding first), 'http-401'/'http-403'.",
+      description: "OVERWRITE-repeat the onboarding interview: resets the talent's completed onboarding interview IN PLACE; the previous evaluation is DISCARDED and CANNOT be recovered. Clearly warn the talent that this is irreversible and get their explicit go-ahead BEFORE calling this. On success run the interview again (onboarding_interview_start, onboarding_interview_turn until ended, onboarding_interview_complete), then onboarding_finish. Returns { interviewId, language } or reason 'onboarding-not-found' (no onboarding yet), 'http-401'/'http-403'.",
       inputSchema: { type: 'object', properties: {} },
       handler: repeatOnboarding,
     },
     {
       name: 'onboarding_finish',
-      description: "Mark the onboarding as complete — the TERMINAL step, ALWAYS call it once the mandatory steps (register) are done, whether the talent took OR skipped the AI-usage evaluation and the interview. This flips their onboarding status to COMPLETED and lets Shakers promote their registration level (the metrics the team tracks). Idempotent: safe to call once at the end of any path. Returns { finalized, onboardingStatus, registrationLevel, completedProfilePercentage, profileUrl }: use completedProfilePercentage to tell the talent how complete their profile is, and profileUrl to point them to it.",
+      description: "Mark the onboarding as COMPLETED on Shakers. NOT part of the sign-up flow (signup_start): there, never call it. Use it only to close a repeat_onboarding_interview run. Idempotent. Returns { finalized, onboardingStatus, registrationLevel, completedProfilePercentage, profileUrl }.",
       inputSchema: FINISH_SCHEMA,
       handler: onboardingFinish,
     },
@@ -557,18 +342,9 @@ function makeRegisterTools(deps = {}) {
 
 module.exports = {
   makeRegisterTools,
-  ACCOUNT_FIELDS,
-  REGISTER_SCHEMA,
-  PREVIEW_SCHEMA,
-  STATUS_SCHEMA,
+  completedOnboardingInterview,
   INTERVIEW_START_SCHEMA,
   INTERVIEW_TURN_SCHEMA,
   INTERVIEW_COMPLETE_SCHEMA,
   FINISH_SCHEMA,
-  PROFILE_SCHEMA,
-  WORK_SITUATION_SCHEMA,
-  PRICING_SCHEMA,
-  AVAILABILITY_SCHEMA,
-  LANGUAGES_SCHEMA,
-  PHONE_SCHEMA,
 };