shakers-cli-beta 0.8.0-beta.0

package/src/certifications-flow.js

@@ -0,0 +1,75 @@
+'use strict';
+
+// `certifications` flow: render the talent's dimension certifications by state
+// (certified / uncertified / expired) + band + main role. Read-only.
+
+const { styleLabelPrefix } = require('./ansi');
+
+function makeCertificationsDeps(overrides = {}) {
+  const client = require('./certifications-client');
+  return {
+    fetchMeCertifications: (opts) => client.fetchMeCertifications({}, opts),
+    ...overrides,
+  };
+}
+
+function groupByState(dimensions) {
+  const g = { certified: [], uncertified: [], expired: [] };
+  for (const d of dimensions || []) {
+    if (d.state === 'CERTIFIED') g.certified.push(d);
+    else if (d.state === 'EXPIRED') g.expired.push(d);
+    else g.uncertified.push(d);
+  }
+  return g;
+}
+
+function renderGroup(io, fp, heading, items, withBand) {
+  if (!items.length) return;
+  io.section(heading);
+  items.forEach((d) => {
+    const label = d.name || d.slug || fp.untitled;
+    io.notify(withBand && d.band ? `${label} — ${d.band}` : label);
+  });
+}
+
+async function runCertifications({ io, rawOut, session, catalog, opts = {}, deps = makeCertificationsDeps() }) {
+  const fp = catalog.certifications;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+
+  const doFetch = () => deps.fetchMeCertifications({ hubAccessToken });
+  const res = opts.json ? await doFetch() : await io.withProgress(fp.loading, doFetch);
+  if (!res.ok) {
+    io.error(fp.fetchFailed(res.reason));
+    return { ok: false, reason: res.reason };
+  }
+
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({ ok: true, mainRole: res.mainRole, dimensions: res.dimensions, growingInto: res.growingInto }, null, 2)}\n`);
+    return { ok: true, mainRole: res.mainRole, dimensions: res.dimensions };
+  }
+
+  io.section(fp.title);
+  if (res.mainRole && res.mainRole.name) {
+    const ratio = res.mainRole.total != null ? ` (${res.mainRole.certified ?? 0}/${res.mainRole.total})` : '';
+    io.notify(styleLabelPrefix(fp.mainRole(res.mainRole.name) + ratio));
+  } else {
+    io.notify(fp.noMainRole);
+  }
+
+  const g = groupByState(res.dimensions);
+  if (g.certified.length === 0 && g.uncertified.length === 0 && g.expired.length === 0) {
+    io.notify(fp.noDimensions);
+    return { ok: true, mainRole: res.mainRole, dimensions: res.dimensions };
+  }
+  renderGroup(io, fp, fp.headingCertified, g.certified, true);
+  renderGroup(io, fp, fp.headingExpired, g.expired, true);
+  renderGroup(io, fp, fp.headingUncertified, g.uncertified, false);
+  io.success(fp.done);
+  return { ok: true, mainRole: res.mainRole, dimensions: res.dimensions };
+}
+
+module.exports = {
+  makeCertificationsDeps,
+  groupByState,
+  runCertifications,
+};

package/src/certify-dimension-client.js

@@ -0,0 +1,217 @@
+'use strict';
+
+// Dimension-certification discovery + lifecycle client (hub + certs endpoints).
+
+const { postJsonWithTimeout } = require('./backend-request');
+const { reasonForError } = require('./onboarding-client');
+const { toUpperLang } = require('./lang-codes');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function payloadOf(raw) {
+  const json = parseJson(raw);
+  if (!json || typeof json !== 'object') return undefined;
+  if (json.status === 'OK') return json.data;
+  return json;
+}
+
+function bearerHeaders(accessToken) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return headers;
+}
+
+function pick(obj, keys) {
+  for (const k of keys) {
+    const v = obj && obj[k];
+    if (v !== undefined && v !== null && v !== '') return v;
+  }
+  return null;
+}
+
+// FLAG: hub gives `clusterId`, certs keys templates by `clusterRef`; assumed equal here.
+function composeDimensionKey(clusterRef, slug) {
+  if (!clusterRef || !slug) return null;
+  return `${clusterRef}/${slug}`;
+}
+
+async function requestMyCertifications({ hubAccessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, null, timeoutMs, 'GET', null, bearerHeaders(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 = payloadOf(res.raw);
+  if (data === undefined || !data || typeof data !== 'object') return { ok: false, reason: 'bad-response' };
+  const rawDims = Array.isArray(data) ? data
+    : (Array.isArray(data.dimensions) ? data.dimensions
+      : (Array.isArray(data.items) ? data.items : []));
+  const dimensions = rawDims
+    .map((d) => ({
+      slug: pick(d, ['slug', 'dimensionSlug', 'key']),
+      clusterId: pick(d, ['clusterRef', 'clusterId', 'clusterKey', 'cluster']),
+      state: pick(d, ['state', 'status']),
+      band: pick(d, ['band', 'level']) || null,
+    }))
+    .filter((d) => d.slug && d.clusterId);
+  return { ok: true, mainRole: pick(data, ['mainRole', 'role']) || null, dimensions };
+}
+
+// @Public: no auth header. Returns a Map dimensionKey -> deliveryFormat.
+async function requestTemplatesByDimension({ dimensionKeys } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  const keys = (Array.isArray(dimensionKeys) ? dimensionKeys : []).filter(Boolean);
+  if (keys.length === 0) return { ok: true, formats: new Map() };
+
+  const url = `${endpoint}${endpoint.includes('?') ? '&' : '?'}dimensionKeys=${keys.map(encodeURIComponent).join(',')}`;
+  let res;
+  try {
+    res = await postJsonWithTimeout(url, null, timeoutMs, 'GET', null, {});
+  } 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 = payloadOf(res.raw);
+  if (data === undefined || data === null) return { ok: false, reason: 'bad-response' };
+
+  // The real certs route returns rows under `data.items`; templates/bare-array are tolerant fallbacks.
+  const formats = new Map();
+  const rows = Array.isArray(data)
+    ? data
+    : (Array.isArray(data.items) ? data.items
+      : (Array.isArray(data.templates) ? data.templates : null));
+  if (rows) {
+    for (const t of rows) {
+      const key = pick(t, ['dimensionKey', 'key', 'dimension']);
+      const fmt = pick(t, ['deliveryFormat', 'delivery_format', 'format']);
+      if (key && fmt) formats.set(String(key), String(fmt));
+    }
+  } else if (typeof data === 'object') {
+    for (const [key, value] of Object.entries(data)) {
+      const fmt = value && typeof value === 'object' ? pick(value, ['deliveryFormat', 'delivery_format', 'format']) : value;
+      if (fmt) formats.set(String(key), String(fmt));
+    }
+  }
+  return { ok: true, formats };
+}
+
+// What the terminal can run: the templates marked for it, and the spoken ones, which are
+// conversation only. Whiteboard and screen share need the web.
+const TEXT_DELIVERY_FORMATS = new Set(['terminal', 'spoken_case']);
+
+function composeOfferableDimensions({ dimensions, formats } = {}) {
+  const fmt = formats instanceof Map ? formats : new Map(Object.entries(formats || {}));
+  const candidates = (Array.isArray(dimensions) ? dimensions : [])
+    .filter((d) => d && d.state !== 'CERTIFIED')
+    .map((d) => ({ ...d, dimensionKey: composeDimensionKey(d.clusterId, d.slug) }))
+    .filter((d) => d.dimensionKey);
+  const offerable = candidates.filter((d) => TEXT_DELIVERY_FORMATS.has(fmt.get(d.dimensionKey)));
+  const unmatched = candidates
+    .filter((d) => !fmt.has(d.dimensionKey))
+    .map((d) => d.dimensionKey);
+  return { offerable, unmatched };
+}
+
+async function discoverOfferableDimensions(deps = {}, { accessToken, hubAccessToken, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const {
+    getMyCertificationsEndpoint = require('./config').getMyCertificationsEndpoint,
+    getTemplatesByDimensionEndpoint = require('./config').getTemplatesByDimensionEndpoint,
+    requestMyCertifications: myCerts = requestMyCertifications,
+    requestTemplatesByDimension: templates = requestTemplatesByDimension,
+  } = deps;
+
+  const mineEndpoint = getMyCertificationsEndpoint();
+  if (!mineEndpoint) return { ok: false, reason: 'no-endpoint' };
+  const mine = await myCerts({ hubAccessToken }, { endpoint: mineEndpoint, timeoutMs });
+  if (!mine.ok) return { ok: false, reason: mine.reason };
+
+  const candidateDims = mine.dimensions.filter((d) => d.state !== 'CERTIFIED');
+  if (candidateDims.length === 0) return { ok: true, mainRole: mine.mainRole, offerable: [], unmatched: [] };
+
+  const templatesEndpoint = getTemplatesByDimensionEndpoint();
+  if (!templatesEndpoint) return { ok: false, reason: 'no-endpoint' };
+  const keys = candidateDims
+    .map((d) => composeDimensionKey(d.clusterId, d.slug))
+    .filter(Boolean);
+  const tmpl = await templates({ dimensionKeys: keys }, { endpoint: templatesEndpoint, timeoutMs });
+  if (!tmpl.ok) return { ok: false, reason: tmpl.reason };
+
+  const { offerable, unmatched } = composeOfferableDimensions({ dimensions: candidateDims, formats: tmpl.formats });
+  return { ok: true, mainRole: mine.mainRole, offerable, unmatched };
+}
+
+async function requestCreateCertificationInterview(
+  { dimensionKey, languageCode, accessToken } = {},
+  { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!dimensionKey) return { ok: false, reason: 'no-dimension' };
+  const body = { dimensionKey };
+  if (languageCode) body.languageCode = toUpperLang(languageCode);
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, body, timeoutMs, 'POST', null, bearerHeaders(accessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status < 200 || res.status >= 300) {
+    const reason = reasonForError(res.status, res.raw);
+    if (reason !== 'dimension-on-cooldown') return { ok: false, reason };
+    // certs puts the date in the message only: "... available on 2026-10-28T14:50:38.265Z".
+    const available = String(res.raw || '').match(/available on (\d{4}-\d{2}-\d{2}T[\d:.]+Z)/);
+    return { ok: false, reason, availableOn: available ? available[1] : null };
+  }
+  const data = payloadOf(res.raw);
+  const interviewId = pick(data || {}, ['interviewId', 'id']);
+  if (!interviewId) return { ok: false, reason: 'bad-response' };
+  return { ok: true, interviewId, language: pick(data || {}, ['language', 'languageCode']) || null };
+}
+
+// Poll the verdict; a 2xx/404/425/202 with no band yet resolves `ready:false` (retriable).
+async function requestCertificationReport(
+  { interviewId, accessToken } = {},
+  { base, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  if (!base) return { ok: false, reason: 'no-endpoint' };
+  if (!interviewId) return { ok: false, reason: 'no-interview' };
+  const url = `${base.replace(/\/+$/, '')}/${encodeURIComponent(interviewId)}/report`;
+  let res;
+  try {
+    res = await postJsonWithTimeout(url, null, timeoutMs, 'GET', null, bearerHeaders(accessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status === 404 || res.status === 425 || res.status === 202) return { ok: true, ready: false, report: null };
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
+  const data = payloadOf(res.raw);
+  if (data === undefined || data === null || typeof data !== 'object') return { ok: true, ready: false, report: null };
+  const band = pick(data, ['band', 'level', 'combinedLevel']);
+  // A report with too little evidence for a level has band null; it is still finished.
+  if (!band && !pick(data, ['evaluationId'])) return { ok: true, ready: false, report: null };
+  return { ok: true, ready: true, report: data };
+}
+
+module.exports = {
+  requestMyCertifications,
+  requestTemplatesByDimension,
+  requestCreateCertificationInterview,
+  requestCertificationReport,
+  composeDimensionKey,
+  composeOfferableDimensions,
+  discoverOfferableDimensions,
+  TEXT_DELIVERY_FORMATS,
+};

package/src/certify-dimension-flow.js

@@ -0,0 +1,193 @@
+'use strict';
+
+// `certify` dimension flow: discover -> pick -> create -> LiveKit interview -> poll verdict.
+
+const { runInteractiveMultiSelect } = require('./interactive-select');
+
+function makeCertifyDimensionDeps(overrides = {}) {
+  const config = require('./config');
+  const client = require('./certify-dimension-client');
+  const onboardingFlow = require('./onboarding-flow');
+  return {
+    getCertificationInterviewsEndpoint: config.getCertificationInterviewsEndpoint,
+    // `{certsBase}/interviews` — shared base for LiveKit start/complete + the report poll.
+    getInterviewsBase: config.getOnboardingInterviewsEndpoint,
+    discoverOfferableDimensions: (opts) => client.discoverOfferableDimensions({}, opts),
+    requestCreateCertificationInterview: client.requestCreateCertificationInterview,
+    requestCertificationReport: client.requestCertificationReport,
+    conductLivekitInterview: onboardingFlow.conductLivekitInterview,
+    onboardingDeps: onboardingFlow.makeDeps(),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    ...overrides,
+  };
+}
+
+// Numbered fallback when `ask` can't release stdin for raw mode.
+async function askNumberedChoice(ask, promptText, count) {
+  const raw = (await ask(promptText)).trim();
+  if (!raw) return null;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n < 1 || n > count) return null;
+  return n - 1;
+}
+
+async function chooseDimension(ask, stdinIsTTY, items, cd, out, { input, output } = {}) {
+  const labelFor = (d) => `${d.slug}${d.state === 'EXPIRED' ? ` (${cd.stateExpired})` : ''}`;
+  if (stdinIsTTY && typeof ask.suspend === 'function') {
+    ask.suspend();
+    const picked = await runInteractiveMultiSelect({
+      items,
+      labelFor,
+      header: cd.selectHeading,
+      hint: cd.selectHint,
+      single: true,
+      ...(input ? { input } : {}),
+      ...(output ? { output } : {}),
+    });
+    ask.resume();
+    return picked && picked.length ? picked[0] : null;
+  }
+  out(`\n  ${cd.selectHeading}\n`);
+  items.forEach((d, i) => out(`    ${i + 1}) ${labelFor(d)}\n`));
+  const idx = await askNumberedChoice(ask, `  ${cd.selectPrompt(items.length)}`, items.length);
+  return idx === null ? null : items[idx];
+}
+
+function resolveDimensionArg(arg, items) {
+  if (arg == null) return null;
+  const raw = String(arg).trim();
+  const n = Number.parseInt(raw, 10);
+  if (Number.isInteger(n) && String(n) === raw && n >= 1 && n <= items.length) return items[n - 1];
+  return items.find((d) => d.dimensionKey === raw || d.slug === raw) || undefined;
+}
+
+// The evaluation lands one to two minutes after the interview ends, four when the queue is busy.
+async function pollReport(deps, { interviewId, accessToken }, { base, attempts = 60, intervalMs = 5000 } = {}) {
+  for (let i = 0; i < attempts; i++) {
+    const res = await deps.requestCertificationReport({ interviewId, accessToken }, { base });
+    if (!res.ok) return { ok: false, reason: res.reason };
+    if (res.ready) return { ok: true, report: res.report };
+    if (i < attempts - 1) await deps.sleep(intervalMs);
+  }
+  return { ok: false, reason: 'timeout' };
+}
+
+function formatDay(iso, lang) {
+  const d = iso ? new Date(iso) : null;
+  if (!d || Number.isNaN(d.getTime())) return null;
+  return d.toLocaleDateString(lang === 'en' ? 'en-GB' : 'es-ES', { day: 'numeric', month: 'long', year: 'numeric' });
+}
+
+function renderVerdict(report, cd) {
+  const lines = [];
+  const band = report.band || report.level || report.combinedLevel;
+  const dimension = report.dimensionName || report.dimension || report.dimensionKey;
+  if (dimension) lines.push(cd.verdictDimension(dimension));
+  if (band) lines.push(cd.verdictBand(band));
+  if (typeof report.certified === 'boolean') lines.push(report.certified ? cd.verdictCertified : cd.verdictNotCertified);
+  const summary = report.summary || report.rationale || report.feedback;
+  if (typeof summary === 'string' && summary.trim()) lines.push(summary.trim());
+  const areas = Array.isArray(report.areas) ? report.areas : null;
+  if (areas && areas.length) {
+    for (const a of areas) {
+      const name = a && (a.name || a.area || a.tag);
+      const note = a && (a.note || a.comment);
+      if (name) lines.push(`- ${name}${note ? `: ${note}` : ''}`);
+    }
+  }
+  return lines.join('\n  ');
+}
+
+async function runCertifyDimension({ io, ask, stdinIsTTY, session, lang, catalog, opts = {}, deps = makeCertifyDimensionDeps() }) {
+  const cd = catalog.certifyDimension;
+  const accessToken = session ? session.accessToken : null;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+
+  io.section(cd.title);
+
+  const discovered = await io.withProgress(cd.discovering, () =>
+    deps.discoverOfferableDimensions({ accessToken, hubAccessToken }));
+  if (!discovered.ok) {
+    io.error(cd.discoverFailed(discovered.reason));
+    return { ok: false, reason: discovered.reason, step: 'discover' };
+  }
+
+  if (Array.isArray(discovered.unmatched) && discovered.unmatched.length > 0) {
+    io.warn(cd.unmatchedNote(discovered.unmatched.join(', ')));
+  }
+
+  const offerable = Array.isArray(discovered.offerable) ? discovered.offerable : [];
+  if (offerable.length === 0) {
+    io.notify(cd.noneOfferable);
+    return { ok: true, none: true };
+  }
+  const mainRole = discovered.mainRole;
+  // The hub sends the main role as { clusterId, name, ... }.
+  const mainRoleName = mainRole && typeof mainRole === 'object' ? mainRole.name || mainRole.clusterId : mainRole;
+  if (mainRoleName) io.notify(cd.mainRole(mainRoleName));
+
+  let chosen;
+  if (opts.dimension != null) {
+    const resolved = resolveDimensionArg(opts.dimension, offerable);
+    if (!resolved) {
+      io.error(cd.dimensionInvalid);
+      return { ok: false, reason: 'bad-dimension', step: 'select' };
+    }
+    chosen = resolved;
+    io.notify(cd.dimensionUsing(chosen.slug));
+  } else if (!stdinIsTTY) {
+    io.error(cd.selectNonInteractive);
+    return { ok: false, reason: 'non-interactive', step: 'select' };
+  } else {
+    chosen = await chooseDimension(ask, stdinIsTTY, offerable, cd, (s) => io.notify(s.replace(/\n$/, '')), opts);
+    if (!chosen) {
+      io.notify(cd.selectNoneChosen);
+      return { ok: true, cancelled: true };
+    }
+  }
+
+  const createEndpoint = deps.getCertificationInterviewsEndpoint();
+  const created = await io.withProgress(cd.creating, () =>
+    deps.requestCreateCertificationInterview(
+      { dimensionKey: chosen.dimensionKey, languageCode: lang, accessToken },
+      { endpoint: createEndpoint },
+    ));
+  if (!created.ok) {
+    io.error(created.reason === 'dimension-on-cooldown'
+      ? cd.onCooldown(formatDay(created.availableOn, lang))
+      : cd.createFailed(created.reason));
+    return { ok: false, reason: created.reason, step: 'create' };
+  }
+
+  const interview = await deps.conductLivekitInterview(io, deps.onboardingDeps, {
+    interviewId: created.interviewId,
+    language: lang,
+    plain: true,
+  });
+  if (!interview.ok) {
+    io.warn(interview.reason === 'needs-web' ? cd.needsWeb : cd.interviewUnavailable(interview.reason));
+    return { ok: false, reason: interview.reason, step: 'interview' };
+  }
+
+  const reportBase = deps.getInterviewsBase();
+  const polled = await io.withProgress(cd.reportPolling, () =>
+    pollReport(deps, { interviewId: created.interviewId, accessToken }, { base: reportBase }));
+  if (!polled.ok) {
+    io.warn(polled.reason === 'timeout' ? cd.reportTimeout : cd.reportFailed(polled.reason));
+    return { ok: true, completed: 'interview', verdict: null };
+  }
+
+  io.section(cd.verdictTitle);
+  io.notify(renderVerdict(polled.report, cd));
+  io.success(cd.done);
+  return { ok: true, completed: 'interview', verdict: polled.report };
+}
+
+module.exports = {
+  makeCertifyDimensionDeps,
+  runCertifyDimension,
+  chooseDimension,
+  resolveDimensionArg,
+  pollReport,
+  renderVerdict,
+};

package/src/certify-disclaimer.js

@@ -0,0 +1,51 @@
+'use strict';
+
+// Legal disclaimer + EXPLICIT acceptance gate (ADR-001), shown before egress. Skill-code certify was retired (certify is now a dimension LiveKit interview); consumers today are the add-skill/add-agent/add-project consent gates.
+
+const { renderLegalNotice } = require('./legal-notice');
+const { styleQuestion } = require('./ansi');
+
+const MAX_ATTEMPTS = 5;
+const YES_RE = /^(y|yes|s|si|sí)$/i;
+const NO_RE = /^(n|no)$/i;
+
+function isAffirmative(raw) {
+  return YES_RE.test(String(raw).trim());
+}
+function isNegative(raw) {
+  return NO_RE.test(String(raw).trim());
+}
+
+async function confirmDisclaimerAcceptance({ ask, catalog, preAccepted = false, stdinIsTTY = true, text = null, drainBeforeAsk = false }) {
+  const d = catalog.certify;
+  const shown = text || d.disclaimer;
+
+  // The disclaimer TEXT is always shown, even when pre-accepting via flag — the talent (or the script author who chose the flag) still sees what they're accepting.
+  process.stdout.write(`\n  ${renderLegalNotice(shown, catalog)}\n`);
+
+  if (preAccepted) {
+    process.stdout.write(`  ${d.disclaimerAcceptedFlag}\n\n`);
+    return { accepted: true, reason: 'flag' };
+  }
+
+  if (!stdinIsTTY) {
+    process.stdout.write(`  ${d.disclaimerNonInteractive}\n\n`);
+    return { accepted: false, reason: 'non-interactive' };
+  }
+
+  if (drainBeforeAsk && typeof ask.drain === 'function') ask.drain();
+
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    const raw = String(await ask(styleQuestion(d.disclaimerQuestion))).trim();
+    if (isAffirmative(raw)) return { accepted: true, reason: 'interactive' };
+    if (isNegative(raw)) {
+      process.stdout.write(`  ${d.disclaimerDeclined}\n\n`);
+      return { accepted: false, reason: 'declined' };
+    }
+    process.stdout.write(`  ${d.disclaimerInvalidAnswer}\n`);
+  }
+  process.stdout.write(`  ${d.disclaimerNoAnswer}\n\n`);
+  return { accepted: false, reason: 'no-answer' };
+}
+
+module.exports = { confirmDisclaimerAcceptance, isAffirmative, isNegative };

package/src/certify-remediation-prompt.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { getCatalog } = require('./i18n');
+
+// Client-side "remediation prompt" for the certify report (skill-code- certification, issue 011).
+function buildRemediationPrompt(item, lang) {
+  const r = getCatalog(lang).certify.report;
+  const improvements =
+    item && item.result && Array.isArray(item.result.improvements)
+      ? item.result.improvements.filter((x) => typeof x === 'string' && x)
+      : [];
+  if (improvements.length === 0) return null;
+
+  const lines = [];
+  lines.push(r.remediationIntro(item.skillName, item.technology));
+  lines.push('');
+  improvements.forEach((imp, i) => lines.push(`${i + 1}. ${imp}`));
+  lines.push('');
+  lines.push(r.remediationClosing);
+  return lines.join('\n');
+}
+
+module.exports = { buildRemediationPrompt };

package/src/cli-args.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const VALID_LANGS = new Set(['es', 'en']);
+const VALID_SCOPES = new Set(['machine', 'repo']);
+
+function parseScope(value) {
+  return VALID_SCOPES.has(value) ? value : null;
+}
+
+function parseRepoList(value) {
+  if (typeof value !== 'string') return null;
+  const items = value
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : null;
+}
+
+function parseArgs(argv) {
+  const opts = {
+    json: false,
+    save: true,
+    root: null,
+    help: false,
+    consentStatus: false,
+    consentRevoke: false,
+    consentReset: false,
+    consentEmail: null,
+    setEndpoint: null,
+    showEndpoint: false,
+    buildNextLevel: false,
+    force: false,
+    lang: null,
+    roadmap: false,
+    repos: null,
+    allRepos: false,
+    // Dynamic scope selector for the DEDICATED `ai-usage` command (a symptom fix: machine-wide runs were silently collapsing to the current repo's agents).
+    machine: false,
+    repo: false,
+    scope: null,
+    noAi: false,
+    // Issue 103: turns the section reveal off. Same name in both parsers, and the
+    // env var `NO_ANIMATION` does the same thing (the `NO_COLOR` pattern of 079).
+    noAnimation: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--no-animation') opts.noAnimation = true;
+    else if (a === '--json') opts.json = true;
+    else if (a === '--no-save') opts.save = false;
+    else if (a === '--root') opts.root = argv[++i];
+    else if (a === '--consent-status') opts.consentStatus = true;
+    else if (a === '--consent-revoke') opts.consentRevoke = true;
+    else if (a === '--consent-reset') opts.consentReset = true;
+    else if (a === '--consent-email') opts.consentEmail = argv[++i];
+    else if (a.startsWith('--consent-email=')) opts.consentEmail = a.slice('--consent-email='.length);
+    else if (a === '--set-endpoint') opts.setEndpoint = argv[++i];
+    else if (a.startsWith('--set-endpoint=')) opts.setEndpoint = a.slice('--set-endpoint='.length);
+    else if (a === '--show-endpoint') opts.showEndpoint = true;
+    else if (a === '--build-next-level') opts.buildNextLevel = true;
+    else if (a === '--force') opts.force = true;
+    // ADR-016: the tier roadmap / "next steps" block is removed from the
+    // default footprint output; `--roadmap` (alias `--next`) shows it again.
+    else if (a === '--roadmap' || a === '--next') opts.roadmap = true;
+    else if (a === '--lang') opts.lang = VALID_LANGS.has(argv[++i]) ? argv[i] : null;
+    else if (a.startsWith('--lang=')) {
+      const value = a.slice('--lang='.length);
+      opts.lang = VALID_LANGS.has(value) ? value : null;
+    }
+    else if (a === '--no-ai') opts.noAi = true;
+    else if (a === '--all-repos') opts.allRepos = true;
+    else if (a === '--machine') opts.machine = true;
+    else if (a === '--repo') opts.repo = true;
+    else if (a === '--scope') opts.scope = parseScope(argv[++i]);
+    else if (a.startsWith('--scope=')) opts.scope = parseScope(a.slice('--scope='.length));
+    else if (a === '--repos') opts.repos = parseRepoList(argv[++i]);
+    else if (a.startsWith('--repos=')) opts.repos = parseRepoList(a.slice('--repos='.length));
+    else if (a === '--help' || a === '-h') opts.help = true;
+  }
+  return opts;
+}
+
+module.exports = { parseArgs };