@hasna/experts 0.0.5 → 0.0.7

package/dist/cli/index.js

@@ -32,6 +32,206 @@ function expertText(e) {
   return [e.title, e.headline, e.bio].filter(Boolean).join(". ");
 }
 
+// src/score.ts
+var DEFAULT_WEIGHTS = {
+  rating: 0.3,
+  reviews: 0.2,
+  followers: 0.25,
+  featured: 0.1,
+  verified: 0.05,
+  recency: 0.1
+};
+var clamp01 = (n) => Math.max(0, Math.min(1, n));
+var logNorm = (x, cap) => clamp01(Math.log10(1 + Math.max(0, x)) / Math.log10(1 + cap));
+function authorityScore(e, inputs = {}, weights = DEFAULT_WEIGHTS) {
+  const rating = clamp01((e.rating || 0) / 5);
+  const reviews = logNorm(e.ratingCount || 0, 1000);
+  const followers = logNorm(inputs.followers ?? 0, 1e6);
+  const featured = e.featured ? 1 : 0;
+  const verified = e.verified ? 1 : 0;
+  const recency = inputs.daysSinceLastTweet == null ? 0 : clamp01(1 - inputs.daysSinceLastTweet / 30);
+  const raw = weights.rating * rating + weights.reviews * reviews + weights.followers * followers + weights.featured * featured + weights.verified * verified + weights.recency * recency;
+  return Math.round(raw * 1000) / 10;
+}
+
+// src/embed.ts
+var STOPWORDS = new Set([
+  "the",
+  "a",
+  "an",
+  "and",
+  "or",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "at",
+  "is",
+  "are",
+  "with",
+  "by",
+  "as",
+  "be",
+  "this",
+  "that",
+  "it",
+  "from",
+  "i",
+  "you",
+  "we",
+  "they"
+]);
+function tokenize(text) {
+  return (text || "").toLowerCase().replace(/https?:\/\/\S+/g, " ").split(/[^a-z0-9]+/).filter((t) => t.length >= 2 && !STOPWORDS.has(t));
+}
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+  }
+  return h >>> 0;
+}
+
+class HashingEmbedder {
+  id = "hash-v1";
+  dim;
+  constructor(dim = 512) {
+    this.dim = dim;
+  }
+  one(text) {
+    const v = new Array(this.dim).fill(0);
+    const toks = tokenize(text);
+    for (let i = 0;i < toks.length; i++) {
+      const uni = toks[i];
+      v[fnv1a(uni) % this.dim] += 1;
+      if (i + 1 < toks.length) {
+        const bi = uni + "_" + toks[i + 1];
+        v[fnv1a(bi) % this.dim] += 0.5;
+      }
+    }
+    const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0)) || 1;
+    return v.map((x) => x / norm);
+  }
+  async embed(texts) {
+    return texts.map((t) => this.one(t));
+  }
+}
+
+class OpenAIEmbedder {
+  id;
+  dim = 1536;
+  apiKey;
+  model;
+  fetchFn;
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    this.model = opts.model ?? "text-embedding-3-small";
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.id = `openai:${this.model}`;
+  }
+  async embed(texts) {
+    const res = await this.fetchFn("https://api.openai.com/v1/embeddings", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${this.apiKey}` },
+      body: JSON.stringify({ model: this.model, input: texts })
+    });
+    if (!res.ok)
+      throw new Error(`OpenAI embeddings ${res.status}: ${(await res.text()).slice(0, 200)}`);
+    const data = await res.json();
+    return data.data.map((d) => d.embedding);
+  }
+}
+function getEmbedder() {
+  if (process.env.EXPERTS_EMBEDDER === "openai" && process.env.OPENAI_API_KEY) {
+    return new OpenAIEmbedder;
+  }
+  return new HashingEmbedder;
+}
+function cosine(a, b) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0;i < n; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  const d = Math.sqrt(na) * Math.sqrt(nb);
+  return d === 0 ? 0 : dot / d;
+}
+function packVector(v) {
+  const f = new Float32Array(v);
+  return new Uint8Array(f.buffer);
+}
+function unpackVector(buf) {
+  const ab = buf instanceof Uint8Array ? buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) : buf;
+  return Array.from(new Float32Array(ab));
+}
+function expertEmbedText(e) {
+  return [e.fullName, e.title, e.headline, e.bio, e.topics.join(" "), e.tags.join(" ")].filter(Boolean).join(". ");
+}
+
+// src/identity.ts
+function socialHandles(e) {
+  const out = new Set;
+  for (const [platform, url] of Object.entries(e.socials || {})) {
+    if (!url)
+      continue;
+    const m = String(url).match(/(?:[a-z]+\.[a-z]+\/@?)([A-Za-z0-9_.-]+)/i);
+    const handle = (m ? m[1] : String(url)).toLowerCase().replace(/\/+$/, "");
+    if (handle)
+      out.add(`${platform}:${handle}`);
+  }
+  return out;
+}
+var key = (e) => `${e.source}:${e.sourceId}`;
+function clusterPersons(experts) {
+  const parent = new Map;
+  const find = (x) => {
+    let r = x;
+    while (parent.get(r) !== r)
+      r = parent.get(r);
+    let c = x;
+    while (parent.get(c) !== r) {
+      const n = parent.get(c);
+      parent.set(c, r);
+      c = n;
+    }
+    return r;
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra === rb)
+      return;
+    if (ra < rb)
+      parent.set(rb, ra);
+    else
+      parent.set(ra, rb);
+  };
+  for (const e of experts)
+    parent.set(key(e), key(e));
+  const byHandle = new Map;
+  for (const e of experts) {
+    for (const h of socialHandles(e)) {
+      if (!byHandle.has(h))
+        byHandle.set(h, []);
+      byHandle.get(h).push(key(e));
+    }
+  }
+  for (const members of byHandle.values()) {
+    for (let i = 1;i < members.length; i++)
+      union(members[0], members[i]);
+  }
+  const out = new Map;
+  for (const e of experts)
+    out.set(key(e), find(key(e)));
+  return out;
+}
+
 // src/db.ts
 function defaultDbPath() {
   return process.env.OPEN_EXPERTS_DB || join(homedir(), ".hasna", "experts", "experts.db");
@@ -115,8 +315,59 @@ class ExpertsDB {
         PRIMARY KEY (source, tweet_id)
       );
       CREATE INDEX IF NOT EXISTS idx_tweets_expert ON tweets(source, source_id, created_at DESC);
+
+      -- Enrichment: recent YouTube videos per expert.
+      CREATE TABLE IF NOT EXISTS videos (
+        source TEXT NOT NULL, source_id TEXT NOT NULL,
+        video_id TEXT NOT NULL, title TEXT, description TEXT,
+        published_at TEXT, url TEXT, thumbnail TEXT, view_count INTEGER,
+        PRIMARY KEY (source, video_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_videos_expert ON videos(source, source_id, published_at DESC);
+
+      -- Generic external enrichment (linkedin, site/newsletter, \u2026) as JSON.
+      CREATE TABLE IF NOT EXISTS ext_profiles (
+        source TEXT NOT NULL, source_id TEXT NOT NULL, kind TEXT NOT NULL,
+        data TEXT, enriched_at TEXT,
+        PRIMARY KEY (source, source_id, kind)
+      );
+
+      -- Enrichment: discovered contact methods (multiple email/phone per expert).
+      CREATE TABLE IF NOT EXISTS contacts (
+        source TEXT NOT NULL, source_id TEXT NOT NULL,
+        type TEXT NOT NULL, value TEXT NOT NULL,
+        label TEXT, provider TEXT, confidence REAL,
+        status TEXT DEFAULT 'unverified', verified_at TEXT, created_at TEXT,
+        PRIMARY KEY (source, source_id, type, value)
+      );
+      CREATE INDEX IF NOT EXISTS idx_contacts_expert ON contacts(source, source_id);
+      CREATE INDEX IF NOT EXISTS idx_contacts_status ON contacts(status);
+
+      -- Semantic search: one embedding vector per expert.
+      CREATE TABLE IF NOT EXISTS vectors (
+        source TEXT NOT NULL, source_id TEXT NOT NULL,
+        embedder TEXT NOT NULL, dim INTEGER, vec BLOB,
+        PRIMARY KEY (source, source_id)
+      );
+
+      -- Identity resolution: maps each expert record to a canonical person.
+      CREATE TABLE IF NOT EXISTS persons (
+        source TEXT NOT NULL, source_id TEXT NOT NULL, person_id TEXT NOT NULL,
+        PRIMARY KEY (source, source_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_persons_person ON persons(person_id);
+
+      -- Change detection: a log of what changed between crawls.
+      CREATE TABLE IF NOT EXISTS changes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source TEXT NOT NULL, source_id TEXT NOT NULL,
+        kind TEXT NOT NULL, field TEXT, old_value TEXT, new_value TEXT,
+        detected_at TEXT
+      );
+      CREATE INDEX IF NOT EXISTS idx_changes_time ON changes(detected_at DESC);
     `);
     this.addColumnIfMissing("experts", "avatar_local", "TEXT");
+    this.addColumnIfMissing("experts", "authority", "REAL DEFAULT 0");
   }
   addColumnIfMissing(table, column, type) {
     const cols = this.db.query(`PRAGMA table_info(${table})`).all();
@@ -202,6 +453,7 @@ class ExpertsDB {
       socials: JSON.parse(r.socials || "{}"),
       extra: JSON.parse(r.extra || "{}"),
       avatarLocal: r.avatar_local || undefined,
+      authority: r.authority ?? 0,
       crawledAt: r.crawled_at
     };
   }
@@ -249,7 +501,7 @@ class ExpertsDB {
       where.push("rating >= ?");
       params.push(filters.minRating);
     }
-    const sortCol = filters.sort === "price" ? "price" : filters.sort === "name" ? "full_name" : filters.sort === "reviews" ? "rating_count" : "rating";
+    const sortCol = filters.sort === "price" ? "price" : filters.sort === "name" ? "full_name" : filters.sort === "reviews" ? "rating_count" : filters.sort === "authority" ? "authority" : "rating";
     const defaultAsc = filters.sort === "name";
     const dir = filters.desc ?? !defaultAsc ? "DESC" : "ASC";
     let sql = "SELECT * FROM experts";
@@ -325,11 +577,11 @@ class ExpertsDB {
     sql += " ORDER BY name";
     return this.db.query(sql).all(...params);
   }
-  setMeta(key, value) {
-    this.db.query("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(key, value);
+  setMeta(key2, value) {
+    this.db.query("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value").run(key2, value);
   }
-  getMeta(key) {
-    const row = this.db.query("SELECT value FROM meta WHERE key = ?").get(key);
+  getMeta(key2) {
+    const row = this.db.query("SELECT value FROM meta WHERE key = ?").get(key2);
     return row ? row.value : null;
   }
   stats(source) {
@@ -353,12 +605,12 @@ class ExpertsDB {
       const nodeIds = new Map;
       const insertNode = this.db.query("INSERT INTO kg_nodes (type, key, label) VALUES (?, ?, ?) ON CONFLICT(type, key) DO UPDATE SET label=excluded.label RETURNING id");
       const insertEdge = this.db.query("INSERT OR REPLACE INTO kg_edges (src, dst, rel, weight) VALUES (?, ?, ?, ?)");
-      const node = (type, key, label) => {
-        const ck = `${type}\x00${key.toLowerCase()}`;
+      const node = (type, key2, label) => {
+        const ck = `${type}\x00${key2.toLowerCase()}`;
         const cached = nodeIds.get(ck);
         if (cached != null)
           return cached;
-        const id = insertNode.get(type, key.toLowerCase(), label).id;
+        const id = insertNode.get(type, key2.toLowerCase(), label).id;
         nodeIds.set(ck, id);
         return id;
       };
@@ -368,7 +620,8 @@ class ExpertsDB {
         for (const topic of e.topics) {
           insertEdge.run(eId, node("topic", topic, topic), "IN_TOPIC", 1);
         }
-        const tags = inferTags(expertText(e), vocabulary);
+        const tweetText = this.recentTweets(e.source, e.sourceId, 30).map((t) => t.text).join(". ");
+        const tags = inferTags(expertText(e) + ". " + tweetText, vocabulary);
         for (const tag of tags) {
           insertEdge.run(eId, node("tag", tag, tag), "HAS_TAG", 1);
         }
@@ -381,11 +634,51 @@ class ExpertsDB {
     this.setMeta("graph_built", new Date().toISOString());
     return { nodes, edges };
   }
-  expertFromNodeKey(key) {
-    const idx = key.indexOf(":");
+  rescore(source) {
+    const experts = this.list({ source });
+    const upd = this.db.query("UPDATE experts SET authority = ? WHERE source = ? AND source_id = ?");
+    const followerStmt = this.db.query("SELECT followers FROM x_profiles WHERE source = ? AND source_id = ?");
+    const lastTweetStmt = this.db.query("SELECT MAX(created_at) AS t FROM tweets WHERE source = ? AND source_id = ?");
+    const tx = this.db.transaction((rows) => {
+      for (const e of rows) {
+        const fr = followerStmt.get(e.source, e.sourceId);
+        const lt = lastTweetStmt.get(e.source, e.sourceId);
+        let daysSince;
+        if (lt?.t) {
+          const ms = Date.now() - Date.parse(lt.t);
+          if (!Number.isNaN(ms))
+            daysSince = ms / 86400000;
+        }
+        const score = authorityScore(e, { followers: fr?.followers ?? 0, daysSinceLastTweet: daysSince });
+        upd.run(score, e.source, e.sourceId);
+      }
+    });
+    tx(experts);
+    this.setMeta("rescored_at", new Date().toISOString());
+    return experts.length;
+  }
+  stalest(opts = {}) {
+    const where = opts.source ? "WHERE e.source = ?" : "";
+    const params = opts.source ? [opts.source] : [];
+    const sql = `
+      SELECT e.*, COALESCE(
+        (SELECT MAX(enriched_at) FROM x_profiles xp WHERE xp.source=e.source AND xp.source_id=e.source_id),
+        e.crawled_at
+      ) AS last_seen
+      FROM experts e ${where}
+      ORDER BY last_seen ASC
+      LIMIT ?`;
+    params.push(opts.limit ?? 25);
+    return this.db.query(sql).all(...params).map((r) => ({
+      expert: this.rowToExpert(r),
+      lastSeen: r.last_seen || ""
+    }));
+  }
+  expertFromNodeKey(key2) {
+    const idx = key2.indexOf(":");
     if (idx < 0)
       return null;
-    return this.get(key.slice(idx + 1), key.slice(0, idx));
+    return this.get(key2.slice(idx + 1), key2.slice(0, idx));
   }
   findByNeeds(needs, opts = {}) {
     const cleaned = needs.map((n) => n.trim().toLowerCase()).filter(Boolean);
@@ -574,6 +867,270 @@ class ExpertsDB {
     const avatars = this.db.query(`SELECT COUNT(*) AS n FROM experts WHERE avatar_local IS NOT NULL${source ? " AND source = ?" : ""}`).get(...args).n;
     return { withHandle, enriched, tweets, avatars };
   }
+  recordChanges(source, incoming) {
+    const existing = new Map(this.list({ source }).map((e) => [e.sourceId, e]));
+    const now = new Date().toISOString();
+    const watched = ["price", "title", "headline", "bio", "slug"];
+    const stmt = this.db.query("INSERT INTO changes (source, source_id, kind, field, old_value, new_value, detected_at) VALUES (?, ?, ?, ?, ?, ?, ?)");
+    let count = 0;
+    const tx = this.db.transaction((rows) => {
+      for (const e of rows) {
+        const prev = existing.get(e.sourceId);
+        if (!prev) {
+          stmt.run(source, e.sourceId, "added", null, null, e.fullName || e.slug, now);
+          count++;
+          continue;
+        }
+        for (const f of watched) {
+          const a = String(prev[f] ?? "");
+          const b = String(e[f] ?? "");
+          if (a !== b) {
+            stmt.run(source, e.sourceId, "updated", f, a, b, now);
+            count++;
+          }
+        }
+      }
+    });
+    tx(incoming);
+    return count;
+  }
+  changes(opts = {}) {
+    const where = opts.source ? "WHERE source = ?" : "";
+    const params = opts.source ? [opts.source] : [];
+    params.push(opts.limit ?? 50);
+    return this.db.query(`SELECT * FROM changes ${where} ORDER BY detected_at DESC, id DESC LIMIT ?`).all(...params);
+  }
+  rebuildPersons() {
+    const experts = this.list();
+    const mapping = clusterPersons(experts);
+    const tx = this.db.transaction(() => {
+      this.db.exec("DELETE FROM persons");
+      const stmt = this.db.query("INSERT OR REPLACE INTO persons (source, source_id, person_id) VALUES (?, ?, ?)");
+      for (const [k, pid] of mapping) {
+        const idx = k.indexOf(":");
+        stmt.run(k.slice(0, idx), k.slice(idx + 1), pid);
+      }
+    });
+    tx();
+    const persons = new Set(mapping.values()).size;
+    this.setMeta("persons_built", new Date().toISOString());
+    return { experts: experts.length, persons };
+  }
+  personIdOf(source, sourceId) {
+    const r = this.db.query("SELECT person_id FROM persons WHERE source = ? AND source_id = ?").get(source, sourceId);
+    return r ? r.person_id : `${source}:${sourceId}`;
+  }
+  expertsForPerson(personId) {
+    const rows = this.db.query("SELECT e.* FROM persons p JOIN experts e ON e.source=p.source AND e.source_id=p.source_id WHERE p.person_id = ?").all(personId);
+    return rows.map((r) => this.rowToExpert(r));
+  }
+  personStats() {
+    const experts = this.count();
+    const row = this.db.query("SELECT COUNT(DISTINCT person_id) n FROM persons").get();
+    const persons = row?.n ?? 0;
+    const dupes = this.db.query("SELECT person_id, COUNT(*) c FROM persons GROUP BY person_id HAVING c > 1 ORDER BY c DESC").all();
+    return { experts, persons: persons || experts, duplicated: dupes.length };
+  }
+  async buildEmbeddings(embedder, opts = {}) {
+    const log = opts.onLog ?? (() => {});
+    const experts = this.list({ source: opts.source });
+    const batch = opts.batch ?? 64;
+    const stmt = this.db.query("INSERT OR REPLACE INTO vectors (source, source_id, embedder, dim, vec) VALUES (?, ?, ?, ?, ?)");
+    let done = 0;
+    for (let i = 0;i < experts.length; i += batch) {
+      const slice = experts.slice(i, i + batch);
+      const vecs = await embedder.embed(slice.map((e) => expertEmbedText(e)));
+      const tx = this.db.transaction(() => {
+        slice.forEach((e, j) => stmt.run(e.source, e.sourceId, embedder.id, embedder.dim, packVector(vecs[j])));
+      });
+      tx();
+      done += slice.length;
+      log(`  embedded ${done}/${experts.length}`);
+    }
+    this.setMeta("embedder", embedder.id);
+    this.setMeta("embedded_at", new Date().toISOString());
+    return done;
+  }
+  vectorCount() {
+    return this.db.query("SELECT COUNT(*) n FROM vectors").get().n;
+  }
+  semanticSearch(queryVec, opts = {}) {
+    const where = opts.source ? "WHERE v.source = ?" : "";
+    const params = opts.source ? [opts.source] : [];
+    const rows = this.db.query(`SELECT e.*, v.vec AS _vec FROM vectors v JOIN experts e ON e.source=v.source AND e.source_id=v.source_id ${where}`).all(...params);
+    const scored = rows.map((r) => ({ expert: this.rowToExpert(r), score: cosine(queryVec, unpackVector(r._vec)) }));
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, opts.limit ?? 25);
+  }
+  upsertExt(source, sourceId, kind, data) {
+    this.db.query(`
+        INSERT INTO ext_profiles (source, source_id, kind, data, enriched_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(source, source_id, kind) DO UPDATE SET data=excluded.data, enriched_at=excluded.enriched_at
+      `).run(source, sourceId, kind, JSON.stringify(data), new Date().toISOString());
+  }
+  getExt(source, sourceId, kind) {
+    const r = this.db.query("SELECT data FROM ext_profiles WHERE source=? AND source_id=? AND kind=?").get(source, sourceId, kind);
+    return r ? JSON.parse(r.data || "{}") : null;
+  }
+  allExt(source, sourceId) {
+    const rows = this.db.query("SELECT kind, data FROM ext_profiles WHERE source=? AND source_id=?").all(source, sourceId);
+    return Object.fromEntries(rows.map((r) => [r.kind, JSON.parse(r.data || "{}")]));
+  }
+  expertsNeedingExt(platform, kind, opts = {}) {
+    const where = [`json_extract(socials, '$.${platform}') IS NOT NULL`];
+    const bind = [];
+    if (opts.source) {
+      where.push("source = ?");
+      bind.push(opts.source);
+    }
+    if (!opts.refresh) {
+      where.push("NOT EXISTS (SELECT 1 FROM ext_profiles x WHERE x.source=experts.source AND x.source_id=experts.source_id AND x.kind=?)");
+      bind.push(kind);
+    }
+    let sql = "SELECT * FROM experts WHERE " + where.join(" AND ") + " ORDER BY rating_count DESC";
+    if (opts.limit) {
+      sql += " LIMIT ?";
+      bind.push(opts.limit);
+    }
+    return this.db.query(sql).all(...bind).map((r) => this.rowToExpert(r));
+  }
+  replaceVideos(source, sourceId, videos) {
+    const tx = this.db.transaction((rows) => {
+      this.db.query("DELETE FROM videos WHERE source = ? AND source_id = ?").run(source, sourceId);
+      const stmt = this.db.query("INSERT OR REPLACE INTO videos (source, source_id, video_id, title, description, published_at, url, thumbnail, view_count) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+      for (const v of rows) {
+        stmt.run(v.source, v.sourceId, v.videoId, v.title, v.description, v.publishedAt, v.url, v.thumbnail, v.viewCount);
+      }
+    });
+    tx(videos);
+  }
+  recentVideos(source, sourceId, limit = 10) {
+    const rows = this.db.query("SELECT * FROM videos WHERE source = ? AND source_id = ? ORDER BY published_at DESC LIMIT ?").all(source, sourceId, limit);
+    return rows.map((r) => ({
+      source: r.source,
+      sourceId: r.source_id,
+      videoId: r.video_id,
+      title: r.title || "",
+      description: r.description || "",
+      publishedAt: r.published_at || "",
+      url: r.url || "",
+      thumbnail: r.thumbnail || "",
+      viewCount: r.view_count ?? 0
+    }));
+  }
+  expertsNeedingVideos(opts = {}) {
+    const where = ["json_extract(socials, '$.youtube') IS NOT NULL"];
+    const params = [];
+    if (opts.source) {
+      where.push("source = ?");
+      params.push(opts.source);
+    }
+    if (!opts.refresh) {
+      where.push("NOT EXISTS (SELECT 1 FROM videos v WHERE v.source=experts.source AND v.source_id=experts.source_id)");
+    }
+    let sql = "SELECT * FROM experts WHERE " + where.join(" AND ") + " ORDER BY rating_count DESC";
+    if (opts.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.query(sql).all(...params).map((r) => this.rowToExpert(r));
+  }
+  upsertContact(c) {
+    this.db.query(`
+        INSERT INTO contacts (source, source_id, type, value, label, provider, confidence, status, verified_at, created_at)
+        VALUES ($source, $source_id, $type, $value, $label, $provider, $confidence, $status, $verified_at, $created_at)
+        ON CONFLICT(source, source_id, type, value) DO UPDATE SET
+          label=excluded.label, provider=excluded.provider, confidence=excluded.confidence,
+          status=CASE WHEN excluded.status != 'unverified' THEN excluded.status ELSE contacts.status END,
+          verified_at=COALESCE(excluded.verified_at, contacts.verified_at)
+      `).run({
+      $source: c.source,
+      $source_id: c.sourceId,
+      $type: c.type,
+      $value: c.value,
+      $label: c.label,
+      $provider: c.provider,
+      $confidence: c.confidence,
+      $status: c.status,
+      $verified_at: c.verifiedAt || null,
+      $created_at: c.createdAt || new Date().toISOString()
+    });
+  }
+  setContactStatus(source, sourceId, type, value, status) {
+    this.db.query("UPDATE contacts SET status = ?, verified_at = ? WHERE source = ? AND source_id = ? AND type = ? AND value = ?").run(status, new Date().toISOString(), source, sourceId, type, value);
+  }
+  contacts(source, sourceId) {
+    const rows = this.db.query("SELECT * FROM contacts WHERE source = ? AND source_id = ? ORDER BY type, confidence DESC").all(source, sourceId);
+    return rows.map((r) => ({
+      source: r.source,
+      sourceId: r.source_id,
+      type: r.type,
+      value: r.value,
+      label: r.label || "",
+      provider: r.provider || "",
+      confidence: r.confidence ?? 0,
+      status: r.status || "unverified",
+      verifiedAt: r.verified_at || "",
+      createdAt: r.created_at || ""
+    }));
+  }
+  contactsToVerify(opts = {}) {
+    const where = ["status = 'unverified'"];
+    const params = [];
+    if (opts.source) {
+      where.push("source = ?");
+      params.push(opts.source);
+    }
+    let sql = "SELECT * FROM contacts WHERE " + where.join(" AND ") + " ORDER BY confidence DESC";
+    if (opts.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.query(sql).all(...params).map((r) => ({
+      source: r.source,
+      sourceId: r.source_id,
+      type: r.type,
+      value: r.value,
+      label: r.label || "",
+      provider: r.provider || "",
+      confidence: r.confidence ?? 0,
+      status: r.status || "unverified",
+      verifiedAt: r.verified_at || "",
+      createdAt: r.created_at || ""
+    }));
+  }
+  expertsNeedingContacts(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.source) {
+      where.push("source = ?");
+      params.push(opts.source);
+    }
+    if (!opts.refresh) {
+      where.push("NOT EXISTS (SELECT 1 FROM contacts c WHERE c.source = experts.source AND c.source_id = experts.source_id)");
+    }
+    let sql = "SELECT * FROM experts";
+    if (where.length)
+      sql += " WHERE " + where.join(" AND ");
+    sql += " ORDER BY rating_count DESC";
+    if (opts.limit) {
+      sql += " LIMIT ?";
+      params.push(opts.limit);
+    }
+    return this.db.query(sql).all(...params).map((r) => this.rowToExpert(r));
+  }
+  contactStats(source) {
+    const filt = source ? " WHERE source = ?" : "";
+    const args = source ? [source] : [];
+    const total = this.db.query(`SELECT COUNT(*) n FROM contacts${filt}`).get(...args).n;
+    const valid = this.db.query(`SELECT COUNT(*) n FROM contacts WHERE status='valid'${source ? " AND source = ?" : ""}`).get(...args).n;
+    const invalid = this.db.query(`SELECT COUNT(*) n FROM contacts WHERE status='invalid'${source ? " AND source = ?" : ""}`).get(...args).n;
+    const emails = this.db.query(`SELECT COUNT(*) n FROM contacts WHERE type='email'${source ? " AND source = ?" : ""}`).get(...args).n;
+    const phones = this.db.query(`SELECT COUNT(*) n FROM contacts WHERE type='phone'${source ? " AND source = ?" : ""}`).get(...args).n;
+    const expertsWith = this.db.query(`SELECT COUNT(DISTINCT source||source_id) n FROM contacts${filt}`).get(...args).n;
+    return { total, valid, invalid, emails, phones, expertsWith };
+  }
   close() {
     this.db.close();
   }
@@ -792,62 +1349,393 @@ class IntroSource {
   }
 }
 
-// src/sources/index.ts
-var registry = new Map;
-function registerSource(source) {
-  registry.set(source.name, source);
-}
-function getSource(name) {
-  return registry.get(name);
+// src/sources/common.ts
+function makeExpert(p) {
+  const first = p.firstName ?? "";
+  const last = p.lastName ?? "";
+  return {
+    source: p.source,
+    sourceId: p.sourceId,
+    slug: p.slug ?? "",
+    url: p.url ?? "",
+    fullName: p.fullName ?? [first, last].filter(Boolean).join(" "),
+    firstName: first,
+    lastName: last,
+    title: p.title ?? "",
+    headline: p.headline ?? "",
+    bio: p.bio ?? "",
+    avatar: p.avatar ?? "",
+    price: p.price ?? 0,
+    priceCurrency: p.priceCurrency ?? "USD",
+    priceUnit: p.priceUnit ?? "",
+    rating: p.rating ?? 0,
+    ratingCount: p.ratingCount ?? 0,
+    verified: p.verified ?? false,
+    featured: p.featured ?? false,
+    topics: p.topics ? [...new Set(p.topics)].sort() : [],
+    tags: p.tags ?? [],
+    socials: p.socials ?? {},
+    extra: p.extra ?? {},
+    crawledAt: p.crawledAt ?? new Date().toISOString()
+  };
 }
-function listSources() {
-  return [...registry.values()];
+function slugify(s) {
+  return (s || "").toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
-registerSource(new IntroSource);
-
-// src/crawl.ts
-async function crawlSource(db, sourceName, opts = {}) {
-  const source = getSource(sourceName);
-  if (!source) {
-    throw new Error(`Unknown source "${sourceName}". Run \`experts sources\` to list options.`);
+async function fetchJson(url, fetchFn, init = {}) {
+  try {
+    const res = await fetchFn(url, {
+      ...init,
+      headers: {
+        "User-Agent": "open-experts (+https://github.com/hasna/experts)",
+        Accept: "application/json",
+        ...init.headers || {}
+      }
+    });
+    if (!res.ok)
+      return null;
+    return await res.json();
+  } catch {
+    return null;
   }
-  const data = await source.crawl(opts);
-  db.upsertExperts(data.experts);
-  if (data.topics.length)
-    db.setTopics(source.name, data.topics);
-  db.setTags(source.name, data.tags);
-  db.setMeta(`last_crawl:${source.name}`, new Date().toISOString());
-  db.setMeta(`catalog_total:${source.name}`, String(data.total));
-  opts.onLog?.("building knowledge graph\u2026");
-  const graph = db.rebuildGraph();
-  return {
-    source: source.name,
-    experts: data.experts.length,
-    topics: data.topics.map((t) => ({ name: t.name, count: t.expertCount })),
-    tags: new Set(data.tags.map((t) => t.name)).size,
-    total: data.total,
-    graph
-  };
 }
 
-// src/format.ts
-import chalk from "chalk";
-function money(amount, currency = "USD") {
-  const symbol = currency === "USD" ? "$" : `${currency} `;
-  return `${symbol}${amount.toLocaleString("en-US")}`;
+// src/sources/mentorcruise.ts
+function normalizeMentor(m, crawledAt) {
+  const slug = m.slug || slugify(m.name || String(m.id ?? ""));
+  const socials = {};
+  if (m.twitter)
+    socials.twitter = m.twitter.startsWith("http") ? m.twitter : `https://x.com/${m.twitter}`;
+  if (m.linkedin)
+    socials.linkedin = m.linkedin;
+  return makeExpert({
+    source: "mentorcruise",
+    sourceId: String(m.id ?? slug),
+    slug,
+    url: `https://mentorcruise.com/mentor/${slug}/`,
+    fullName: m.name ?? [m.first_name, m.last_name].filter(Boolean).join(" "),
+    firstName: m.first_name ?? "",
+    lastName: m.last_name ?? "",
+    title: m.job_title ?? "",
+    bio: m.bio ?? "",
+    avatar: m.avatar ?? m.photo ?? "",
+    price: m.price ?? 0,
+    priceCurrency: m.currency ?? "USD",
+    priceUnit: m.price ? "per month" : "",
+    rating: m.rating ?? 0,
+    ratingCount: m.reviews_count ?? 0,
+    verified: Boolean(m.verified),
+    featured: Boolean(m.is_top_mentor),
+    topics: m.categories ?? [],
+    tags: m.skills ?? [],
+    socials,
+    crawledAt
+  });
 }
-function stars(rating, count) {
-  const full = Math.round(rating);
-  const bar = "\u2605".repeat(full) + "\u2606".repeat(Math.max(0, 5 - full));
-  const label = rating ? rating.toFixed(2) : "\u2014";
-  return `${chalk.yellow(bar)} ${label} ${chalk.dim(`(${count})`)}`;
+
+class MentorCruiseSource {
+  name = "mentorcruise";
+  description = "MentorCruise \u2014 long-term mentorship from vetted mentors";
+  website = "https://mentorcruise.com";
+  fetchFn;
+  apiBase;
+  pageSize;
+  constructor(opts = {}) {
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.apiBase = opts.apiBase ?? process.env.MENTORCRUISE_API_BASE ?? "https://mentorcruise.com/api";
+    this.pageSize = opts.pageSize ?? 50;
+  }
+  async crawl(opts = {}) {
+    const log = opts.onLog ?? (() => {});
+    const crawledAt = new Date().toISOString();
+    const experts = [];
+    const tags = new Set;
+    let offset = 0;
+    for (;; ) {
+      const data = await fetchJson(`${this.apiBase}/mentors/?limit=${this.pageSize}&offset=${offset}`, this.fetchFn);
+      const items = data?.results ?? data?.data ?? (Array.isArray(data) ? data : []);
+      if (!items.length)
+        break;
+      for (const m of items) {
+        const e = normalizeMentor(m, crawledAt);
+        experts.push(e);
+        for (const t of e.tags)
+          tags.add(t);
+      }
+      offset += items.length;
+      log(`  mentorcruise: ${experts.length}`);
+      if (opts.max && experts.length >= opts.max)
+        break;
+      if (items.length < this.pageSize)
+        break;
+    }
+    if (experts.length === 0) {
+      log("mentorcruise: no public listing reachable (set MENTORCRUISE_API_BASE or provide a fetchFn).");
+    }
+    const topics = [];
+    return {
+      experts: opts.max ? experts.slice(0, opts.max) : experts,
+      topics,
+      tags: [...tags].map((name) => ({ name, topic: "" })),
+      total: experts.length
+    };
+  }
 }
-function truncate(s, n) {
-  const clean = (s || "").replace(/\s+/g, " ").trim();
-  return clean.length > n ? clean.slice(0, n - 1) + "\u2026" : clean;
+
+// src/sources/adplist.ts
+function normalizeAdpMentor(m, crawledAt) {
+  const slug = m.username || slugify(m.name || m.full_name || String(m.id ?? ""));
+  const socials = {};
+  if (m.twitter)
+    socials.twitter = m.twitter.startsWith("http") ? m.twitter : `https://x.com/${m.twitter}`;
+  if (m.linkedin)
+    socials.linkedin = m.linkedin;
+  return makeExpert({
+    source: "adplist",
+    sourceId: String(m.id ?? slug),
+    slug,
+    url: `https://adplist.org/mentors/${slug}`,
+    fullName: m.name ?? m.full_name ?? "",
+    title: m.headline ?? m.tagline ?? "",
+    headline: m.tagline ?? "",
+    bio: m.bio ?? m.about ?? "",
+    avatar: m.profile_photo ?? m.avatar ?? "",
+    price: 0,
+    priceUnit: "free session",
+    rating: m.rating ?? 0,
+    ratingCount: m.total_reviews ?? 0,
+    verified: Boolean(m.verified),
+    featured: Boolean(m.is_featured),
+    tags: m.expertise ?? m.skills ?? [],
+    socials,
+    crawledAt
+  });
 }
-function badges(e) {
-  const parts = [];
+
+class ADPListSource {
+  name = "adplist";
+  description = "ADPList \u2014 free mentorship across design, product & engineering";
+  website = "https://adplist.org";
+  fetchFn;
+  apiBase;
+  pageSize;
+  constructor(opts = {}) {
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.apiBase = opts.apiBase ?? process.env.ADPLIST_API_BASE ?? "https://api.adplist.org/api";
+    this.pageSize = opts.pageSize ?? 50;
+  }
+  async crawl(opts = {}) {
+    const log = opts.onLog ?? (() => {});
+    const crawledAt = new Date().toISOString();
+    const experts = [];
+    const tags = new Set;
+    let page = 1;
+    for (;; ) {
+      const data = await fetchJson(`${this.apiBase}/mentors/?page=${page}&page_size=${this.pageSize}`, this.fetchFn);
+      const items = data?.results ?? data?.data ?? (Array.isArray(data) ? data : []);
+      if (!items.length)
+        break;
+      for (const m of items) {
+        const e = normalizeAdpMentor(m, crawledAt);
+        experts.push(e);
+        for (const t of e.tags)
+          tags.add(t);
+      }
+      log(`  adplist: ${experts.length}`);
+      page++;
+      if (opts.max && experts.length >= opts.max)
+        break;
+      if (items.length < this.pageSize)
+        break;
+    }
+    if (experts.length === 0)
+      log("adplist: no public listing reachable (set ADPLIST_API_BASE or provide a fetchFn).");
+    return {
+      experts: opts.max ? experts.slice(0, opts.max) : experts,
+      topics: [],
+      tags: [...tags].map((name) => ({ name, topic: "" })),
+      total: experts.length
+    };
+  }
+}
+
+// src/sources/clarity.ts
+function normalizeClarityExpert(c, crawledAt) {
+  const slug = c.username || slugify(c.name || String(c.id ?? ""));
+  return makeExpert({
+    source: "clarity",
+    sourceId: String(c.id ?? slug),
+    slug,
+    url: `https://clarity.fm/${slug}`,
+    fullName: c.name ?? "",
+    title: c.title ?? "",
+    bio: c.bio ?? "",
+    avatar: c.image ?? "",
+    price: c.rate_per_minute ?? 0,
+    priceCurrency: "USD",
+    priceUnit: c.rate_per_minute ? "per minute" : "",
+    rating: c.rating ?? 0,
+    ratingCount: c.reviews ?? 0,
+    topics: c.categories ?? [],
+    tags: c.expertise ?? [],
+    crawledAt
+  });
+}
+
+class ClaritySource {
+  name = "clarity";
+  description = "Clarity.fm \u2014 on-demand expert calls billed per minute";
+  website = "https://clarity.fm";
+  fetchFn;
+  apiBase;
+  constructor(opts = {}) {
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.apiBase = opts.apiBase ?? process.env.CLARITY_API_BASE;
+  }
+  async crawl(opts = {}) {
+    const log = opts.onLog ?? (() => {});
+    if (!this.apiBase) {
+      log("clarity: no public listing API; set CLARITY_API_BASE or inject a fetchFn to crawl.");
+      return { experts: [], topics: [], tags: [], total: 0 };
+    }
+    const crawledAt = new Date().toISOString();
+    const data = await fetchJson(`${this.apiBase}/experts`, this.fetchFn);
+    const items = data?.results ?? data?.data ?? (Array.isArray(data) ? data : []);
+    const experts = items.map((c) => normalizeClarityExpert(c, crawledAt));
+    const tags = new Set;
+    for (const e of experts)
+      for (const t of e.tags)
+        tags.add(t);
+    return {
+      experts: opts.max ? experts.slice(0, opts.max) : experts,
+      topics: [],
+      tags: [...tags].map((name) => ({ name, topic: "" })),
+      total: experts.length
+    };
+  }
+}
+
+// src/sources/glg.ts
+function normalizeGlgExpert(g, crawledAt) {
+  const slug = slugify(g.name || String(g.id ?? ""));
+  return makeExpert({
+    source: "glg",
+    sourceId: String(g.id ?? slug),
+    slug,
+    url: "https://glginsights.com",
+    fullName: g.name ?? "",
+    title: g.title ?? "",
+    bio: g.biography ?? "",
+    price: g.hourly_rate ?? 0,
+    priceCurrency: g.currency ?? "USD",
+    priceUnit: g.hourly_rate ? "per hour" : "",
+    topics: g.industries ?? [],
+    tags: g.expertise_areas ?? [],
+    crawledAt
+  });
+}
+
+class GLGSource {
+  name = "glg";
+  description = "GLG \u2014 enterprise expert network (requires partner API access)";
+  website = "https://glginsights.com";
+  fetchFn;
+  apiBase;
+  apiKey;
+  constructor(opts = {}) {
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.apiBase = opts.apiBase ?? process.env.GLG_API_BASE;
+    this.apiKey = opts.apiKey ?? process.env.GLG_API_KEY;
+  }
+  async crawl(opts = {}) {
+    const log = opts.onLog ?? (() => {});
+    if (!this.apiBase) {
+      log("glg: enterprise-gated; no public directory. Set GLG_API_BASE + GLG_API_KEY (partner access) to crawl.");
+      return { experts: [], topics: [], tags: [], total: 0 };
+    }
+    const crawledAt = new Date().toISOString();
+    const data = await fetchJson(`${this.apiBase}/experts`, this.fetchFn, {
+      headers: this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+    });
+    const items = data?.results ?? data?.data ?? (Array.isArray(data) ? data : []);
+    const experts = items.map((g) => normalizeGlgExpert(g, crawledAt));
+    const tags = new Set;
+    for (const e of experts)
+      for (const t of e.tags)
+        tags.add(t);
+    return {
+      experts: opts.max ? experts.slice(0, opts.max) : experts,
+      topics: [],
+      tags: [...tags].map((name) => ({ name, topic: "" })),
+      total: experts.length
+    };
+  }
+}
+
+// src/sources/index.ts
+var registry = new Map;
+function registerSource(source) {
+  registry.set(source.name, source);
+}
+function getSource(name) {
+  return registry.get(name);
+}
+function listSources() {
+  return [...registry.values()];
+}
+registerSource(new IntroSource);
+registerSource(new MentorCruiseSource);
+registerSource(new ADPListSource);
+registerSource(new ClaritySource);
+registerSource(new GLGSource);
+
+// src/crawl.ts
+async function crawlSource(db, sourceName, opts = {}) {
+  const source = getSource(sourceName);
+  if (!source) {
+    throw new Error(`Unknown source "${sourceName}". Run \`experts sources\` to list options.`);
+  }
+  const data = await source.crawl(opts);
+  const changes = db.recordChanges(source.name, data.experts);
+  db.upsertExperts(data.experts);
+  if (data.topics.length)
+    db.setTopics(source.name, data.topics);
+  db.setTags(source.name, data.tags);
+  db.setMeta(`last_crawl:${source.name}`, new Date().toISOString());
+  db.setMeta(`catalog_total:${source.name}`, String(data.total));
+  opts.onLog?.("building knowledge graph\u2026");
+  const graph = db.rebuildGraph();
+  db.rescore(source.name);
+  db.rebuildPersons();
+  return {
+    source: source.name,
+    experts: data.experts.length,
+    topics: data.topics.map((t) => ({ name: t.name, count: t.expertCount })),
+    tags: new Set(data.tags.map((t) => t.name)).size,
+    total: data.total,
+    graph,
+    changes
+  };
+}
+
+// src/format.ts
+import chalk from "chalk";
+function money(amount, currency = "USD") {
+  const symbol = currency === "USD" ? "$" : `${currency} `;
+  return `${symbol}${amount.toLocaleString("en-US")}`;
+}
+function stars(rating, count) {
+  const full = Math.round(rating);
+  const bar = "\u2605".repeat(full) + "\u2606".repeat(Math.max(0, 5 - full));
+  const label = rating ? rating.toFixed(2) : "\u2014";
+  return `${chalk.yellow(bar)} ${label} ${chalk.dim(`(${count})`)}`;
+}
+function truncate(s, n) {
+  const clean = (s || "").replace(/\s+/g, " ").trim();
+  return clean.length > n ? clean.slice(0, n - 1) + "\u2026" : clean;
+}
+function badges(e) {
+  const parts = [];
   if (e.featured)
     parts.push(chalk.bgYellow.black(" TOP "));
   if (e.verified)
@@ -907,6 +1795,36 @@ function formatDetail(e, enrichment = {}) {
       L.push(`  ${chalk.dim((t.createdAt || "").slice(0, 10))} ${truncate(t.text, 80)}`);
     }
   }
+  const ext = enrichment.ext ?? {};
+  const li = ext.linkedin;
+  if (li && (li.headline || li.company)) {
+    L.push("");
+    L.push(chalk.bold.blue("LinkedIn") + `  ${[li.headline, li.company].filter(Boolean).join(" \xB7 ")}`);
+    if (li.about)
+      L.push(chalk.dim(wrap(String(li.about), 80)));
+  }
+  const site = ext.site;
+  if (site && site.summary) {
+    L.push("");
+    L.push(chalk.dim("Site ") + chalk.dim(String(site.url || "")));
+    L.push(wrap(truncate(String(site.summary), 280), 88));
+  }
+  const videos = enrichment.videos ?? [];
+  if (videos.length) {
+    L.push("");
+    L.push(chalk.dim(`Recent videos (${videos.length}):`));
+    for (const v of videos.slice(0, 5))
+      L.push(`  ${chalk.dim((v.publishedAt || "").slice(0, 10))} ${truncate(v.title, 70)}`);
+  }
+  const contacts = enrichment.contacts ?? [];
+  if (contacts.length) {
+    L.push("");
+    L.push(chalk.dim("Contacts:"));
+    for (const c of contacts) {
+      const mark = c.status === "valid" ? chalk.green("\u2713") : c.status === "invalid" ? chalk.red("\u2717") : chalk.dim("\xB7");
+      L.push(`  ${mark} ${c.type}: ${c.value}`);
+    }
+  }
   const eq = e.extra?.exampleQuestions || [];
   if (eq.length) {
     L.push("");
@@ -970,11 +1888,48 @@ import { join as join2 } from "path";
 import { mkdirSync as mkdirSync2 } from "fs";
 
 // src/connectors.ts
+class CredentialPool {
+  creds;
+  cooldownMs;
+  cooldownUntil = new Map;
+  constructor(creds, cooldownMs = 15 * 60 * 1000) {
+    this.creds = creds;
+    this.cooldownMs = cooldownMs;
+  }
+  static fromEnv(variable) {
+    const sets = [];
+    const csv = process.env[`${variable}S`];
+    if (csv) {
+      csv.split(",").map((t) => t.trim()).filter(Boolean).forEach((t, i) => sets.push({ name: `${variable}#csv${i + 1}`, env: { [variable]: t } }));
+    }
+    if (process.env[variable])
+      sets.push({ name: `${variable}#1`, env: { [variable]: process.env[variable] } });
+    for (let i = 2;i <= 10; i++) {
+      const v = process.env[`${variable}_${i}`];
+      if (v)
+        sets.push({ name: `${variable}#${i}`, env: { [variable]: v } });
+    }
+    return new CredentialPool(sets);
+  }
+  size() {
+    return this.creds.length;
+  }
+  available(now = Date.now()) {
+    return this.creds.filter((c) => (this.cooldownUntil.get(c.name) ?? 0) <= now);
+  }
+  next(now = Date.now()) {
+    return this.available(now)[0] ?? null;
+  }
+  cooldown(name, now = Date.now()) {
+    this.cooldownUntil.set(name, now + this.cooldownMs);
+  }
+}
 function defaultRunner(bin = "connectors") {
-  return async (connector, args) => {
+  return async (connector, args, env) => {
     const proc = Bun.spawn([bin, "run", connector, ...args, "--format", "json"], {
       stdout: "pipe",
-      stderr: "pipe"
+      stderr: "pipe",
+      env: env ? { ...process.env, ...env } : process.env
     });
     const [out, err, code] = await Promise.all([
       new Response(proc.stdout).text(),
@@ -1018,9 +1973,30 @@ function extractJson(text) {
 }
 
 class ConnectorsClient {
-  run;
+  runner;
+  pool;
   constructor(opts = {}) {
-    this.run = opts.runner ?? defaultRunner(opts.bin);
+    this.runner = opts.runner ?? defaultRunner(opts.bin);
+    this.pool = opts.pool;
+  }
+  async run(connector, args) {
+    if (!this.pool || this.pool.size() <= 1) {
+      return this.runner(connector, args, this.pool?.next()?.env);
+    }
+    const tries = this.pool.size();
+    for (let i = 0;i < tries; i++) {
+      const cred = this.pool.next();
+      if (!cred) {
+        return { success: false, quotaExhausted: true, error: "all credentials are in cooldown" };
+      }
+      const res = await this.runner(connector, args, cred.env);
+      if (res.quotaExhausted || res.rateLimited) {
+        this.pool.cooldown(cred.name);
+        continue;
+      }
+      return res;
+    }
+    return { success: false, quotaExhausted: true, error: "all credentials exhausted" };
   }
   async xUser(username) {
     const result = await this.run("x", ["users", "get", username]);
@@ -1073,10 +2049,65 @@ class ConnectorsClient {
     });
     return { tweets, result };
   }
+  async ytVideos(query, opts = {}) {
+    const result = await this.run("youtube", [
+      "search",
+      "--query",
+      query,
+      "--type",
+      "video",
+      "--order",
+      "date",
+      "--max",
+      String(opts.max ?? 10)
+    ]);
+    if (!result.success)
+      return { videos: [], result };
+    const items = result.data?.items ?? result.data?.data ?? (Array.isArray(result.data) ? result.data : []);
+    const videos = items.map((it) => parseYouTubeItem(it)).filter((v) => v !== null);
+    return { videos, result };
+  }
+  async linkedInProfile(handle) {
+    const result = await this.run("linkedin", ["profile", "get", handle]);
+    if (!result.success)
+      return { profile: null, result };
+    const d = result.data?.data ?? result.data ?? {};
+    if (!d || !d.headline && !d.about && !d.summary)
+      return { profile: null, result };
+    return {
+      profile: {
+        headline: d.headline ?? d.occupation ?? "",
+        company: d.company ?? d.companyName ?? "",
+        about: d.about ?? d.summary ?? "",
+        location: d.location ?? d.locationName ?? ""
+      },
+      result
+    };
+  }
+}
+function parseYouTubeItem(it) {
+  const id = typeof it?.id === "string" ? it.id : it?.id?.videoId ?? it?.videoId;
+  if (!id)
+    return null;
+  const sn = it?.snippet ?? it ?? {};
+  const stats = it?.statistics ?? {};
+  const thumb = sn?.thumbnails?.high?.url ?? sn?.thumbnails?.default?.url ?? "";
+  return {
+    id: String(id),
+    title: sn.title ?? "",
+    description: sn.description ?? "",
+    publishedAt: sn.publishedAt ?? sn.publishTime ?? "",
+    url: `https://www.youtube.com/watch?v=${id}`,
+    thumbnail: thumb,
+    viewCount: Number(stats.viewCount ?? 0)
+  };
 }
 
 // src/enrich.ts
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+function defaultXClient() {
+  return new ConnectorsClient({ pool: CredentialPool.fromEnv("X_BEARER_TOKEN") });
+}
 function avatarDir() {
   return process.env.OPEN_EXPERTS_AVATARS || join2(homedir2(), ".hasna", "experts", "avatars");
 }
@@ -1116,7 +2147,7 @@ async function downloadAvatar(url, e, fetchFn = fetch) {
   return path;
 }
 async function enrichExpert(db, e, opts) {
-  const client = opts.client ?? new ConnectorsClient;
+  const client = opts.client ?? defaultXClient();
   const handle = handleFromSocial(e.socials.twitter || "");
   const now = new Date().toISOString();
   if (!handle)
@@ -1208,9 +2239,37 @@ async function enrichExpert(db, e, opts) {
   }
   return { ok: true, notFound: false, tweets: tweetCount, avatar, rateLimited: false, quotaExhausted: false };
 }
+async function backfillAvatars(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const fetchFn = opts.fetchFn ?? fetch;
+  const delayMs = opts.delayMs ?? 150;
+  const experts = db.list({ source: opts.source });
+  const res = { downloaded: 0, skipped: 0, failed: 0 };
+  for (const e of experts) {
+    if (e.avatarLocal || !e.avatar) {
+      res.skipped++;
+      continue;
+    }
+    try {
+      const path = await downloadAvatar(e.avatar, e, fetchFn);
+      if (path) {
+        db.setAvatarLocal(e.source, e.sourceId, path);
+        res.downloaded++;
+        if (res.downloaded % 100 === 0)
+          log(`  avatars: ${res.downloaded} downloaded`);
+      } else {
+        res.failed++;
+      }
+    } catch {
+      res.failed++;
+    }
+    await sleep2(delayMs);
+  }
+  return res;
+}
 async function enrichX(db, opts = {}) {
   const log = opts.onLog ?? (() => {});
-  const client = opts.client ?? new ConnectorsClient;
+  const client = opts.client ?? defaultXClient();
   const delayMs = opts.delayMs ?? 1200;
   const staleBefore = opts.refresh ? undefined : opts.sinceDays ? new Date(Date.now() - opts.sinceDays * 86400000).toISOString() : undefined;
   const targets = db.expertsToEnrich({
@@ -1267,13 +2326,440 @@ async function enrichX(db, opts = {}) {
   db.setMeta(`last_enrich:x:${opts.source ?? "all"}`, new Date().toISOString());
   return res;
 }
+async function enrichYouTube(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const client = opts.client ?? new ConnectorsClient;
+  const delayMs = opts.delayMs ?? 500;
+  const targets = db.expertsNeedingVideos({ source: opts.source, refresh: opts.refresh, limit: opts.max });
+  const res = { attempted: 0, withVideos: 0, videos: 0, stoppedEarly: false };
+  for (let i = 0;i < targets.length; i++) {
+    const e = targets[i];
+    res.attempted++;
+    let found;
+    try {
+      found = await client.ytVideos(e.fullName || e.slug, { max: opts.videoMax ?? 10 });
+    } catch (err) {
+      log(`  ${e.slug}: error ${err?.message || err}`);
+      await sleep2(delayMs);
+      continue;
+    }
+    if (found.result.quotaExhausted) {
+      res.stoppedEarly = true;
+      res.reason = "YouTube API quota exhausted \u2014 top up or wait, then re-run";
+      res.attempted--;
+      break;
+    }
+    if (found.result.rateLimited && found.videos.length === 0) {
+      res.stoppedEarly = true;
+      res.reason = "YouTube rate limited \u2014 resume later";
+      res.attempted--;
+      break;
+    }
+    const rows = found.videos.map((v) => ({
+      source: e.source,
+      sourceId: e.sourceId,
+      videoId: v.id,
+      title: v.title,
+      description: v.description,
+      publishedAt: v.publishedAt,
+      url: v.url,
+      thumbnail: v.thumbnail,
+      viewCount: v.viewCount
+    }));
+    db.replaceVideos(e.source, e.sourceId, rows);
+    if (rows.length)
+      res.withVideos++;
+    res.videos += rows.length;
+    log(`  [${res.attempted}/${targets.length}] ${e.fullName || e.slug}: ${rows.length} videos`);
+    await sleep2(delayMs);
+  }
+  db.setMeta(`last_youtube:${opts.source ?? "all"}`, new Date().toISOString());
+  return res;
+}
+async function liveTweets(db, e, opts = {}) {
+  const client = opts.client ?? defaultXClient();
+  let xId = db.getXProfile(e.source, e.sourceId)?.xId || "";
+  if (!xId) {
+    const handle = handleFromSocial(e.socials.twitter || "");
+    if (!handle)
+      return { tweets: [], rateLimited: false, quotaExhausted: false };
+    const { user, result: result2 } = await client.xUser(handle);
+    if (!user)
+      return { tweets: [], rateLimited: !!result2.rateLimited, quotaExhausted: !!result2.quotaExhausted };
+    xId = user.id;
+  }
+  const { tweets, result } = await client.xTimeline(xId, { max: opts.max ?? 10, replies: false });
+  const rows = tweets.map((t) => ({
+    source: e.source,
+    sourceId: e.sourceId,
+    tweetId: t.id,
+    text: t.text,
+    createdAt: t.createdAt,
+    retweetCount: t.retweetCount,
+    replyCount: t.replyCount,
+    likeCount: t.likeCount,
+    quoteCount: t.quoteCount,
+    impressionCount: t.impressionCount,
+    isRetweet: t.isRetweet,
+    isReply: t.isReply
+  }));
+  return { tweets: rows, rateLimited: !!result.rateLimited, quotaExhausted: !!result.quotaExhausted };
+}
+function linkedinHandle(value) {
+  if (!value)
+    return "";
+  const m = value.match(/linkedin\.com\/(?:in|company)\/([^/?#]+)/i);
+  if (m)
+    return m[1];
+  return value.replace(/^https?:\/\/[^/]+\//, "").replace(/^@/, "").split(/[/?#]/)[0] ?? "";
+}
+async function enrichLinkedIn(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const client = opts.client ?? new ConnectorsClient;
+  const delayMs = opts.delayMs ?? 500;
+  const targets = db.expertsNeedingExt("linkedin", "linkedin", { source: opts.source, refresh: opts.refresh, limit: opts.max });
+  const res = { attempted: 0, enriched: 0, stoppedEarly: false };
+  for (const e of targets) {
+    res.attempted++;
+    const handle = linkedinHandle(e.socials.linkedin || "");
+    if (!handle)
+      continue;
+    let out;
+    try {
+      out = await client.linkedInProfile(handle);
+    } catch (err) {
+      log(`  ${e.slug}: error ${err?.message || err}`);
+      await sleep2(delayMs);
+      continue;
+    }
+    if (out.result.quotaExhausted || out.result.rateLimited) {
+      res.stoppedEarly = true;
+      res.reason = "linkedin connector quota/rate-limited or not authenticated \u2014 resume later";
+      res.attempted--;
+      break;
+    }
+    if (out.profile) {
+      db.upsertExt(e.source, e.sourceId, "linkedin", { ...out.profile });
+      res.enriched++;
+      log(`  [${res.attempted}/${targets.length}] ${e.fullName || e.slug}: linkedin \u2713`);
+    }
+    await sleep2(delayMs);
+  }
+  return res;
+}
+function htmlToText(html) {
+  return (html || "").replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&[a-z#0-9]+;/gi, " ").replace(/\s+/g, " ").trim();
+}
+async function enrichSite(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const fetchFn = opts.fetchFn ?? fetch;
+  const delayMs = opts.delayMs ?? 500;
+  const maxChars = opts.maxChars ?? 1500;
+  const all = db.list({ source: opts.source });
+  const res = { attempted: 0, enriched: 0, stoppedEarly: false };
+  let processed = 0;
+  for (const e of all) {
+    if (opts.max && processed >= opts.max)
+      break;
+    const x = db.getXProfile(e.source, e.sourceId);
+    const url = x?.url || "";
+    if (!url || /t\.co\//.test(url))
+      continue;
+    if (!opts.refresh && db.getExt(e.source, e.sourceId, "site"))
+      continue;
+    processed++;
+    res.attempted++;
+    try {
+      const r = await fetchFn(url, { headers: { "User-Agent": "open-experts (+https://github.com/hasna/experts)" } });
+      if (r.ok) {
+        const text = htmlToText(await r.text()).slice(0, maxChars);
+        db.upsertExt(e.source, e.sourceId, "site", { url, summary: text });
+        res.enriched++;
+        log(`  [${res.attempted}] ${e.fullName || e.slug}: site \u2713`);
+      }
+    } catch {}
+    await sleep2(delayMs);
+  }
+  return res;
+}
+
+// src/contacts.ts
+import { resolveMx } from "dns/promises";
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function normalizeEmail(v) {
+  return v.trim().toLowerCase().replace(/^mailto:/, "");
+}
+function normalizePhone(v) {
+  const cleaned = v.trim().replace(/[^\d+]/g, "");
+  if (cleaned.startsWith("+"))
+    return "+" + cleaned.slice(1).replace(/\D/g, "");
+  return cleaned;
+}
+function validatePhone(v) {
+  const n = normalizePhone(v);
+  const digits = n.replace(/\D/g, "");
+  return digits.length >= 7 && digits.length <= 15 ? "valid" : "invalid";
+}
+async function validateEmail(email, resolver = resolveMx) {
+  const e = normalizeEmail(email);
+  if (!EMAIL_RE.test(e))
+    return "invalid";
+  const domain = e.split("@")[1];
+  try {
+    const mx = await resolver(domain);
+    return mx && mx.length > 0 ? "valid" : "invalid";
+  } catch (err) {
+    const code = err?.code || "";
+    if (code === "ENOTFOUND" || code === "ENODATA" || code === "NXDOMAIN")
+      return "invalid";
+    return "unknown";
+  }
+}
+
+class ExaWebsetsProvider {
+  name = "exa";
+  apiKey;
+  fetchFn;
+  pollMs;
+  maxPollMs;
+  baseUrl;
+  constructor(opts = {}) {
+    this.apiKey = opts.apiKey ?? process.env.EXA_API_KEY ?? "";
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.pollMs = opts.pollMs ?? 3000;
+    this.maxPollMs = opts.maxPollMs ?? 120000;
+    this.baseUrl = (opts.baseUrl ?? "https://api.exa.ai").replace(/\/+$/, "");
+  }
+  headers() {
+    return { "content-type": "application/json", "x-api-key": this.apiKey };
+  }
+  query(e) {
+    const company = e.extra?.company || "";
+    const bits = [e.fullName, e.title, company].filter(Boolean).join(", ");
+    return `Contact information (email and phone) for ${bits || e.fullName || e.slug}`;
+  }
+  async find(e) {
+    if (!this.apiKey)
+      return { contacts: [], quotaExhausted: true };
+    const createRes = await this.fetchFn(`${this.baseUrl}/websets/v0/websets`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        search: { query: this.query(e), count: 3 },
+        enrichments: [
+          { description: "email address of this person", format: "email" },
+          { description: "phone number of this person", format: "phone" }
+        ]
+      })
+    });
+    if (createRes.status === 429)
+      return { contacts: [], rateLimited: true };
+    if (createRes.status === 402 || createRes.status === 403)
+      return { contacts: [], quotaExhausted: true };
+    if (!createRes.ok)
+      return { contacts: [] };
+    const created = await createRes.json();
+    const id = created?.id;
+    if (!id)
+      return { contacts: [] };
+    const deadline = Date.now() + this.maxPollMs;
+    let status = created?.status;
+    while (status !== "idle" && status !== "completed" && Date.now() < deadline) {
+      await sleep3(this.pollMs);
+      const r = await this.fetchFn(`${this.baseUrl}/websets/v0/websets/${id}`, { headers: this.headers() });
+      if (!r.ok)
+        break;
+      status = (await r.json())?.status;
+    }
+    const itemsRes = await this.fetchFn(`${this.baseUrl}/websets/v0/websets/${id}/items`, { headers: this.headers() });
+    if (!itemsRes.ok)
+      return { contacts: [] };
+    const items = await itemsRes.json();
+    return { contacts: extractExaContacts(items) };
+  }
+}
+function extractExaContacts(payload) {
+  const out = [];
+  const seen = new Set;
+  const items = payload?.data ?? payload?.items ?? (Array.isArray(payload) ? payload : []);
+  for (const item of items) {
+    const enrichments = item?.enrichments ?? [];
+    for (const en of enrichments) {
+      const fmt = en?.format;
+      const results = en?.result ?? en?.results ?? (en?.value != null ? [en.value] : []);
+      for (const r of results) {
+        const raw = typeof r === "string" ? r : r?.value ?? r?.text;
+        if (!raw)
+          continue;
+        if (fmt === "email" || /@/.test(raw)) {
+          const v = normalizeEmail(String(raw));
+          if (EMAIL_RE.test(v) && !seen.has("e:" + v)) {
+            seen.add("e:" + v);
+            out.push({ type: "email", value: v, confidence: en?.confidence ?? 0.5 });
+          }
+        } else if (fmt === "phone" || /\+?\d[\d\s().-]{6,}/.test(raw)) {
+          const v = normalizePhone(String(raw));
+          if (v.replace(/\D/g, "").length >= 7 && !seen.has("p:" + v)) {
+            seen.add("p:" + v);
+            out.push({ type: "phone", value: v, confidence: en?.confidence ?? 0.5 });
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
+async function discoverContacts(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const provider = opts.provider ?? new ExaWebsetsProvider;
+  const delayMs = opts.delayMs ?? 500;
+  const targets = db.expertsNeedingContacts({ source: opts.source, refresh: opts.refresh, limit: opts.max });
+  const res = { attempted: 0, withContacts: 0, contacts: 0, stoppedEarly: false };
+  const now = new Date().toISOString();
+  for (let i = 0;i < targets.length; i++) {
+    const e = targets[i];
+    res.attempted++;
+    let found;
+    try {
+      found = await provider.find(e);
+    } catch (err) {
+      log(`  ${e.slug}: error ${err?.message || err}`);
+      await sleep3(delayMs);
+      continue;
+    }
+    if (found.quotaExhausted) {
+      res.stoppedEarly = true;
+      res.reason = `${provider.name} quota/credits exhausted \u2014 top up or wait, then re-run`;
+      res.attempted--;
+      log(`${provider.name} quota exhausted; stopping at ${i}/${targets.length}`);
+      break;
+    }
+    if (found.rateLimited && found.contacts.length === 0) {
+      res.stoppedEarly = true;
+      res.reason = `${provider.name} rate limited \u2014 resume later`;
+      res.attempted--;
+      break;
+    }
+    for (const c of found.contacts) {
+      db.upsertContact({
+        source: e.source,
+        sourceId: e.sourceId,
+        type: c.type,
+        value: c.value,
+        label: c.label ?? "",
+        provider: provider.name,
+        confidence: c.confidence,
+        status: "unverified",
+        verifiedAt: "",
+        createdAt: now
+      });
+    }
+    if (found.contacts.length)
+      res.withContacts++;
+    res.contacts += found.contacts.length;
+    log(`  [${res.attempted}/${targets.length}] ${e.fullName || e.slug}: ${found.contacts.length} contacts`);
+    await sleep3(delayMs);
+  }
+  db.setMeta(`last_contacts:${opts.source ?? "all"}`, now);
+  return res;
+}
+async function verifyContacts(db, opts = {}) {
+  const log = opts.onLog ?? (() => {});
+  const delayMs = opts.delayMs ?? 50;
+  const targets = db.contactsToVerify({ source: opts.source, limit: opts.max });
+  const res = { checked: 0, valid: 0, invalid: 0, unknown: 0 };
+  for (const c of targets) {
+    let status;
+    if (c.type === "email")
+      status = await validateEmail(c.value, opts.resolver);
+    else
+      status = validatePhone(c.value);
+    db.setContactStatus(c.source, c.sourceId, c.type, c.value, status);
+    res.checked++;
+    res[status]++;
+    if (res.checked % 50 === 0)
+      log(`  verified ${res.checked}`);
+    if (delayMs)
+      await sleep3(delayMs);
+  }
+  return res;
+}
+
+// src/sync.ts
+function expertToContactRecord(e, contacts) {
+  const li = e.extra?.company || "";
+  return {
+    name: e.fullName || e.slug,
+    title: e.title,
+    company: li,
+    emails: contacts.filter((c) => c.type === "email").map((c) => ({ value: c.value, status: c.status })),
+    phones: contacts.filter((c) => c.type === "phone").map((c) => ({ value: c.value, status: c.status })),
+    socials: e.socials,
+    url: e.url,
+    source: e.source,
+    sourceId: e.sourceId,
+    tags: e.tags,
+    notes: e.headline || e.bio.slice(0, 200)
+  };
+}
+
+class JsonSink {
+  name = "json";
+  records = [];
+  async push(records) {
+    this.records.push(...records);
+    return { ok: records.length, failed: 0, output: JSON.stringify(records, null, 2) };
+  }
+}
+
+class CliSink {
+  bin;
+  name = "contacts-cli";
+  constructor(bin = "contacts") {
+    this.bin = bin;
+  }
+  async push(records) {
+    let ok = 0;
+    let failed = 0;
+    for (const r of records) {
+      try {
+        const proc = Bun.spawn([this.bin, "upsert", "--json", JSON.stringify(r)], { stdout: "pipe", stderr: "pipe" });
+        const code = await proc.exited;
+        if (code === 0)
+          ok++;
+        else
+          failed++;
+      } catch {
+        failed++;
+      }
+    }
+    return { ok, failed };
+  }
+}
+async function syncContacts(db, idsOrSlugs, opts = {}) {
+  const sink = opts.sink ?? new JsonSink;
+  const records = [];
+  for (const id of idsOrSlugs) {
+    const e = db.get(id, opts.source);
+    if (!e)
+      continue;
+    records.push(expertToContactRecord(e, db.contacts(e.source, e.sourceId)));
+  }
+  const res = await sink.push(records);
+  return { records, ...res };
+}
 
 // src/cli/index.ts
-var VERSION = "0.0.5";
+var VERSION = "0.0.7";
 function openDb() {
   const opts = program.opts();
   return new ExpertsDB(opts.db || defaultDbPath());
 }
+function truncateMid(v, n = 32) {
+  const s = String(v ?? "").replace(/\s+/g, " ").trim();
+  return s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+}
 function requireData(db) {
   if (db.count() === 0) {
     console.error(chalk2.yellow("No experts stored yet. Run ") + chalk2.bold("experts crawl intro") + chalk2.yellow(" first."));
@@ -1305,6 +2791,8 @@ program.command("crawl [source]").description("Fetch experts from a source into
       console.log(`  ${chalk2.dim(t.name.padEnd(20))} ${t.count}`);
   }
   console.log(chalk2.dim(`graph: ${res.graph.nodes} nodes, ${res.graph.edges} edges`));
+  if (res.changes)
+    console.log(chalk2.dim(`changes since last crawl: ${res.changes}`));
   db.close();
 });
 program.command("enrich [source]").description("Enrich experts via X/Twitter: profile, recent tweets, avatar").option("--max <n>", "limit experts processed (resumable)", (v) => parseInt(v, 10)).option("--refresh", "re-enrich experts already done").option("--since-days <n>", "tweet window in days", (v) => parseInt(v, 10), 30).option("--delay <ms>", "min delay between experts", (v) => parseInt(v, 10), 1200).option("--tweet-max <n>", "max tweets fetched per expert", (v) => parseInt(v, 10), 100).option("--no-avatars", "skip downloading profile pictures").option("--no-tweets", "skip fetching tweets").action(async (source, cmdOpts) => {
@@ -1326,6 +2814,7 @@ program.command("enrich [source]").description("Enrich experts via X/Twitter: pr
 `))
   });
   db.rebuildGraph();
+  db.rescore(source);
   console.log(chalk2.green(`\u2713 enriched ${res.enriched}`) + chalk2.dim(` (${res.notFound} not found, ${res.tweets} tweets, ${res.avatars} avatars, ${res.attempted} attempted)`));
   if (res.stoppedEarly)
     console.log(chalk2.yellow(`\u26A0 stopped early: ${res.reason}`));
@@ -1333,14 +2822,93 @@ program.command("enrich [source]").description("Enrich experts via X/Twitter: pr
   console.log(chalk2.dim(`progress: ${after.enriched}/${after.withHandle} enriched`));
   db.close();
 });
-program.command("tweets <idOrSlug>").description("Show an expert's stored recent tweets").option("-s, --source <name>", "disambiguate by source").option("-n, --limit <n>", "max tweets", (v) => parseInt(v, 10), 10).action((idOrSlug, cmdOpts) => {
+program.command("avatars [source]").description("Download + properly name profile pictures for experts missing one").option("--delay <ms>", "delay between downloads", (v) => parseInt(v, 10), 150).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  console.error(chalk2.dim("Backfilling profile pictures from source media\u2026"));
+  const res = await backfillAvatars(db, {
+    source,
+    delayMs: cmdOpts.delay,
+    onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`))
+  });
+  console.log(chalk2.green(`\u2713 ${res.downloaded} avatars downloaded`) + chalk2.dim(` (${res.skipped} already had one or no URL, ${res.failed} failed)`));
+  const total = db.enrichmentStats(source).avatars;
+  console.log(chalk2.dim(`total experts with a named avatar: ${total}`));
+  db.close();
+});
+program.command("enrich-linkedin [source]").description("Enrich experts with LinkedIn headline/company/about (needs linkedin connector auth)").option("--max <n>", "limit experts processed", (v) => parseInt(v, 10)).option("--refresh", "re-enrich").option("--delay <ms>", "delay between experts", (v) => parseInt(v, 10), 500).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const res = await enrichLinkedIn(db, { source, max: cmdOpts.max, refresh: cmdOpts.refresh, delayMs: cmdOpts.delay, onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`)) });
+  console.log(chalk2.green(`\u2713 enriched ${res.enriched}`) + chalk2.dim(` (${res.attempted} attempted)`));
+  if (res.stoppedEarly)
+    console.log(chalk2.yellow(`\u26A0 ${res.reason}`));
+  db.close();
+});
+program.command("enrich-sites [source]").description("Fetch experts' personal sites and store a text summary").option("--max <n>", "limit experts processed", (v) => parseInt(v, 10)).option("--refresh", "re-enrich").option("--delay <ms>", "delay between requests", (v) => parseInt(v, 10), 500).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const res = await enrichSite(db, { source, max: cmdOpts.max, refresh: cmdOpts.refresh, delayMs: cmdOpts.delay, onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`)) });
+  console.log(chalk2.green(`\u2713 enriched ${res.enriched} sites`) + chalk2.dim(` (${res.attempted} attempted)`));
+  db.close();
+});
+program.command("enrich-youtube [source]").description("Fetch + store recent YouTube videos for experts with a YT handle").option("--max <n>", "limit experts processed", (v) => parseInt(v, 10)).option("--refresh", "re-fetch for experts that already have videos").option("--video-max <n>", "videos per expert", (v) => parseInt(v, 10), 10).option("--delay <ms>", "delay between experts", (v) => parseInt(v, 10), 500).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const remaining = db.expertsNeedingVideos({ source, refresh: cmdOpts.refresh }).length;
+  console.error(chalk2.dim(`Fetching YouTube videos \u2014 ${remaining} experts with handles to do`));
+  const res = await enrichYouTube(db, {
+    source,
+    max: cmdOpts.max,
+    refresh: cmdOpts.refresh,
+    videoMax: cmdOpts.videoMax,
+    delayMs: cmdOpts.delay,
+    onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`))
+  });
+  console.log(chalk2.green(`\u2713 ${res.videos} videos for ${res.withVideos} experts`) + chalk2.dim(` (${res.attempted} attempted)`));
+  if (res.stoppedEarly)
+    console.log(chalk2.yellow(`\u26A0 stopped early: ${res.reason}`));
+  db.close();
+});
+program.command("videos <idOrSlug>").description("Show an expert's recent YouTube videos").option("-s, --source <name>", "disambiguate by source").option("-n, --limit <n>", "max videos", (v) => parseInt(v, 10), 10).action((idOrSlug, cmdOpts) => {
+  const db = openDb();
+  const e = db.get(idOrSlug, cmdOpts.source);
+  if (!e) {
+    console.error(chalk2.red(`No expert found for "${idOrSlug}".`));
+    process.exit(1);
+  }
+  const videos = db.recentVideos(e.source, e.sourceId, cmdOpts.limit);
+  if (program.opts().json) {
+    console.log(JSON.stringify(videos, null, 2));
+  } else if (videos.length === 0) {
+    console.log(chalk2.yellow(`No videos for ${e.fullName || e.slug}. Run \`experts enrich-youtube\`.`));
+  } else {
+    console.log(chalk2.bold(`YouTube \u2014 ${e.fullName || e.slug}`));
+    for (const v of videos)
+      console.log(`  ${chalk2.dim((v.publishedAt || "").slice(0, 10))} ${v.title}
+    ${chalk2.dim(v.url)}`);
+  }
+  db.close();
+});
+program.command("tweets <idOrSlug>").description("Show an expert's recent tweets (stored, or --live)").option("-s, --source <name>", "disambiguate by source").option("-n, --limit <n>", "max tweets", (v) => parseInt(v, 10), 10).option("--live", "fetch latest live via the connector (needs X credits)").action(async (idOrSlug, cmdOpts) => {
   const db = openDb();
   const e = db.get(idOrSlug, cmdOpts.source);
   if (!e) {
     console.error(chalk2.red(`No expert found for "${idOrSlug}".`));
     process.exit(1);
   }
-  const tweets = db.recentTweets(e.source, e.sourceId, cmdOpts.limit);
+  let tweets = db.recentTweets(e.source, e.sourceId, cmdOpts.limit);
+  if (cmdOpts.live) {
+    const live = await liveTweets(db, e, { max: cmdOpts.limit });
+    if (live.quotaExhausted)
+      console.error(chalk2.yellow("X API quota exhausted \u2014 showing stored tweets."));
+    else if (live.tweets.length)
+      tweets = live.tweets;
+  }
   if (program.opts().json) {
     console.log(JSON.stringify(tweets, null, 2));
   } else if (tweets.length === 0) {
@@ -1357,14 +2925,121 @@ ${chalk2.dim(date)} ${chalk2.yellow(`\u2665${t.likeCount} \u21BA${t.retweetCount
   }
   db.close();
 });
-program.command("reindex").description("Rebuild the knowledge graph from stored experts (no network)").action(() => {
+program.command("find-contacts [source]").description("Discover email + phone for experts via Exa.ai websets (resumable)").option("--max <n>", "limit experts processed", (v) => parseInt(v, 10)).option("--refresh", "re-discover for experts that already have contacts").option("--delay <ms>", "delay between experts", (v) => parseInt(v, 10), 500).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const remaining = db.expertsNeedingContacts({ source, refresh: cmdOpts.refresh }).length;
+  console.error(chalk2.dim(`Discovering contacts via Exa \u2014 ${remaining} experts to do${cmdOpts.max ? ` (capped ${cmdOpts.max})` : ""}`));
+  const res = await discoverContacts(db, {
+    source,
+    max: cmdOpts.max,
+    refresh: cmdOpts.refresh,
+    delayMs: cmdOpts.delay,
+    onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`))
+  });
+  console.log(chalk2.green(`\u2713 ${res.contacts} contacts for ${res.withContacts} experts`) + chalk2.dim(` (${res.attempted} attempted)`));
+  if (res.stoppedEarly)
+    console.log(chalk2.yellow(`\u26A0 stopped early: ${res.reason}`));
+  console.log(chalk2.dim("Next: `experts verify-contacts` to set working/not status."));
+  db.close();
+});
+program.command("verify-contacts [source]").description("Validate discovered contacts and set working/not status").option("--max <n>", "limit contacts checked", (v) => parseInt(v, 10)).action(async (source, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const res = await verifyContacts(db, {
+    source,
+    max: cmdOpts.max,
+    onLog: (m) => process.stderr.write(chalk2.dim(m + `
+`))
+  });
+  console.log(chalk2.green(`\u2713 verified ${res.checked}`) + chalk2.dim(` (${res.valid} valid, ${res.invalid} invalid, ${res.unknown} unknown)`));
+  db.close();
+});
+program.command("contacts <idOrSlug>").description("Show an expert's discovered contacts with working/not status").option("-s, --source <name>", "disambiguate by source").action((idOrSlug, cmdOpts) => {
+  const db = openDb();
+  const e = db.get(idOrSlug, cmdOpts.source);
+  if (!e) {
+    console.error(chalk2.red(`No expert found for "${idOrSlug}".`));
+    process.exit(1);
+  }
+  const list = db.contacts(e.source, e.sourceId);
+  if (program.opts().json) {
+    console.log(JSON.stringify(list, null, 2));
+  } else if (list.length === 0) {
+    console.log(chalk2.yellow(`No contacts for ${e.fullName || e.slug}. Run \`experts find-contacts\`.`));
+  } else {
+    console.log(chalk2.bold(`Contacts \u2014 ${e.fullName || e.slug}`));
+    for (const c of list) {
+      const mark = c.status === "valid" ? chalk2.green("\u2713 working") : c.status === "invalid" ? chalk2.red("\u2717 not working") : chalk2.dim(c.status);
+      console.log(`  ${c.type.padEnd(5)} ${c.value.padEnd(36)} ${mark}`);
+    }
+  }
+  db.close();
+});
+program.command("reindex").description("Rebuild the knowledge graph + authority scores (no network)").action(() => {
   const db = openDb();
   requireData(db);
   const g = db.rebuildGraph();
-  console.log(chalk2.green(`\u2713 graph rebuilt: ${g.nodes} nodes, ${g.edges} edges`));
+  const n = db.rescore();
+  const p = db.rebuildPersons();
+  console.log(chalk2.green(`\u2713 graph: ${g.nodes} nodes/${g.edges} edges; rescored ${n}; ${p.persons} persons (${p.experts} records)`));
+  db.close();
+});
+program.command("changes").description("What changed between crawls (price/title/bio edits, new experts)").option("-s, --source <name>", "filter by source").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 50).action((cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const rows = db.changes({ source: cmdOpts.source, limit: cmdOpts.limit });
+  if (program.opts().json) {
+    console.log(JSON.stringify(rows, null, 2));
+  } else if (rows.length === 0) {
+    console.log(chalk2.dim("No changes recorded yet (changes are detected on re-crawl)."));
+  } else {
+    for (const c of rows) {
+      const when = (c.detected_at || "").slice(0, 10);
+      if (c.kind === "added") {
+        console.log(`${chalk2.dim(when)} ${chalk2.green("\uFF0B added")}  ${c.new_value} ${chalk2.dim(`[${c.source}:${c.source_id}]`)}`);
+      } else {
+        console.log(`${chalk2.dim(when)} ${chalk2.yellow("~ " + c.field)}  ${chalk2.dim(truncateMid(c.old_value))} \u2192 ${truncateMid(c.new_value)} ${chalk2.dim(`[${c.source}:${c.source_id}]`)}`);
+      }
+    }
+    console.log(chalk2.dim(`
+${rows.length} changes`));
+  }
   db.close();
 });
-program.command("list").description("List experts with filters").option("-s, --source <name>", "filter by source").option("-t, --topic <topic>", "filter by topic/category").option("--verified", "only verified experts").option("--top", "only featured/top experts").option("--min-price <n>", "minimum price", (v) => parseInt(v, 10)).option("--max-price <n>", "maximum price", (v) => parseInt(v, 10)).option("--min-rating <n>", "minimum rating", parseFloat).option("--sort <field>", "rating|price|name|reviews", "rating").option("--asc", "ascending order").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 25).action((cmdOpts) => {
+program.command("persons").description("Identity-resolution overview (canonical persons vs. records)").action(() => {
+  const db = openDb();
+  requireData(db);
+  const s = db.personStats();
+  if (program.opts().json)
+    console.log(JSON.stringify(s, null, 2));
+  else {
+    console.log(chalk2.bold("Identity resolution"));
+    console.log(`  Expert records   ${s.experts}`);
+    console.log(`  Unique persons   ${s.persons}`);
+    console.log(`  Merged (>1 src)  ${s.duplicated}`);
+  }
+  db.close();
+});
+program.command("stale").description("List the experts whose data is oldest (refresh candidates)").option("-s, --source <name>", "filter by source").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 25).action((cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const rows = db.stalest({ source: cmdOpts.source, limit: cmdOpts.limit });
+  if (program.opts().json) {
+    console.log(JSON.stringify(rows, null, 2));
+  } else {
+    const now = Date.now();
+    for (const { expert, lastSeen } of rows) {
+      const days = lastSeen ? Math.floor((now - Date.parse(lastSeen)) / 86400000) : "?";
+      console.log(`${chalk2.dim(String(days).padStart(4) + "d")}  ${formatRow(expert)}`);
+    }
+    console.log(chalk2.dim(`
+${rows.length} stalest experts`));
+  }
+  db.close();
+});
+program.command("list").description("List experts with filters").option("-s, --source <name>", "filter by source").option("-t, --topic <topic>", "filter by topic/category").option("--verified", "only verified experts").option("--top", "only featured/top experts").option("--min-price <n>", "minimum price", (v) => parseInt(v, 10)).option("--max-price <n>", "maximum price", (v) => parseInt(v, 10)).option("--min-rating <n>", "minimum rating", parseFloat).option("--sort <field>", "rating|price|name|reviews|authority", "rating").option("--asc", "ascending order").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 25).action((cmdOpts) => {
   const db = openDb();
   requireData(db);
   const filters = {
@@ -1391,6 +3066,81 @@ ${rows.length} experts`));
   }
   db.close();
 });
+program.command("embed [source]").description("Build the semantic search index (embeddings) for stored experts").action(async (source) => {
+  const db = openDb();
+  requireData(db);
+  const embedder = getEmbedder();
+  console.error(chalk2.dim(`Embedding with ${embedder.id}\u2026`));
+  const n = await db.buildEmbeddings(embedder, {
+    source,
+    onLog: (m) => process.stderr.write(chalk2.dim(`\r${m}`.padEnd(40)))
+  });
+  process.stderr.write(`
+`);
+  console.log(chalk2.green(`\u2713 embedded ${n} experts (${embedder.id})`));
+  db.close();
+});
+program.command("ask <query...>").description("Natural-language semantic search: 'who can help with X'").option("-s, --source <name>", "filter by source").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 15).action(async (query, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  if (db.vectorCount() === 0) {
+    console.error(chalk2.yellow("No semantic index yet. Run ") + chalk2.bold("experts embed") + chalk2.yellow(" first."));
+    process.exit(1);
+  }
+  const embedder = getEmbedder();
+  const [qv] = await embedder.embed([query.join(" ")]);
+  const results = db.semanticSearch(qv, { source: cmdOpts.source, limit: cmdOpts.limit });
+  if (program.opts().json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    const multi = new Set(results.map((r) => r.expert.source)).size > 1;
+    for (const { expert, score } of results) {
+      console.log(chalk2.dim(score.toFixed(3)) + "  " + formatRow(expert, { showSource: multi }));
+    }
+    console.log(chalk2.dim(`
+${results.length} matches for "${query.join(" ")}"`));
+  }
+  db.close();
+});
+program.command("brief <text...>").description("Paste a brief \u2192 ranked, de-duplicated expert shortlist with why each matched").option("-s, --source <name>", "filter by source").option("-n, --limit <n>", "shortlist size", (v) => parseInt(v, 10), 10).action(async (text, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  if (db.vectorCount() === 0) {
+    console.error(chalk2.yellow("No semantic index. Run ") + chalk2.bold("experts embed") + chalk2.yellow(" first."));
+    process.exit(1);
+  }
+  const brief = text.join(" ");
+  const [qv] = await getEmbedder().embed([brief]);
+  const raw = db.semanticSearch(qv, { source: cmdOpts.source, limit: (cmdOpts.limit + 5) * 4 });
+  const seen = new Set;
+  const shortlist = [];
+  for (const r of raw) {
+    const pid = db.personIdOf(r.expert.source, r.expert.sourceId);
+    if (seen.has(pid))
+      continue;
+    seen.add(pid);
+    shortlist.push(r);
+    if (shortlist.length >= cmdOpts.limit)
+      break;
+  }
+  const briefLc = brief.toLowerCase();
+  const annotated = shortlist.map((r) => ({
+    ...r,
+    why: r.expert.tags.filter((t) => briefLc.includes(t.toLowerCase())).slice(0, 4)
+  }));
+  if (program.opts().json) {
+    console.log(JSON.stringify(annotated, null, 2));
+  } else {
+    console.log(chalk2.bold(`Shortlist for: "${brief}"
+`));
+    annotated.forEach((r, i) => {
+      console.log(`${chalk2.cyan(`${i + 1}.`)} ${formatRow(r.expert)}`);
+      const why = r.why.length ? r.why.join(", ") : "semantic match";
+      console.log(`     ${chalk2.dim("why:")} ${why}  ${chalk2.dim(`(${r.score.toFixed(3)})`)}`);
+    });
+  }
+  db.close();
+});
 program.command("search <query...>").description("Full-text search across name, title and bio").option("-s, --source <name>", "filter by source").option("-n, --limit <n>", "max rows", (v) => parseInt(v, 10), 25).action((query, cmdOpts) => {
   const db = openDb();
   requireData(db);
@@ -1473,10 +3223,13 @@ program.command("show <idOrSlug>").description("Show full detail for one expert"
   }
   const xProfile = db.getXProfile(e.source, e.sourceId);
   const tweets = db.recentTweets(e.source, e.sourceId, 10);
+  const contacts = db.contacts(e.source, e.sourceId);
+  const videos = db.recentVideos(e.source, e.sourceId, 5);
+  const ext = db.allExt(e.source, e.sourceId);
   if (program.opts().json) {
-    console.log(JSON.stringify({ ...e, xProfile, tweets }, null, 2));
+    console.log(JSON.stringify({ ...e, xProfile, tweets, contacts, videos, ext }, null, 2));
   } else {
-    console.log(formatDetail(e, { xProfile, tweets }));
+    console.log(formatDetail(e, { xProfile, tweets, contacts, videos, ext }));
   }
   db.close();
 });
@@ -1543,6 +3296,21 @@ program.command("export").description("Export experts as JSON or CSV").option("-
   }
   db.close();
 });
+program.command("sync-contacts <idsOrSlugs...>").description("Export experts + their contacts to the contacts system (JSON, or --via-cli)").option("-s, --source <name>", "disambiguate by source").option("--via-cli", "push via the `contacts` CLI instead of emitting JSON").option("-o, --out <file>", "write JSON to a file").action(async (ids, cmdOpts) => {
+  const db = openDb();
+  requireData(db);
+  const sink = cmdOpts.viaCli ? new CliSink : new JsonSink;
+  const res = await syncContacts(db, ids, { source: cmdOpts.source, sink });
+  if (cmdOpts.viaCli) {
+    console.log(chalk2.green(`\u2713 pushed ${res.ok} contacts`) + chalk2.dim(` (${res.failed} failed)`));
+  } else if (cmdOpts.out) {
+    await Bun.write(cmdOpts.out, res.output ?? "[]");
+    console.error(chalk2.green(`\u2713 wrote ${res.records.length} contact records to ${cmdOpts.out}`));
+  } else {
+    console.log(res.output ?? "[]");
+  }
+  db.close();
+});
 program.command("sources").description("List available marketplace sources").action(() => {
   const db = openDb();
   const inStore = new Map(db.sourcesInStore().map((r) => [r.source, r.count]));