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

package/src/onboarding-client.js

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

package/src/onboarding-flow.js

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

package/src/onboarding-status-client.js

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

package/src/register-context.js

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

package/src/roles-client.js

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

package/src/scanner.js

@@ -202,7 +202,19 @@ function computeRecency(paths) {
 /* ---------- version: ONLY runs the ALREADY detected binary, with --version ---------- */
 /* Never arbitrary commands; all output is discarded except the version pattern. */
 
+// scan() runs once per selected repo; remember each binary's version for a minute instead of asking again.
+const VERSION_TTL_MS = 60 * 1000;
+const versionCache = new Map();
+
 function getVersion(bin) {
+  const cached = versionCache.get(bin);
+  if (cached && Date.now() - cached.at <= VERSION_TTL_MS) return cached.version;
+  const version = readVersion(bin);
+  versionCache.set(bin, { version, at: Date.now() });
+  return version;
+}
+
+function readVersion(bin) {
   try {
     const out = execFileSync(bin, ['--version'], {
       timeout: 3000,
@@ -609,4 +621,4 @@ function mergeReports(reports) {
   };
 }
 
-module.exports = { scan, scanForRoots };
+module.exports = { scan, scanForRoots, getVersion };

package/src/session-normalizers.js

@@ -0,0 +1,174 @@
+'use strict';
+
+// Input normalizers: map a RAW session record into the Claude-shaped internal object model
+// that session-scan harvest + transcript-turns already consume
+// ({ cwd, timestamp, type, message:{ role, content:[{type:'text'|'tool_use', ...}] } }).
+// They ONLY translate input shape — downstream redaction/upload (share.js#derivePayload
+// -> POST usage/reports) is unchanged; no field is read that the Claude path didn't expose.
+// FAIL-CLOSED: every normalizer returns null / [] when a record does not match the expected
+// shape — it never fabricates or guesses fields. A documented format that differs from the
+// real one yields "no data for that tool", never wrong data.
+
+function str(v) {
+  return typeof v === 'string' && v ? v : null;
+}
+
+function textFromParts(parts) {
+  if (typeof parts === 'string') return parts.trim() || null;
+  if (!Array.isArray(parts)) return null;
+  const out = [];
+  for (const p of parts) {
+    if (typeof p === 'string') out.push(p);
+    else if (p && typeof p === 'object' && typeof p.text === 'string') out.push(p.text);
+  }
+  const joined = out.join('').trim();
+  return joined || null;
+}
+
+// --- Codex (~/.codex/sessions/**/rollout-*.jsonl) ---
+// Reads timestamp, cwd (session_meta), user text, and shell commands; a record matching none
+// of those passes through only its own real timestamp/cwd, else is dropped.
+function codexCommand(args) {
+  let a = args;
+  if (typeof a === 'string') {
+    try { a = JSON.parse(a); } catch { return a.trim() || null; }
+  }
+  if (!a || typeof a !== 'object') return null;
+  const cmd = a.command ?? a.cmd ?? a.commandLine;
+  if (Array.isArray(cmd)) return cmd.map(String).join(' ').trim() || null;
+  return str(cmd);
+}
+
+function normalizeCodexRecord(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const payload = raw.payload && typeof raw.payload === 'object' ? raw.payload : null;
+  const item = payload || raw;
+  const out = {};
+  const ts = str(raw.timestamp) || str(item.timestamp);
+  if (ts) out.timestamp = ts;
+  const cwd = str(raw.cwd) || str(item.cwd);
+  if (cwd) out.cwd = cwd;
+
+  const role = str(item.role);
+  if (role === 'user') {
+    const text = textFromParts(item.content);
+    if (text) {
+      out.type = 'user';
+      out.message = { role: 'user', content: [{ type: 'text', text }] };
+      return out;
+    }
+  }
+
+  const type = str(raw.type) || str(item.type);
+  const name = str(item.name) || (type === 'function_call' ? 'shell' : null);
+  if (name && /shell|exec|bash|terminal|command/i.test(name)) {
+    const command = codexCommand(item.arguments ?? item.input ?? item.args);
+    if (command) {
+      out.message = { content: [{ type: 'tool_use', name: 'Shell', input: { command } }] };
+      return out;
+    }
+  }
+
+  return out.timestamp || out.cwd ? out : null;
+}
+
+// --- Gemini CLI (~/.gemini/tmp/<project-hash>/chats/logs.json | session-*.jsonl) ---
+// logs.json = JSON array of { type:'user'|'model', message, timestamp }; session-*.jsonl =
+// per-line { role, parts }. No cwd is recorded (the dir is a one-way SHA-256 hash), so cwd
+// stays null — global session/time metrics still count; per-repo scoping can't.
+function normalizeGeminiRecord(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const out = {};
+  const ts = str(raw.timestamp) || str(raw.time);
+  if (ts) out.timestamp = ts;
+
+  const isUser = str(raw.type) === 'user' || str(raw.role) === 'user';
+  if (isUser) {
+    const text = str(raw.message) || textFromParts(raw.parts) || textFromParts(raw.content);
+    if (text) {
+      out.type = 'user';
+      out.message = { role: 'user', content: [{ type: 'text', text }] };
+      return out;
+    }
+  }
+  return out.timestamp ? out : null;
+}
+
+// --- Continue (continue.dev) ~/.continue/sessions/*.json ---
+// Each file is one session object; expand its history into per-turn objects, carrying
+// workspaceDirectory as cwd (good repo attribution).
+function normalizeContinueRecord(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  const cwd = str(raw.workspaceDirectory) || str(raw.workspace) || str(raw.cwd);
+  const history = Array.isArray(raw.history) ? raw.history
+    : (Array.isArray(raw.messages) ? raw.messages : (Array.isArray(raw.conversation) ? raw.conversation : null));
+  // A single message object (not a session) — handle defensively too.
+  if (!history) {
+    const msg = raw.message && typeof raw.message === 'object' ? raw.message : raw;
+    if (str(msg.role) === 'user') {
+      const text = typeof msg.content === 'string' ? msg.content.trim() : textFromParts(msg.content);
+      if (text) return oneUser(text, cwd, str(raw.timestamp) || str(raw.createdAt));
+    }
+    return null;
+  }
+  const out = [];
+  for (const entry of history) {
+    const msg = entry && entry.message && typeof entry.message === 'object' ? entry.message : entry;
+    if (!msg || typeof msg !== 'object') continue;
+    const ts = str(entry.timestamp) || str(entry.createdAt) || str(msg.timestamp);
+    // Only emit on a real user turn (with text) or a record carrying a real timestamp.
+    if (str(msg.role) === 'user') {
+      const text = typeof msg.content === 'string' ? msg.content.trim() : textFromParts(msg.content);
+      if (text) { out.push(oneUser(text, cwd, ts)); continue; }
+    }
+    if (ts) out.push(cwd ? { cwd, timestamp: ts } : { timestamp: ts });
+  }
+  return out.length ? out : null;
+}
+
+// --- Cline / Roo Code: VS Code globalStorage .../tasks/<id>/api_conversation_history.json ---
+// One JSON array of Anthropic messages (role/content); no cwd and no timestamp in this file
+// (ui_messages.json has ts) → cwd/time attribution absent. Emits only real user turns.
+function normalizeClineRecord(raw) {
+  if (!raw || typeof raw !== 'object') return null;
+  if (str(raw.role) !== 'user') return null;
+  const text = typeof raw.content === 'string' ? raw.content.trim() : textFromParts(raw.content);
+  return text ? oneUser(text, null, null) : null;
+}
+
+// --- Aider: per-repo .aider.chat.history.md (markdown) ---
+// Repo-level source → cwd is the repo toplevel (good attribution). Markdown parse:
+// '# aider chat started at <ts>' sets the session time; '#### <text>' lines are user
+// instructions. A file matching neither pattern yields 0 records.
+function parseAiderHistory(text, cwd) {
+  if (typeof text !== 'string' || !text) return [];
+  const out = [];
+  let ts = null;
+  for (const line of text.split('\n')) {
+    const started = /^#\s*aider chat started at\s+(.+?)\s*$/i.exec(line);
+    if (started) {
+      const t = Date.parse(started[1].replace(' ', 'T'));
+      ts = Number.isFinite(t) ? new Date(t).toISOString() : null;
+      if (ts) out.push(cwd ? { cwd, timestamp: ts } : { timestamp: ts });
+      continue;
+    }
+    const user = /^####\s+(.*)$/.exec(line);
+    if (user && user[1].trim()) out.push(oneUser(user[1].trim(), cwd, ts));
+  }
+  return out;
+}
+
+function oneUser(text, cwd, ts) {
+  const o = { type: 'user', message: { role: 'user', content: [{ type: 'text', text }] } };
+  if (cwd) o.cwd = cwd;
+  if (ts) o.timestamp = ts;
+  return o;
+}
+
+module.exports = {
+  normalizeCodexRecord,
+  normalizeGeminiRecord,
+  normalizeContinueRecord,
+  normalizeClineRecord,
+  parseAiderHistory,
+};