@hasna/contacts 0.4.2 → 0.5.0

package/dist/cli/index.js

@@ -2358,6 +2358,21 @@ var init_database = __esm(() => {
 
   CREATE INDEX IF NOT EXISTS idx_company_relationships_contact ON company_relationships(contact_id);
   CREATE INDEX IF NOT EXISTS idx_company_relationships_company ON company_relationships(company_id);
+  `,
+    `
+  ALTER TABLE groups ADD COLUMN project_id TEXT;
+
+  CREATE TABLE IF NOT EXISTS contact_projects (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    project_id TEXT NOT NULL,
+    PRIMARY KEY (contact_id, project_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_contact_projects_project ON contact_projects(project_id);
+  CREATE INDEX IF NOT EXISTS idx_contact_projects_contact ON contact_projects(contact_id);
+
+  INSERT OR IGNORE INTO contact_projects (contact_id, project_id)
+  SELECT id, project_id FROM contacts WHERE project_id IS NOT NULL;
   `,
     `
   CREATE TABLE IF NOT EXISTS contact_notes (
@@ -2481,6 +2496,142 @@ var init_database = __esm(() => {
     deal_id TEXT REFERENCES deals(id) ON DELETE SET NULL,
     created_at TEXT NOT NULL DEFAULT (datetime('now'))
   );
+  `,
+    `
+  -- CON-00069: temporal field history
+  CREATE TABLE IF NOT EXISTS contact_field_history (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    field_name TEXT NOT NULL,
+    old_value TEXT,
+    new_value TEXT,
+    valid_from TEXT NOT NULL DEFAULT (datetime('now')),
+    source TEXT,
+    confidence TEXT NOT NULL DEFAULT 'imported' CHECK(confidence IN ('verified','inferred','imported','stale')),
+    created_by TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  -- CON-00070: job history
+  CREATE TABLE IF NOT EXISTS job_history (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    company_name TEXT NOT NULL,
+    title TEXT,
+    start_date TEXT,
+    end_date TEXT,
+    is_current INTEGER NOT NULL DEFAULT 0,
+    inferred INTEGER NOT NULL DEFAULT 0,
+    source TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  -- CON-00071: learnings
+  CREATE TABLE IF NOT EXISTS contact_learnings (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'fact' CHECK(type IN ('preference','fact','inference','warning','signal')),
+    confidence INTEGER NOT NULL DEFAULT 70 CHECK(confidence BETWEEN 0 AND 100),
+    importance INTEGER NOT NULL DEFAULT 5 CHECK(importance BETWEEN 1 AND 10),
+    learned_by TEXT,
+    session_id TEXT,
+    visibility TEXT NOT NULL DEFAULT 'shared' CHECK(visibility IN ('private','shared','human')),
+    tags TEXT NOT NULL DEFAULT '[]',
+    confirmed_count INTEGER NOT NULL DEFAULT 0,
+    contradicts_id TEXT REFERENCES contact_learnings(id) ON DELETE SET NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  -- CON-00072: coordination
+  CREATE TABLE IF NOT EXISTS contact_locks (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL UNIQUE REFERENCES contacts(id) ON DELETE CASCADE,
+    agent_name TEXT NOT NULL,
+    reason TEXT,
+    acquired_at TEXT NOT NULL DEFAULT (datetime('now')),
+    expires_at TEXT NOT NULL,
+    session_id TEXT
+  );
+  CREATE TABLE IF NOT EXISTS contact_agent_activity (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    agent_name TEXT NOT NULL,
+    action TEXT NOT NULL,
+    details TEXT,
+    session_id TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  -- CON-00073: relationship graph extra columns
+  ALTER TABLE contact_relationships ADD COLUMN strength_score INTEGER NOT NULL DEFAULT 50;
+  ALTER TABLE contact_relationships ADD COLUMN interaction_count INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE contact_relationships ADD COLUMN last_interaction TEXT;
+  ALTER TABLE contact_relationships ADD COLUMN relationship_status TEXT NOT NULL DEFAULT 'stable' CHECK(relationship_status IN ('warming','stable','cooling','ghost'));
+
+  -- CON-00074: identity resolution
+  CREATE TABLE IF NOT EXISTS contact_identities (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    system TEXT NOT NULL,
+    external_id TEXT NOT NULL,
+    external_url TEXT,
+    confidence TEXT NOT NULL DEFAULT 'inferred' CHECK(confidence IN ('verified','inferred')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(system, external_id)
+  );
+  ALTER TABLE contacts ADD COLUMN canonical_id TEXT;
+
+  -- CON-00076: relationship signals
+  ALTER TABLE contacts ADD COLUMN relationship_health INTEGER NOT NULL DEFAULT 50;
+  ALTER TABLE contacts ADD COLUMN avg_response_hours REAL;
+  ALTER TABLE contacts ADD COLUMN preferred_channel TEXT;
+  ALTER TABLE contacts ADD COLUMN engagement_status TEXT NOT NULL DEFAULT 'new' CHECK(engagement_status IN ('warming','stable','cooling','ghost','new'));
+  ALTER TABLE contacts ADD COLUMN interaction_count_30d INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE contacts ADD COLUMN interaction_count_90d INTEGER NOT NULL DEFAULT 0;
+
+  -- CON-00079: freshness scoring
+  CREATE TABLE IF NOT EXISTS contact_field_confidence (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    field_name TEXT NOT NULL,
+    confidence TEXT NOT NULL DEFAULT 'imported' CHECK(confidence IN ('verified','inferred','imported','stale')),
+    source TEXT,
+    last_verified_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(contact_id, field_name)
+  );
+
+  -- CON-00080: org chart
+  CREATE TABLE IF NOT EXISTS org_chart_edges (
+    id TEXT PRIMARY KEY,
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    contact_a_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    contact_b_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    edge_type TEXT NOT NULL CHECK(edge_type IN ('reports_to','manages','collaborates_with','peer')),
+    inferred INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(company_id, contact_a_id, contact_b_id, edge_type)
+  );
+  CREATE TABLE IF NOT EXISTS deal_contact_roles (
+    id TEXT PRIMARY KEY,
+    deal_id TEXT NOT NULL REFERENCES deals(id) ON DELETE CASCADE,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    account_role TEXT NOT NULL CHECK(account_role IN ('economic_buyer','technical_evaluator','champion','blocker','influencer','user','sponsor','other')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(deal_id, contact_id)
+  );
+
+  -- CON-00075: embeddings
+  CREATE TABLE IF NOT EXISTS contact_embeddings (
+    contact_id TEXT PRIMARY KEY REFERENCES contacts(id) ON DELETE CASCADE,
+    embedding TEXT NOT NULL,
+    model TEXT NOT NULL DEFAULT 'tfidf',
+    embedded_text TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
   `
   ];
 });
@@ -2499,14 +2650,20 @@ var init_activity = __esm(() => {
 var exports_contacts = {};
 __export(exports_contacts, {
   updateContact: () => updateContact,
+  unlinkContactFromProject: () => unlinkContactFromProject,
   unarchiveContact: () => unarchiveContact,
+  setContactProjects: () => setContactProjects,
   searchContacts: () => searchContacts,
   mergeContacts: () => mergeContacts,
   listRecentContacts: () => listRecentContacts,
   listContacts: () => listContacts,
+  listContactIdsByProject: () => listContactIdsByProject,
   listColdContacts: () => listColdContacts,
+  linkContactToProject: () => linkContactToProject,
+  getContactProjectIds: () => getContactProjectIds,
   getContactByEmail: () => getContactByEmail,
   getContact: () => getContact,
+  findOrCreateContact: () => findOrCreateContact,
   deleteContact: () => deleteContact,
   createContact: () => createContact,
   autoLinkContactToCompany: () => autoLinkContactToCompany,
@@ -3036,6 +3193,25 @@ function listColdContacts(days, db) {
      LIMIT 100`).all(`-${days}`);
   return rows.map((row) => loadContactDetails(d, rowToContact(row)));
 }
+async function findOrCreateContact(input, db) {
+  const d = db || getDatabase();
+  const emailAddresses = (input.emails ?? []).map((e) => e.address);
+  for (const addr of emailAddresses) {
+    const emailRow = d.query(`SELECT contact_id FROM emails WHERE LOWER(address) = LOWER(?) AND contact_id IS NOT NULL LIMIT 1`).get(addr);
+    if (emailRow) {
+      return { contact: getContact(emailRow.contact_id, d), created: false };
+    }
+  }
+  const nameQuery = input.display_name ?? (input.first_name || input.last_name ? `${input.first_name ?? ""} ${input.last_name ?? ""}`.trim() : null);
+  if (nameQuery) {
+    const results = searchContacts(nameQuery, d);
+    if (results.length > 0 && results[0]) {
+      return { contact: results[0], created: false };
+    }
+  }
+  const contact = createContact(input, d);
+  return { contact, created: true };
+}
 function autoLinkContactToCompany(contactId, db) {
   const d = db || getDatabase();
   const row = d.query(`SELECT * FROM contacts WHERE id = ?`).get(contactId);
@@ -3055,6 +3231,31 @@ function autoLinkContactToCompany(contactId, db) {
   const updated = d.query(`SELECT * FROM contacts WHERE id = ?`).get(contactId);
   return loadContactDetails(d, rowToContact(updated));
 }
+function linkContactToProject(contactId, projectId, db) {
+  const d = db || getDatabase();
+  d.run(`INSERT OR IGNORE INTO contact_projects (contact_id, project_id) VALUES (?, ?)`, [contactId, projectId]);
+}
+function unlinkContactFromProject(contactId, projectId, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM contact_projects WHERE contact_id = ? AND project_id = ?`, [contactId, projectId]);
+}
+function getContactProjectIds(contactId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT project_id FROM contact_projects WHERE contact_id = ?`).all(contactId);
+  return rows.map((r) => r.project_id);
+}
+function listContactIdsByProject(projectId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT contact_id FROM contact_projects WHERE project_id = ?`).all(projectId);
+  return rows.map((r) => r.contact_id);
+}
+function setContactProjects(contactId, projectIds, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM contact_projects WHERE contact_id = ?`, [contactId]);
+  for (const pid of projectIds) {
+    d.run(`INSERT OR IGNORE INTO contact_projects (contact_id, project_id) VALUES (?, ?)`, [contactId, pid]);
+  }
+}
 var init_contacts = __esm(() => {
   init_types();
   init_database();
@@ -3291,6 +3492,61 @@ var init_companies = __esm(() => {
 });
 
 // src/db/relationships.ts
+var exports_relationships = {};
+__export(exports_relationships, {
+  listRelationships: () => listRelationships,
+  listCompanyRelationships: () => listCompanyRelationships,
+  getRelationship: () => getRelationship,
+  getEntityTeam: () => getEntityTeam,
+  deleteRelationship: () => deleteRelationship,
+  deleteCompanyRelationship: () => deleteCompanyRelationship,
+  createRelationship: () => createRelationship,
+  createCompanyRelationship: () => createCompanyRelationship
+});
+function rowToRelationship(row) {
+  return {
+    ...row,
+    relationship_type: row.relationship_type
+  };
+}
+function createRelationship(input, db) {
+  const d = db || getDatabase();
+  const a = d.query(`SELECT id FROM contacts WHERE id = ?`).get(input.contact_a_id);
+  if (!a)
+    throw new ContactNotFoundError(input.contact_a_id);
+  const b = d.query(`SELECT id FROM contacts WHERE id = ?`).get(input.contact_b_id);
+  if (!b)
+    throw new ContactNotFoundError(input.contact_b_id);
+  const id = uuid();
+  d.run(`INSERT INTO contact_relationships (id, contact_a_id, contact_b_id, relationship_type, notes) VALUES (?, ?, ?, ?, ?)`, [id, input.contact_a_id, input.contact_b_id, input.relationship_type, input.notes ?? null]);
+  return rowToRelationship(d.query(`SELECT * FROM contact_relationships WHERE id = ?`).get(id));
+}
+function listRelationships(opts = {}, db) {
+  const d = db || getDatabase();
+  const { contact_id, relationship_type } = opts;
+  const conditions = [];
+  const params = [];
+  if (contact_id) {
+    conditions.push("(contact_a_id = ? OR contact_b_id = ?)");
+    params.push(contact_id, contact_id);
+  }
+  if (relationship_type) {
+    conditions.push("relationship_type = ?");
+    params.push(relationship_type);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM contact_relationships ${where} ORDER BY created_at DESC`).all(...params);
+  return rows.map(rowToRelationship);
+}
+function getRelationship(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM contact_relationships WHERE id = ?`).get(id);
+  return row ? rowToRelationship(row) : null;
+}
+function deleteRelationship(id, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM contact_relationships WHERE id = ?`, [id]);
+}
 function rowToCompanyRelationship(row) {
   return {
     ...row,
@@ -3343,6 +3599,25 @@ function listCompanyRelationships(opts = {}, db) {
   const rows = d.query(`SELECT * FROM company_relationships ${where} ORDER BY created_at DESC`).all(...params);
   return rows.map(rowToCompanyRelationship);
 }
+function deleteCompanyRelationship(id, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM company_relationships WHERE id = ?`, [id]);
+}
+function getEntityTeam(companyId, db) {
+  const d = db || getDatabase();
+  const rows = d.query(`SELECT id, contact_id, relationship_type, is_primary, status, start_date, end_date, notes
+     FROM company_relationships WHERE company_id = ? ORDER BY is_primary DESC, created_at ASC`).all(companyId);
+  return rows.map((r) => ({
+    contact_id: r.contact_id,
+    relationship_id: r.id,
+    relationship_type: r.relationship_type,
+    is_primary: !!r.is_primary,
+    status: r.status,
+    start_date: r.start_date,
+    end_date: r.end_date,
+    notes: r.notes
+  }));
+}
 var init_relationships = __esm(() => {
   init_types();
   init_database();
@@ -4913,6 +5188,590 @@ var init_events = __esm(() => {
   init_database();
 });
 
+// src/db/field-history.ts
+var exports_field_history = {};
+__export(exports_field_history, {
+  recordFieldChange: () => recordFieldChange,
+  getFieldHistory: () => getFieldHistory,
+  getContactAt: () => getContactAt
+});
+function recordFieldChange(contactId, fieldName, oldValue, newValue, source, createdBy, db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`INSERT INTO contact_field_history(id,contact_id,field_name,old_value,new_value,valid_from,source,created_by,created_at) VALUES(?,?,?,?,?,?,?,?,?)`).run(uuid(), contactId, fieldName, oldValue != null ? String(oldValue) : null, newValue != null ? String(newValue) : null, now(), source || null, createdBy || null, now());
+}
+function getFieldHistory(contactId, fieldName, db) {
+  const _db2 = db || getDatabase();
+  if (fieldName) {
+    return _db2.query(`SELECT * FROM contact_field_history WHERE contact_id=? AND field_name=? ORDER BY valid_from DESC`).all(contactId, fieldName);
+  }
+  return _db2.query(`SELECT * FROM contact_field_history WHERE contact_id=? ORDER BY valid_from DESC`).all(contactId);
+}
+function getContactAt(contactId, timestamp, db) {
+  const _db2 = db || getDatabase();
+  const rows = _db2.query(`SELECT field_name, new_value FROM contact_field_history WHERE contact_id=? AND valid_from<=? ORDER BY valid_from ASC`).all(contactId, timestamp);
+  const result = {};
+  for (const r of rows) {
+    if (r.new_value != null)
+      result[r.field_name] = r.new_value;
+  }
+  return result;
+}
+var init_field_history = __esm(() => {
+  init_database();
+});
+
+// src/db/learnings.ts
+var exports_learnings = {};
+__export(exports_learnings, {
+  searchLearnings: () => searchLearnings,
+  saveLearning: () => saveLearning,
+  getLearnings: () => getLearnings,
+  deleteLearning: () => deleteLearning,
+  decayLearnings: () => decayLearnings,
+  confirmLearning: () => confirmLearning
+});
+function rowToLearning(r) {
+  return { ...r, tags: JSON.parse(r["tags"] || "[]") };
+}
+function saveLearning(contactId, input, db) {
+  const _db2 = db || getDatabase();
+  const id = uuid();
+  _db2.query(`INSERT INTO contact_learnings(id,contact_id,content,type,confidence,importance,learned_by,session_id,visibility,tags,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)`).run(id, contactId, input.content, input.type || "fact", input.confidence ?? 70, input.importance ?? 5, input.learned_by || null, input.session_id || null, input.visibility || "shared", JSON.stringify(input.tags || []), now(), now());
+  return rowToLearning(_db2.query(`SELECT * FROM contact_learnings WHERE id=?`).get(id));
+}
+function getLearnings(contactId, opts = {}, db) {
+  const _db2 = db || getDatabase();
+  let sql = `SELECT * FROM contact_learnings WHERE contact_id=?`;
+  const params = [contactId];
+  if (opts.type) {
+    sql += ` AND type=?`;
+    params.push(opts.type);
+  }
+  if (opts.min_importance) {
+    sql += ` AND importance>=?`;
+    params.push(opts.min_importance);
+  }
+  if (opts.visibility) {
+    sql += ` AND visibility=?`;
+    params.push(opts.visibility);
+  }
+  sql += ` ORDER BY importance DESC, confidence DESC`;
+  return _db2.query(sql).all(...params).map(rowToLearning);
+}
+function searchLearnings(query, opts = {}, db) {
+  const _db2 = db || getDatabase();
+  let sql = `SELECT * FROM contact_learnings WHERE content LIKE ?`;
+  const params = [`%${query}%`];
+  if (opts.type) {
+    sql += ` AND type=?`;
+    params.push(opts.type);
+  }
+  if (opts.contact_id) {
+    sql += ` AND contact_id=?`;
+    params.push(opts.contact_id);
+  }
+  sql += ` ORDER BY importance DESC, confidence DESC LIMIT 50`;
+  return _db2.query(sql).all(...params).map(rowToLearning);
+}
+function confirmLearning(learningId, _agentName, db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`UPDATE contact_learnings SET confirmed_count=confirmed_count+1, confidence=MIN(100,confidence+10), updated_at=? WHERE id=?`).run(now(), learningId);
+}
+function decayLearnings(db) {
+  const _db2 = db || getDatabase();
+  const cutoff = new Date(Date.now() - 30 * 86400000).toISOString();
+  const result = _db2.query(`UPDATE contact_learnings SET confidence=MAX(10,confidence-5), updated_at=? WHERE confirmed_count=0 AND created_at<? AND confidence>10`).run(now(), cutoff);
+  return result.changes || 0;
+}
+function deleteLearning(learningId, db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`DELETE FROM contact_learnings WHERE id=?`).run(learningId);
+}
+var init_learnings = __esm(() => {
+  init_database();
+});
+
+// src/db/graph.ts
+var exports_graph = {};
+__export(exports_graph, {
+  findWarmPath: () => findWarmPath,
+  findConnectionsAtCompany: () => findConnectionsAtCompany,
+  detectCoolingRelationships: () => detectCoolingRelationships,
+  computeRelationshipStrength: () => computeRelationshipStrength
+});
+function computeRelationshipStrength(contactId, db) {
+  const _db2 = db || getDatabase();
+  const contact = _db2.query(`SELECT last_contacted_at, interaction_count_30d, interaction_count_90d FROM contacts WHERE id=?`).get(contactId);
+  if (!contact)
+    return 0;
+  let score = 50;
+  if (contact.last_contacted_at) {
+    const days = Math.floor((Date.now() - new Date(contact.last_contacted_at).getTime()) / 86400000);
+    score += days < 7 ? 30 : days < 30 ? 20 : days < 90 ? 5 : -20;
+  } else {
+    score -= 20;
+  }
+  score += Math.min(20, (contact.interaction_count_30d || 0) * 4);
+  return Math.max(0, Math.min(100, score));
+}
+function findWarmPath(fromContactId, toContactId, db) {
+  const _db2 = db || getDatabase();
+  const visited = new Set([fromContactId]);
+  const queue = [{ id: fromContactId, path: [] }];
+  while (queue.length) {
+    const item = queue.shift();
+    const { id, path } = item;
+    if (id === toContactId)
+      return path;
+    if (path.length >= 4)
+      continue;
+    const neighbors = _db2.query(`SELECT cr.*, c.display_name FROM contact_relationships cr JOIN contacts c ON (CASE WHEN cr.contact_a_id=? THEN cr.contact_b_id ELSE cr.contact_a_id END)=c.id WHERE (cr.contact_a_id=? OR cr.contact_b_id=?) LIMIT 20`).all(id, id, id);
+    for (const n of neighbors) {
+      const nextId = n.contact_a_id === id ? n.contact_b_id : n.contact_a_id;
+      if (visited.has(nextId))
+        continue;
+      visited.add(nextId);
+      queue.push({
+        id: nextId,
+        path: [
+          ...path,
+          { contact_id: nextId, display_name: n.display_name, strength: n.strength_score || 50 }
+        ]
+      });
+    }
+  }
+  return [];
+}
+function findConnectionsAtCompany(companyId, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT c.id as contact_id, c.display_name, c.job_title, c.relationship_health as strength FROM contacts c WHERE c.company_id=? AND c.archived=0 ORDER BY c.relationship_health DESC`).all(companyId);
+}
+function detectCoolingRelationships(db) {
+  const _db2 = db || getDatabase();
+  const cutoff = new Date(Date.now() - 45 * 86400000).toISOString();
+  return _db2.query(`SELECT id as contact_id, display_name, CAST((julianday('now') - julianday(last_contacted_at)) AS INTEGER) as days_since FROM contacts WHERE last_contacted_at IS NOT NULL AND last_contacted_at < ? AND engagement_status != 'ghost' AND archived=0 ORDER BY last_contacted_at ASC LIMIT 50`).all(cutoff);
+}
+var init_graph = __esm(() => {
+  init_database();
+});
+
+// src/db/signals.ts
+var exports_signals = {};
+__export(exports_signals, {
+  recomputeAllSignals: () => recomputeAllSignals,
+  getWarmingContacts: () => getWarmingContacts,
+  getRelationshipSignals: () => getRelationshipSignals,
+  getGhostContacts: () => getGhostContacts
+});
+function getRelationshipSignals(contactId, db) {
+  const _db2 = db || getDatabase();
+  const row = _db2.query(`SELECT id as contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE id=?`).get(contactId);
+  if (!row)
+    return [];
+  const daysSince = row.last_contacted_at ? Math.floor((Date.now() - new Date(row.last_contacted_at).getTime()) / 86400000) : null;
+  const signals = [];
+  const cnt = row.interaction_count_30d || 0;
+  const health = row.relationship_health ?? 50;
+  if (daysSince === null || daysSince > 180) {
+    signals.push({ ...row, signal_type: "ghost", days_since_contact: daysSince, reason: "No contact in 180+ days or never contacted" });
+  } else if (daysSince > 60 && cnt === 0) {
+    signals.push({ ...row, signal_type: "cooling", days_since_contact: daysSince, reason: `No contact in ${daysSince} days, no recent interactions` });
+  } else if (cnt > 3 && health > 70) {
+    signals.push({ ...row, signal_type: "warming", days_since_contact: daysSince, reason: `${cnt} interactions in last 30 days, health score ${health}` });
+  } else {
+    signals.push({ ...row, signal_type: "healthy", days_since_contact: daysSince, reason: `Last contact ${daysSince}d ago, ${cnt} interactions in 30d` });
+  }
+  return signals;
+}
+function getGhostContacts(db) {
+  const _db2 = db || getDatabase();
+  const rows = _db2.query(`SELECT id as contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE (last_contacted_at IS NULL OR julianday('now') - julianday(last_contacted_at) > 180) AND archived=0 ORDER BY last_contacted_at ASC LIMIT 50`).all();
+  return rows.map((r) => ({
+    ...r,
+    signal_type: "ghost",
+    days_since_contact: r.last_contacted_at ? Math.floor((Date.now() - new Date(r.last_contacted_at).getTime()) / 86400000) : null,
+    reason: "No contact in 180+ days or never contacted"
+  }));
+}
+function getWarmingContacts(db) {
+  const _db2 = db || getDatabase();
+  const rows = _db2.query(`SELECT id as contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE interaction_count_30d > 2 AND relationship_health > 60 AND archived=0 ORDER BY relationship_health DESC LIMIT 50`).all();
+  return rows.map((r) => ({
+    ...r,
+    signal_type: "warming",
+    days_since_contact: r.last_contacted_at ? Math.floor((Date.now() - new Date(r.last_contacted_at).getTime()) / 86400000) : null,
+    reason: `${r.interaction_count_30d} interactions in last 30 days`
+  }));
+}
+function recomputeAllSignals(db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`
+    UPDATE contacts SET
+      engagement_status = CASE
+        WHEN interaction_count_30d > 3 THEN 'warm'
+        WHEN last_contacted_at IS NULL OR julianday('now') - julianday(last_contacted_at) > 180 THEN 'ghost'
+        WHEN julianday('now') - julianday(last_contacted_at) > 60 THEN 'cooling'
+        ELSE 'active'
+      END,
+      updated_at = datetime('now')
+    WHERE archived = 0
+  `).run();
+  const result = _db2.query(`SELECT changes() as n`).get();
+  return { updated: result?.n ?? 0 };
+}
+var init_signals = __esm(() => {
+  init_database();
+});
+
+// src/db/identity.ts
+var exports_identity = {};
+__export(exports_identity, {
+  resolveIdentity: () => resolveIdentity,
+  resolveByPartial: () => resolveByPartial,
+  getIdentities: () => getIdentities,
+  addIdentity: () => addIdentity
+});
+function addIdentity(contactId, system, externalId, externalUrl, confidence = "inferred", db) {
+  const _db2 = db || getDatabase();
+  const id = uuid();
+  _db2.query(`INSERT OR REPLACE INTO contact_identities(id,contact_id,system,external_id,external_url,confidence,created_at) VALUES(?,?,?,?,?,?,?)`).run(id, contactId, system, externalId, externalUrl || null, confidence, now());
+  return _db2.query(`SELECT * FROM contact_identities WHERE id=?`).get(id);
+}
+function resolveIdentity(system, externalId, db) {
+  const _db2 = db || getDatabase();
+  const row = _db2.query(`SELECT c.id, c.display_name FROM contacts c JOIN contact_identities ci ON c.id=ci.contact_id WHERE ci.system=? AND ci.external_id=?`).get(system, externalId);
+  return row || null;
+}
+function resolveByPartial(partial, db) {
+  const _db2 = db || getDatabase();
+  const matches = new Map;
+  const addMatch = (id, name, title, score, reason) => {
+    const existing = matches.get(id);
+    if (existing) {
+      existing.confidence_score = Math.min(100, existing.confidence_score + score);
+      existing.match_reasons.push(reason);
+    } else {
+      matches.set(id, {
+        contact: { id, display_name: name, job_title: title },
+        confidence_score: score,
+        match_reasons: [reason]
+      });
+    }
+  };
+  if (partial.email) {
+    const rows = _db2.query(`SELECT c.id, c.display_name, c.job_title FROM contacts c JOIN emails e ON c.id=e.contact_id WHERE LOWER(e.address)=LOWER(?)`).all(partial.email);
+    rows.forEach((r) => addMatch(r.id, r.display_name, r.job_title, 90, `email match: ${partial.email}`));
+  }
+  if (partial.linkedin_url) {
+    const rows = _db2.query(`SELECT c.id, c.display_name, c.job_title FROM contacts c JOIN social_profiles sp ON c.id=sp.contact_id WHERE sp.platform='linkedin' AND sp.url LIKE ?`).all(`%${partial.linkedin_url.split("/").pop()}%`);
+    rows.forEach((r) => addMatch(r.id, r.display_name, r.job_title, 85, `linkedin match`));
+  }
+  if (partial.name) {
+    const rows = _db2.query(`SELECT id, display_name, job_title FROM contacts WHERE display_name LIKE ? AND archived=0 LIMIT 10`).all(`%${partial.name}%`);
+    rows.forEach((r) => addMatch(r.id, r.display_name, r.job_title, 40, `name match: ${partial.name}`));
+  }
+  return Array.from(matches.values()).sort((a, b) => b.confidence_score - a.confidence_score);
+}
+function getIdentities(contactId, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT * FROM contact_identities WHERE contact_id=? ORDER BY created_at DESC`).all(contactId);
+}
+var init_identity = __esm(() => {
+  init_database();
+});
+
+// src/lib/embeddings.ts
+var exports_embeddings = {};
+__export(exports_embeddings, {
+  semanticSearch: () => semanticSearch,
+  embedContact: () => embedContact,
+  embedAllContacts: () => embedAllContacts,
+  buildContactEmbeddingText: () => buildContactEmbeddingText
+});
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
+}
+function buildTfIdf(tokens) {
+  const freq = new Map;
+  for (const t of tokens)
+    freq.set(t, (freq.get(t) || 0) + 1);
+  const max = Math.max(...freq.values(), 1);
+  const result = new Map;
+  freq.forEach((v, k) => result.set(k, v / max));
+  return result;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  a.forEach((v, k) => {
+    if (b.has(k))
+      dot += v * b.get(k);
+    normA += v * v;
+  });
+  b.forEach((v) => normB += v * v);
+  return normA && normB ? dot / (Math.sqrt(normA) * Math.sqrt(normB)) : 0;
+}
+function buildContactEmbeddingText(contact) {
+  const tags = contact.tags ?? [];
+  const socialProfiles = contact.social_profiles ?? [];
+  const company = contact.company;
+  const parts = [
+    contact.display_name,
+    contact.job_title,
+    contact.notes,
+    company?.name,
+    company?.industry,
+    ...tags.map((t) => t.name),
+    ...socialProfiles.map((s) => s.platform)
+  ].filter(Boolean);
+  return parts.join(" ");
+}
+async function embedContact(contactId, db) {
+  const { getContact: getContact2 } = await Promise.resolve().then(() => (init_contacts(), exports_contacts));
+  const _db2 = db || getDatabase();
+  const contact = getContact2(contactId, _db2);
+  const text = buildContactEmbeddingText(contact);
+  const tokens = tokenize(text);
+  const tfidf = buildTfIdf(tokens);
+  const embedding = JSON.stringify(Array.from(tfidf.entries()).sort((a, b) => b[1] - a[1]).slice(0, 100));
+  _db2.query(`INSERT OR REPLACE INTO contact_embeddings(contact_id, embedding, model, embedded_text, created_at, updated_at) VALUES(?,?,'tfidf',?,?,?)`).run(contactId, embedding, text.slice(0, 500), now(), now());
+}
+async function embedAllContacts(db) {
+  const _db2 = db || getDatabase();
+  const contacts = _db2.query(`SELECT id FROM contacts WHERE archived=0`).all();
+  for (const c of contacts) {
+    try {
+      await embedContact(c.id, _db2);
+    } catch {}
+  }
+  return contacts.length;
+}
+function semanticSearch(query, limit = 10, db) {
+  const _db2 = db || getDatabase();
+  const queryTokens = buildTfIdf(tokenize(query));
+  let embeddings = [];
+  try {
+    embeddings = _db2.query(`SELECT contact_id, embedding FROM contact_embeddings`).all();
+  } catch {
+    return [];
+  }
+  const results = embeddings.map((e) => {
+    try {
+      const emb = new Map(JSON.parse(e.embedding));
+      return { contact_id: e.contact_id, score: cosineSimilarity(queryTokens, emb) };
+    } catch {
+      return { contact_id: e.contact_id, score: 0 };
+    }
+  }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+  return results;
+}
+var init_embeddings = __esm(() => {
+  init_database();
+});
+
+// src/db/freshness.ts
+var exports_freshness = {};
+__export(exports_freshness, {
+  markFieldVerified: () => markFieldVerified,
+  getStaleContacts: () => getStaleContacts,
+  getFreshnessScore: () => getFreshnessScore
+});
+function getFreshnessScore(contactId, db) {
+  const _db2 = db || getDatabase();
+  const contact = _db2.query(`SELECT * FROM contacts WHERE id=?`).get(contactId);
+  if (!contact)
+    throw new Error(`Contact not found: ${contactId}`);
+  let historyRows = [];
+  try {
+    historyRows = _db2.query(`SELECT field_name, new_value, source, created_at FROM contact_field_history WHERE contact_id=? ORDER BY created_at DESC`).all(contactId);
+  } catch {}
+  let verifiedRows = [];
+  try {
+    verifiedRows = _db2.query(`SELECT field_name, verified_at, source FROM field_verifications WHERE contact_id=?`).all(contactId);
+  } catch {}
+  const verifiedMap = new Map(verifiedRows.map((r) => [r.field_name, r]));
+  const historyMap = new Map;
+  for (const r of historyRows) {
+    if (!historyMap.has(r.field_name))
+      historyMap.set(r.field_name, r);
+  }
+  const fields = SCORED_FIELDS.map((field) => {
+    let value = null;
+    if (field === "emails") {
+      const emailRow = _db2.query(`SELECT address FROM emails WHERE contact_id=? LIMIT 1`).get(contactId);
+      value = emailRow?.address ?? null;
+    } else if (field === "phones") {
+      const phoneRow = _db2.query(`SELECT number FROM phones WHERE contact_id=? LIMIT 1`).get(contactId);
+      value = phoneRow?.number ?? null;
+    } else {
+      value = contact[field] != null ? String(contact[field]) : null;
+    }
+    const verified = verifiedMap.get(field);
+    const history = historyMap.get(field);
+    let confidence = "unknown";
+    let days_old = null;
+    let last_verified_at = null;
+    let source = null;
+    if (verified) {
+      confidence = "verified";
+      last_verified_at = verified.verified_at;
+      source = verified.source;
+      days_old = Math.floor((Date.now() - new Date(verified.verified_at).getTime()) / 86400000);
+    } else if (history) {
+      confidence = history.source === "import" ? "imported" : "inferred";
+      last_verified_at = history.created_at;
+      source = history.source;
+      days_old = Math.floor((Date.now() - new Date(history.created_at).getTime()) / 86400000);
+      if (days_old > 365)
+        confidence = "stale";
+    } else if (value) {
+      confidence = "inferred";
+    }
+    return { field_name: field, value, last_verified_at, source, confidence, days_old };
+  });
+  const fieldScore = fields.reduce((acc, f) => {
+    if (!f.value)
+      return acc;
+    if (f.confidence === "verified")
+      return acc + 20;
+    if (f.confidence === "imported" || f.confidence === "inferred")
+      return acc + 10;
+    return acc + 5;
+  }, 0);
+  const overall_score = Math.min(100, fieldScore);
+  return {
+    contact_id: contactId,
+    overall_score,
+    fields,
+    stale_fields: fields.filter((f) => f.confidence === "stale" || !f.value && f.field_name !== "phones").map((f) => f.field_name),
+    verified_fields: fields.filter((f) => f.confidence === "verified").map((f) => f.field_name)
+  };
+}
+function getStaleContacts(threshold = 40, db) {
+  const _db2 = db || getDatabase();
+  const rows = _db2.query(`SELECT c.id as contact_id, c.display_name,
+        (CASE WHEN c.job_title IS NOT NULL THEN 15 ELSE 0 END +
+         CASE WHEN c.company_id IS NOT NULL THEN 15 ELSE 0 END +
+         CASE WHEN c.last_contacted_at IS NOT NULL THEN 20 ELSE 0 END +
+         CASE WHEN EXISTS(SELECT 1 FROM emails WHERE contact_id=c.id) THEN 20 ELSE 0 END +
+         CASE WHEN EXISTS(SELECT 1 FROM phones WHERE contact_id=c.id) THEN 15 ELSE 0 END +
+         CASE WHEN c.notes IS NOT NULL THEN 10 ELSE 0 END +
+         CASE WHEN EXISTS(SELECT 1 FROM contact_tags WHERE contact_id=c.id) THEN 5 ELSE 0 END
+        ) as score
+      FROM contacts c WHERE c.archived=0 HAVING score < ? ORDER BY score ASC LIMIT 100`).all(threshold);
+  return rows;
+}
+function markFieldVerified(contactId, fieldName, source, db) {
+  const _db2 = db || getDatabase();
+  try {
+    _db2.query(`INSERT OR REPLACE INTO field_verifications(contact_id,field_name,verified_at,source) VALUES(?,?,?,?)`).run(contactId, fieldName, now(), source || null);
+  } catch {
+    _db2.query(`INSERT INTO activity_log(id,contact_id,action,details,created_at) VALUES(?,?,?,?,?)`).run(crypto.randomUUID(), contactId, "field.verified", JSON.stringify({ field_name: fieldName, source }), now());
+  }
+}
+var SCORED_FIELDS;
+var init_freshness = __esm(() => {
+  init_database();
+  SCORED_FIELDS = ["display_name", "job_title", "company_id", "emails", "phones", "last_contacted_at"];
+});
+
+// src/lib/meeting-capture.ts
+var exports_meeting_capture = {};
+__export(exports_meeting_capture, {
+  ingestMeetingParticipants: () => ingestMeetingParticipants
+});
+async function ingestMeetingParticipants(event, db) {
+  const { findOrCreateContact: findOrCreateContact2 } = await Promise.resolve().then(() => (init_contacts(), exports_contacts));
+  const { logEvent: logEvent2 } = await Promise.resolve().then(() => (init_events(), exports_events));
+  const _db2 = db || getDatabase();
+  let created = 0;
+  let updated = 0;
+  const ids = [];
+  for (const a of event.attendees) {
+    try {
+      const nameParts = a.name.split(" ");
+      const result = await findOrCreateContact2({
+        display_name: a.name,
+        first_name: nameParts[0],
+        last_name: nameParts.slice(1).join(" ") || undefined,
+        emails: [{ address: a.email, type: "work", is_primary: true }],
+        source: "import"
+      }, _db2);
+      ids.push(result.contact.id);
+      if (result.created)
+        created++;
+      else
+        updated++;
+    } catch {}
+  }
+  if (ids.length) {
+    try {
+      logEvent2({
+        title: event.title,
+        type: "meeting",
+        event_date: event.event_date,
+        contact_ids: ids,
+        notes: event.context
+      }, _db2);
+    } catch {}
+  }
+  return { created, updated, contact_ids: ids };
+}
+var init_meeting_capture = __esm(() => {
+  init_database();
+});
+
+// src/db/org-chart.ts
+var exports_org_chart = {};
+__export(exports_org_chart, {
+  setDealContactRole: () => setDealContactRole,
+  listOrgChart: () => listOrgChart,
+  getDealTeam: () => getDealTeam,
+  getCoverageGaps: () => getCoverageGaps,
+  addOrgChartEdge: () => addOrgChartEdge
+});
+function addOrgChartEdge(companyId, contactAId, contactBId, edgeType, inferred = false, db) {
+  const _db2 = db || getDatabase();
+  const id = uuid();
+  _db2.query(`INSERT OR IGNORE INTO org_chart_edges(id,company_id,contact_a_id,contact_b_id,edge_type,inferred,created_at) VALUES(?,?,?,?,?,?,?)`).run(id, companyId, contactAId, contactBId, edgeType, inferred ? 1 : 0, now());
+  return _db2.query(`SELECT * FROM org_chart_edges WHERE company_id=? AND contact_a_id=? AND contact_b_id=? AND edge_type=?`).get(companyId, contactAId, contactBId, edgeType);
+}
+function listOrgChart(companyId, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT oe.*, ca.display_name as contact_a_name, cb.display_name as contact_b_name FROM org_chart_edges oe JOIN contacts ca ON oe.contact_a_id=ca.id JOIN contacts cb ON oe.contact_b_id=cb.id WHERE oe.company_id=?`).all(companyId);
+}
+function setDealContactRole(dealId, contactId, accountRole, db) {
+  const _db2 = db || getDatabase();
+  const id = uuid();
+  _db2.query(`INSERT OR REPLACE INTO deal_contact_roles(id,deal_id,contact_id,account_role,created_at) VALUES(?,?,?,?,?)`).run(id, dealId, contactId, accountRole, now());
+  return _db2.query(`SELECT * FROM deal_contact_roles WHERE deal_id=? AND contact_id=?`).get(dealId, contactId);
+}
+function getDealTeam(dealId, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT dr.*, c.display_name, c.job_title FROM deal_contact_roles dr JOIN contacts c ON dr.contact_id=c.id WHERE dr.deal_id=?`).all(dealId);
+}
+function getCoverageGaps(companyId, db) {
+  const _db2 = db || getDatabase();
+  const total = _db2.query(`SELECT COUNT(*) c FROM contacts WHERE company_id=? AND archived=0`).get(companyId).c;
+  const hasManager = _db2.query(`SELECT COUNT(*) c FROM org_chart_edges WHERE company_id=? AND edge_type='manages'`).get(companyId).c > 0;
+  const hasEco = _db2.query(`SELECT COUNT(*) c FROM deal_contact_roles dr JOIN deals d ON dr.deal_id=d.id WHERE d.company_id=? AND dr.account_role='economic_buyer'`).get(companyId).c > 0;
+  const hasTech = _db2.query(`SELECT COUNT(*) c FROM deal_contact_roles dr JOIN deals d ON dr.deal_id=d.id WHERE d.company_id=? AND dr.account_role='technical_evaluator'`).get(companyId).c > 0;
+  const missing = [
+    !hasManager && "org chart relationships",
+    !hasEco && "economic buyer",
+    !hasTech && "technical evaluator"
+  ].filter(Boolean);
+  return {
+    total_contacts: total,
+    has_manager: hasManager,
+    has_technical: hasTech,
+    has_economic_buyer: hasEco,
+    suggestion: missing.length ? `Missing: ${missing.join(", ")}` : "Good coverage"
+  };
+}
+var init_org_chart = __esm(() => {
+  init_database();
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -5132,17 +5991,19 @@ init_tags();
 init_database();
 function createGroup(db, input) {
   const id = uuid();
-  db.query(`INSERT INTO groups(id, name, description, created_at, updated_at) VALUES(?,?,?,?,?)`).run(id, input.name, input.description ?? null, now(), now());
+  db.query(`INSERT INTO groups(id, name, description, project_id, created_at, updated_at) VALUES(?,?,?,?,?,?)`).run(id, input.name, input.description ?? null, input.project_id ?? null, now(), now());
   return getGroup(db, id);
 }
 function getGroup(db, id) {
   return db.query(`SELECT * FROM groups WHERE id = ?`).get(id);
 }
-function listGroups(db) {
+function listGroups(db, projectId) {
+  const where = projectId ? "WHERE g.project_id = ?" : "";
+  const params = projectId ? [projectId] : [];
   return db.query(`SELECT g.*,
        (SELECT COUNT(*) FROM contact_groups cg WHERE cg.group_id = g.id) as member_count,
        (SELECT COUNT(*) FROM company_groups cog WHERE cog.group_id = g.id) as company_count
-     FROM groups g ORDER BY g.name`).all();
+     FROM groups g ${where} ORDER BY g.name`).all(...params);
 }
 function addContactToGroup(db, contactId, groupId) {
   const existing = db.query(`SELECT 1 FROM contact_groups WHERE contact_id = ? AND group_id = ?`).get(contactId, groupId);
@@ -6878,4 +7739,363 @@ program.command("dnc <id>").description("Mark contact as do-not-contact").option
 `));
   }
 });
+program.command("history <id>").description("Show field change timeline for a contact").option("--field <name>", "Filter to a specific field").action(async (id, opts) => {
+  const { getFieldHistory: getFieldHistory2 } = await Promise.resolve().then(() => (init_field_history(), exports_field_history));
+  const db = getDatabase();
+  const history = getFieldHistory2(id, opts.field, db);
+  if (!history.length) {
+    console.log(chalk.gray(`
+No field history found.
+`));
+    return;
+  }
+  const contact = getContact(id);
+  console.log(chalk.bold(`
+Field History: ${contact.display_name}
+`));
+  renderTable(["Field", "Old Value", "New Value", "When", "Source"], history.map((h) => ({
+    Field: h.field_name,
+    "Old Value": h.old_value ?? "",
+    "New Value": h.new_value ?? "",
+    When: h.valid_from.slice(0, 16),
+    Source: h.source ?? ""
+  })));
+  console.log();
+});
+program.command("learnings [id]").description("Show or search learnings for a contact").option("--search <query>", "Cross-contact search across all learnings").option("--type <type>", "Filter by type: preference|fact|inference|warning|signal").option("--min-importance <n>", "Minimum importance (1-10)").action(async (id, opts) => {
+  const { getLearnings: getLearnings2, searchLearnings: searchLearnings2 } = await Promise.resolve().then(() => (init_learnings(), exports_learnings));
+  const db = getDatabase();
+  if (opts.search) {
+    const results = searchLearnings2(opts.search, { type: opts.type, contact_id: id }, db);
+    if (!results.length) {
+      console.log(chalk.gray(`
+No learnings found for: "${opts.search}"
+`));
+      return;
+    }
+    console.log(chalk.bold(`
+Learnings matching "${opts.search}":
+`));
+    renderTable(["Contact", "Type", "Confidence", "Content"], results.map((r) => {
+      let name = r.contact_id;
+      try {
+        name = getContact(r.contact_id).display_name;
+      } catch {}
+      return { Contact: name, Type: r.type, Confidence: String(r.confidence) + "%", Content: r.content };
+    }));
+    console.log(chalk.gray(`
+${results.length} learning(s)
+`));
+    return;
+  }
+  if (!id) {
+    console.error(chalk.red("Provide a contact ID or use --search <query>"));
+    process.exit(1);
+  }
+  const learnings = getLearnings2(id, {
+    type: opts.type,
+    min_importance: opts.minImportance ? parseInt(opts.minImportance, 10) : undefined
+  }, db);
+  const contact = getContact(id);
+  if (!learnings.length) {
+    console.log(chalk.gray(`
+No learnings for ${contact.display_name}.
+`));
+    return;
+  }
+  console.log(chalk.bold(`
+Learnings: ${contact.display_name} (${learnings.length})
+`));
+  for (const l of learnings) {
+    const conf = l.confidence >= 80 ? chalk.green : l.confidence >= 50 ? chalk.yellow : chalk.red;
+    console.log(`  ${conf(String(l.confidence).padStart(3) + "%")}  ${chalk.cyan(l.type.padEnd(12))}  ${l.content}`);
+  }
+  console.log();
+});
+program.command("graph <id>").description("Show relationship network and strength score for a contact").action(async (id) => {
+  const { computeRelationshipStrength: computeRelationshipStrength2 } = await Promise.resolve().then(() => (init_graph(), exports_graph));
+  const { listRelationships: listRelationships2 } = await Promise.resolve().then(() => (init_relationships(), exports_relationships));
+  const db = getDatabase();
+  const contact = getContact(id);
+  const strength = computeRelationshipStrength2(id, db);
+  const rels = listRelationships2({ contact_id: id });
+  console.log(chalk.bold(`
+Network: ${contact.display_name}`));
+  const strengthColor = strength >= 70 ? chalk.green : strength >= 40 ? chalk.yellow : chalk.red;
+  console.log(`  Relationship Strength: ${strengthColor(String(strength) + "/100")}
+`);
+  if (!rels.length) {
+    console.log(chalk.gray(`  No relationships mapped.
+`));
+    return;
+  }
+  for (const r of rels) {
+    const otherId = r.contact_a_id === id ? r.contact_b_id : r.contact_a_id;
+    let otherName = otherId;
+    try {
+      otherName = getContact(otherId).display_name;
+    } catch {}
+    console.log(`  ${chalk.cyan(r.relationship_type.padEnd(14))} ${otherName}`);
+  }
+  console.log();
+});
+program.command("cooling").description("Show warming, cooling, and ghost contacts").action(async () => {
+  const { detectCoolingRelationships: detectCoolingRelationships2 } = await Promise.resolve().then(() => (init_graph(), exports_graph));
+  const { getGhostContacts: getGhostContacts2, getWarmingContacts: getWarmingContacts2 } = await Promise.resolve().then(() => (init_signals(), exports_signals));
+  const db = getDatabase();
+  const cooling = detectCoolingRelationships2(db);
+  const ghosts = getGhostContacts2(db);
+  const warming = getWarmingContacts2(db);
+  if (warming.length) {
+    console.log(chalk.bold.green(`
+Warming (${warming.length}):`));
+    for (const c of warming.slice(0, 10)) {
+      console.log(`  ${chalk.green("\u2191")} ${c.display_name}  ${chalk.gray(c.days_since_contact !== null ? c.days_since_contact + "d ago" : "never")}`);
+    }
+  }
+  if (cooling.length) {
+    console.log(chalk.bold.yellow(`
+Cooling (${cooling.length}):`));
+    for (const c of cooling.slice(0, 10)) {
+      console.log(`  ${chalk.yellow("\u2193")} ${c.display_name}  ${chalk.gray(String(c.days_since) + "d ago")}`);
+    }
+  }
+  if (ghosts.length) {
+    console.log(chalk.bold.red(`
+Ghost (${ghosts.length}):`));
+    for (const c of ghosts.slice(0, 10)) {
+      console.log(`  ${chalk.red("\u2620")} ${c.display_name}  ${chalk.gray(c.days_since_contact !== null ? c.days_since_contact + "d ago" : "never contacted")}`);
+    }
+  }
+  if (!warming.length && !cooling.length && !ghosts.length) {
+    console.log(chalk.green(`
+All relationships look healthy!
+`));
+  }
+  console.log();
+});
+program.command("resolve").description("Resolve contact identity before creating (check for existing contact)").option("--email <email>", "Email to search").option("--name <name>", "Name to search").option("--linkedin <url>", "LinkedIn URL to search").action(async (opts) => {
+  const { resolveByPartial: resolveByPartial2 } = await Promise.resolve().then(() => (init_identity(), exports_identity));
+  const db = getDatabase();
+  const matches = resolveByPartial2({ email: opts.email, name: opts.name, linkedin_url: opts.linkedin }, db);
+  if (!matches.length) {
+    console.log(chalk.gray(`
+No matches found \u2014 safe to create.
+`));
+    return;
+  }
+  console.log(chalk.bold(`
+Potential matches (${matches.length}):
+`));
+  renderTable(["Name", "Job Title", "Confidence", "Match Reasons"], matches.map((m) => ({
+    Name: m.contact.display_name,
+    "Job Title": m.contact.job_title ?? "",
+    Confidence: String(m.confidence_score) + "%",
+    "Match Reasons": m.match_reasons.join("; ")
+  })));
+  console.log();
+});
+program.command("search-semantic <query>").description('Semantic capability search using TF-IDF embeddings (run "contacts embed --all" first)').option("--limit <n>", "Max results", "10").action(async (query, opts) => {
+  const { semanticSearch: semanticSearch2 } = await Promise.resolve().then(() => (init_embeddings(), exports_embeddings));
+  const db = getDatabase();
+  const results = semanticSearch2(query, parseInt(opts.limit, 10), db);
+  if (!results.length) {
+    console.log(chalk.gray(`
+No semantic matches for "${query}". Try running: contacts embed --all
+`));
+    return;
+  }
+  console.log(chalk.bold(`
+Semantic search: "${query}"
+`));
+  renderTable(["Name", "Score", "Company", "Title"], results.map((r) => {
+    let name = r.contact_id;
+    let company = "";
+    let title = "";
+    try {
+      const c = getContact(r.contact_id);
+      name = c.display_name;
+      company = c.company?.name ?? "";
+      title = c.job_title ?? "";
+    } catch {}
+    return { Name: name, Score: (r.score * 100).toFixed(1) + "%", Company: company, Title: title };
+  }));
+  console.log();
+});
+program.command("signals <id>").description("Show relationship health signals for a contact").action(async (id) => {
+  const { getRelationshipSignals: getRelationshipSignals2 } = await Promise.resolve().then(() => (init_signals(), exports_signals));
+  const db = getDatabase();
+  const contact = getContact(id);
+  const signals = getRelationshipSignals2(id, db);
+  console.log(chalk.bold(`
+Signals: ${contact.display_name}
+`));
+  for (const s of signals) {
+    const color = s.signal_type === "warming" ? chalk.green : s.signal_type === "ghost" ? chalk.red : s.signal_type === "cooling" ? chalk.yellow : chalk.cyan;
+    const icon = s.signal_type === "warming" ? "\u2191" : s.signal_type === "ghost" ? "\u2620" : s.signal_type === "cooling" ? "\u2193" : "\u2713";
+    console.log(`  ${color(icon + " " + s.signal_type.toUpperCase())}  ${chalk.gray(s.reason)}`);
+    if (s.days_since_contact !== null) {
+      console.log(`    Last contact: ${s.days_since_contact} days ago`);
+    }
+  }
+  console.log();
+});
+program.command("stale").description("List contacts with low data completeness scores").option("--threshold <n>", "Score threshold 0-100 (default 40)", "40").action(async (opts) => {
+  const { getStaleContacts: getStaleContacts2 } = await Promise.resolve().then(() => (init_freshness(), exports_freshness));
+  const db = getDatabase();
+  const threshold = parseInt(opts.threshold, 10);
+  const contacts = getStaleContacts2(threshold, db);
+  if (!contacts.length) {
+    console.log(chalk.green(`
+No contacts below ${threshold}% completeness!
+`));
+    return;
+  }
+  console.log(chalk.bold(`
+Stale contacts (below ${threshold}% completeness):
+`));
+  renderTable(["Name", "Score"], contacts.map((c) => ({
+    Name: c.display_name,
+    Score: String(c.score) + "%"
+  })));
+  console.log(chalk.gray(`
+${contacts.length} contact(s) need enrichment
+`));
+});
+program.command("freshness <id>").description("Show per-field confidence and freshness breakdown for a contact").action(async (id) => {
+  const { getFreshnessScore: getFreshnessScore2 } = await Promise.resolve().then(() => (init_freshness(), exports_freshness));
+  const db = getDatabase();
+  const contact = getContact(id);
+  const score = getFreshnessScore2(id, db);
+  console.log(chalk.bold(`
+Freshness: ${contact.display_name}`));
+  const scoreColor = score.overall_score >= 70 ? chalk.green : score.overall_score >= 40 ? chalk.yellow : chalk.red;
+  console.log(`  Overall: ${scoreColor(String(score.overall_score) + "/100")}
+`);
+  renderTable(["Field", "Value", "Confidence", "Last Verified", "Days Old"], score.fields.map((f) => ({
+    Field: f.field_name,
+    Value: f.value ? f.value.slice(0, 20) : chalk.gray("(missing)"),
+    Confidence: f.confidence,
+    "Last Verified": f.last_verified_at ? f.last_verified_at.slice(0, 10) : "",
+    "Days Old": f.days_old !== null ? String(f.days_old) + "d" : ""
+  })));
+  console.log();
+});
+program.command("embed").description("Build semantic embeddings for contacts").option("--all", "Embed all contacts in the database").option("--contact <id>", "Embed a single contact").action(async (opts) => {
+  const { embedAllContacts: embedAllContacts2, embedContact: embedContact2 } = await Promise.resolve().then(() => (init_embeddings(), exports_embeddings));
+  const db = getDatabase();
+  if (opts.all) {
+    console.log(chalk.blue(`
+Building embeddings for all contacts...
+`));
+    const count = await embedAllContacts2(db);
+    console.log(chalk.green(`\u2713 Embedded ${count} contact(s)
+`));
+  } else if (opts.contact) {
+    await embedContact2(opts.contact, db);
+    const contact = getContact(opts.contact);
+    console.log(chalk.green(`\u2713 Embedded: ${contact.display_name}
+`));
+  } else {
+    console.error(chalk.red("Use --all or --contact <id>"));
+    process.exit(1);
+  }
+});
+program.command("capture-meeting").description("Ingest meeting participants as contacts and log the event").option("--title <title>", "Meeting title (required)").option("--date <date>", "Meeting date (YYYY-MM-DD, default today)").option("--attendee <name:email>", "Attendee (format: Name:email@example.com), repeatable", collect, []).option("--context <text>", "Meeting context or agenda").action(async (opts) => {
+  const { ingestMeetingParticipants: ingestMeetingParticipants2 } = await Promise.resolve().then(() => (init_meeting_capture(), exports_meeting_capture));
+  const db = getDatabase();
+  let title = opts.title;
+  if (!title) {
+    title = await prompt("Meeting title (required):");
+    if (!title) {
+      console.error(chalk.red("Title is required."));
+      process.exit(1);
+    }
+  }
+  const eventDate = opts.date ?? new Date().toISOString().slice(0, 10);
+  const attendees = opts.attendee.map((a) => {
+    const colonIdx = a.lastIndexOf(":");
+    if (colonIdx > 0) {
+      return { name: a.slice(0, colonIdx), email: a.slice(colonIdx + 1) };
+    }
+    return { name: a, email: a };
+  });
+  if (!attendees.length) {
+    console.log(chalk.yellow(`
+No attendees provided. Use --attendee "Name:email@example.com"
+`));
+    return;
+  }
+  const result = await ingestMeetingParticipants2({ title, event_date: eventDate, attendees, context: opts.context }, db);
+  console.log(chalk.green(`
+\u2713 Meeting captured: ${title}`));
+  console.log(`  ${chalk.cyan(String(result.created))} contacts created`);
+  console.log(`  ${chalk.cyan(String(result.updated))} contacts found (existing)
+`);
+});
+var orgCmd = program.command("org").description("Org chart and deal team management");
+orgCmd.command("chart <company-id>").description("Show ASCII org chart for a company").action(async (companyId) => {
+  const { listOrgChart: listOrgChart2 } = await Promise.resolve().then(() => (init_org_chart(), exports_org_chart));
+  const db = getDatabase();
+  const company = getCompany(companyId);
+  if (!company) {
+    console.error(chalk.red(`
+Company not found: ${companyId}
+`));
+    process.exit(1);
+  }
+  const edges = listOrgChart2(companyId, db);
+  console.log(chalk.bold(`
+Org Chart: ${company.name}
+`));
+  if (!edges.length) {
+    console.log(chalk.gray(`  No org chart edges defined. Use: contacts org add-edge
+`));
+    return;
+  }
+  for (const e of edges) {
+    const arrow = e.edge_type === "manages" ? "\u2192" : e.edge_type === "reports_to" ? "\u2190" : "\u2194";
+    console.log(`  ${chalk.cyan(e.contact_a_name)}  ${chalk.gray(arrow + " " + e.edge_type + " \u2192")}  ${chalk.cyan(e.contact_b_name)}`);
+  }
+  console.log();
+});
+orgCmd.command("add-edge <company-id> <contact-a> <contact-b>").description("Add an org chart edge between two contacts at a company").option("--type <type>", "Edge type: reports_to|manages|peer|collaborates_with", "reports_to").action(async (companyId, contactAId, contactBId, opts) => {
+  const { addOrgChartEdge: addOrgChartEdge2 } = await Promise.resolve().then(() => (init_org_chart(), exports_org_chart));
+  const db = getDatabase();
+  const contactA = getContact(contactAId);
+  const contactB = getContact(contactBId);
+  addOrgChartEdge2(companyId, contactAId, contactBId, opts.type || "reports_to", false, db);
+  console.log(chalk.green(`
+\u2713 ${contactA.display_name} ${opts.type || "reports_to"} ${contactB.display_name}
+`));
+});
+var dealsTeamCmd = program.command("deals-team").description("Deal team and buying committee management");
+dealsTeamCmd.command("show <deal-id>").description("Show buying committee for a deal").action(async (dealId) => {
+  const { getDealTeam: getDealTeam2 } = await Promise.resolve().then(() => (init_org_chart(), exports_org_chart));
+  const db = getDatabase();
+  const team = getDealTeam2(dealId, db);
+  console.log(chalk.bold(`
+Deal Team: ${dealId}
+`));
+  if (!team.length) {
+    console.log(chalk.gray(`  No contacts assigned to this deal team.
+`));
+    return;
+  }
+  renderTable(["Contact", "Role", "Title"], team.map((m) => ({
+    Contact: m.display_name,
+    Role: m.account_role,
+    Title: m.job_title ?? ""
+  })));
+  console.log();
+});
+dealsTeamCmd.command("assign <deal-id> <contact-id>").description("Assign a contact a role in a deal (buying committee)").option("--role <role>", "Role: economic_buyer|technical_evaluator|champion|blocker|influencer|user|sponsor|other", "other").action(async (dealId, contactId, opts) => {
+  const { setDealContactRole: setDealContactRole2 } = await Promise.resolve().then(() => (init_org_chart(), exports_org_chart));
+  const db = getDatabase();
+  const contact = getContact(contactId);
+  setDealContactRole2(dealId, contactId, opts.role || "other", db);
+  console.log(chalk.green(`
+\u2713 ${contact.display_name} assigned as ${opts.role || "other"} in deal ${dealId}
+`));
+});
 program.parse(process.argv);