@hasna/contacts 0.6.5 → 0.6.6

package/dist/mcp/index.js

@@ -19,13 +19,30 @@ var __require = import.meta.require;
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
-import { existsSync, mkdirSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, statSync } from "fs";
 import { dirname, join, resolve } from "path";
+function getDataDir() {
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  const newDir = join(home, ".hasna", "contacts");
+  const oldDir = join(home, ".contacts");
+  if (existsSync(oldDir) && !existsSync(newDir)) {
+    mkdirSync(newDir, { recursive: true });
+    for (const file of readdirSync(oldDir)) {
+      const oldPath = join(oldDir, file);
+      if (statSync(oldPath).isFile()) {
+        copyFileSync(oldPath, join(newDir, file));
+      }
+    }
+  }
+  mkdirSync(newDir, { recursive: true });
+  return newDir;
+}
 function getDbPath() {
+  if (process.env["HASNA_CONTACTS_DB_PATH"])
+    return process.env["HASNA_CONTACTS_DB_PATH"];
   if (process.env["CONTACTS_DB_PATH"])
     return process.env["CONTACTS_DB_PATH"];
-  const home = process.env["HOME"] || "~";
-  return join(home, ".contacts", "contacts.db");
+  return join(getDataDir(), "contacts.db");
 }
 function ensureDir(filePath) {
   if (filePath === ":memory:")
@@ -410,6 +427,177 @@ 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'))
+  );
+  `,
+    `
+  ALTER TABLE contacts ADD COLUMN sensitivity TEXT NOT NULL DEFAULT 'normal' CHECK(sensitivity IN ('normal','confidential','restricted'));
+
+  CREATE TABLE IF NOT EXISTS contact_documents (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    doc_type TEXT NOT NULL,
+    label TEXT,
+    encrypted_value TEXT NOT NULL,
+    iv TEXT NOT NULL,
+    encrypted_file_path TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    expires_at TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_health (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL UNIQUE REFERENCES contacts(id) ON DELETE CASCADE,
+    blood_type TEXT,
+    allergies TEXT NOT NULL DEFAULT '[]',
+    medical_conditions TEXT NOT NULL DEFAULT '[]',
+    medications TEXT NOT NULL DEFAULT '[]',
+    emergency_contacts TEXT NOT NULL DEFAULT '[]',
+    health_insurance_provider TEXT,
+    health_insurance_id TEXT,
+    primary_physician TEXT,
+    primary_physician_phone TEXT,
+    organ_donor INTEGER NOT NULL DEFAULT 0,
+    notes TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
   `
   ];
 });
@@ -491,6 +679,7 @@ __export(exports_contacts, {
   getContactProjectIds: () => getContactProjectIds,
   getContactByEmail: () => getContactByEmail,
   getContact: () => getContact,
+  findOrCreateContact: () => findOrCreateContact,
   deleteContact: () => deleteContact,
   createContact: () => createContact,
   autoLinkContactToCompany: () => autoLinkContactToCompany,
@@ -508,6 +697,7 @@ function rowToContact(row) {
     follow_up_at: row.follow_up_at ?? null,
     archived: !!row.archived,
     project_id: row.project_id ?? null,
+    sensitivity: row.sensitivity ?? "normal",
     do_not_contact: !!row.do_not_contact,
     priority: row.priority ?? 3,
     timezone: row.timezone ?? null
@@ -595,8 +785,8 @@ function createContact(input, db) {
   const firstName = input.first_name ?? "";
   const lastName = input.last_name ?? "";
   const displayName = input.display_name ?? (firstName || lastName ? `${firstName} ${lastName}`.trim() : "Unnamed Contact");
-  d.run(`INSERT INTO contacts (id, first_name, last_name, display_name, nickname, avatar_url, notes, birthday, company_id, job_title, source, custom_fields, last_contacted_at, website, preferred_contact_method, status, follow_up_at, project_id, do_not_contact, priority, timezone, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO contacts (id, first_name, last_name, display_name, nickname, avatar_url, notes, birthday, company_id, job_title, source, custom_fields, last_contacted_at, website, preferred_contact_method, status, follow_up_at, project_id, sensitivity, do_not_contact, priority, timezone, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
     firstName,
     lastName,
@@ -615,6 +805,7 @@ function createContact(input, db) {
     input.status ?? "active",
     input.follow_up_at ?? null,
     input.project_id ?? null,
+    input.sensitivity ?? "normal",
     input.do_not_contact ? 1 : 0,
     input.priority ?? 3,
     input.timezone ?? null,
@@ -663,6 +854,7 @@ function listContacts(opts = {}, db) {
     order_by = "display_name",
     order_dir = "asc",
     include_dnc = false,
+    include_restricted = false,
     priority_min,
     updated_since
   } = opts;
@@ -673,6 +865,9 @@ function listContacts(opts = {}, db) {
   if (!include_dnc) {
     conditions.push("c.do_not_contact = 0");
   }
+  if (!include_restricted) {
+    conditions.push("c.sensitivity != 'restricted'");
+  }
   if (company_id) {
     conditions.push("c.company_id = ?");
     params.push(company_id);
@@ -801,6 +996,10 @@ function updateContact(id, input, db) {
     setClauses.push("project_id = ?");
     params.push(input.project_id);
   }
+  if (input.sensitivity !== undefined) {
+    setClauses.push("sensitivity = ?");
+    params.push(input.sensitivity);
+  }
   if (input.do_not_contact !== undefined) {
     setClauses.push("do_not_contact = ?");
     params.push(input.do_not_contact ? 1 : 0);
@@ -848,26 +1047,26 @@ function searchContacts(query, db) {
   const ftsRows = d.query(`
     SELECT c.* FROM contacts c
     JOIN contacts_fts fts ON fts.id = c.id
-    WHERE contacts_fts MATCH ? AND c.archived = 0
+    WHERE contacts_fts MATCH ? AND c.archived = 0 AND c.sensitivity != 'restricted'
     ORDER BY rank
     LIMIT 50
   `).all(`"${query.replace(/"/g, '""')}"*`);
   const emailRows = d.query(`
     SELECT DISTINCT c.* FROM contacts c
     JOIN emails e ON e.contact_id = c.id
-    WHERE e.address LIKE ? AND c.archived = 0
+    WHERE e.address LIKE ? AND c.archived = 0 AND c.sensitivity != 'restricted'
     LIMIT 20
   `).all(`%${query}%`);
   const phoneRows = d.query(`
     SELECT DISTINCT c.* FROM contacts c
     JOIN phones p ON p.contact_id = c.id
-    WHERE p.number LIKE ? AND c.archived = 0
+    WHERE p.number LIKE ? AND c.archived = 0 AND c.sensitivity != 'restricted'
     LIMIT 20
   `).all(`%${query}%`);
   const companyRows = d.query(`
     SELECT DISTINCT c.* FROM contacts c
     JOIN companies co ON co.id = c.company_id
-    WHERE co.name LIKE ? AND c.archived = 0
+    WHERE co.name LIKE ? AND c.archived = 0 AND c.sensitivity != 'restricted'
     LIMIT 20
   `).all(`%${query}%`);
   const seen = new Set;
@@ -1020,6 +1219,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);
@@ -1070,6 +1288,96 @@ var init_contacts = __esm(() => {
   init_activity();
 });
 
+// src/db/events.ts
+var exports_events = {};
+__export(exports_events, {
+  logEvent: () => logEvent,
+  listEvents: () => listEvents,
+  getEvent: () => getEvent,
+  deleteEvent: () => deleteEvent
+});
+function rowToEvent(row) {
+  let contact_ids = [];
+  try {
+    contact_ids = JSON.parse(row.contact_ids);
+  } catch {
+    contact_ids = [];
+  }
+  return {
+    id: row.id,
+    title: row.title,
+    type: row.type,
+    event_date: row.event_date,
+    duration_min: row.duration_min,
+    contact_ids,
+    company_id: row.company_id,
+    notes: row.notes,
+    outcome: row.outcome,
+    deal_id: row.deal_id,
+    created_at: row.created_at
+  };
+}
+function logEvent(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO events (id, title, type, event_date, duration_min, contact_ids, company_id, notes, outcome, deal_id, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.title,
+    input.type ?? "meeting",
+    input.event_date,
+    input.duration_min ?? null,
+    JSON.stringify(input.contact_ids ?? []),
+    input.company_id ?? null,
+    input.notes ?? null,
+    input.outcome ?? null,
+    input.deal_id ?? null,
+    timestamp
+  ]);
+  return rowToEvent(d.query(`SELECT * FROM events WHERE id = ?`).get(id));
+}
+function getEvent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query(`SELECT * FROM events WHERE id = ?`).get(id);
+  return row ? rowToEvent(row) : null;
+}
+function listEvents(opts = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (opts.contact_id) {
+    conditions.push("contact_ids LIKE ?");
+    params.push(`%${opts.contact_id}%`);
+  }
+  if (opts.company_id) {
+    conditions.push("company_id = ?");
+    params.push(opts.company_id);
+  }
+  if (opts.type) {
+    conditions.push("type = ?");
+    params.push(opts.type);
+  }
+  if (opts.date_from) {
+    conditions.push("event_date >= ?");
+    params.push(opts.date_from);
+  }
+  if (opts.date_to) {
+    conditions.push("event_date <= ?");
+    params.push(opts.date_to);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM events ${where} ORDER BY event_date DESC`).all(...params);
+  return rows.map(rowToEvent);
+}
+function deleteEvent(id, db) {
+  const d = db || getDatabase();
+  d.run(`DELETE FROM events WHERE id = ?`, [id]);
+}
+var init_events = __esm(() => {
+  init_database();
+});
+
 // src/mcp/index.ts
 init_database();
 init_contacts();
@@ -3279,84 +3587,1142 @@ function deleteDeal(id, db) {
   d.run(`DELETE FROM deals WHERE id = ?`, [id]);
 }
 
-// src/db/events.ts
+// src/mcp/index.ts
+init_events();
+
+// src/db/field-history.ts
 init_database();
-function rowToEvent(row) {
-  let contact_ids = [];
-  try {
-    contact_ids = JSON.parse(row.contact_ids);
-  } catch {
-    contact_ids = [];
+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 {
-    id: row.id,
-    title: row.title,
-    type: row.type,
-    event_date: row.event_date,
-    duration_min: row.duration_min,
-    contact_ids,
-    company_id: row.company_id,
-    notes: row.notes,
-    outcome: row.outcome,
-    deal_id: row.deal_id,
-    created_at: row.created_at
-  };
+  return _db2.query(`SELECT * FROM contact_field_history WHERE contact_id=? ORDER BY valid_from DESC`).all(contactId);
 }
-function logEvent(input, db) {
-  const d = db || getDatabase();
+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;
+}
+
+// src/db/job-history.ts
+init_database();
+function rowToJob(r) {
+  return { ...r, is_current: !!r["is_current"], inferred: !!r["inferred"] };
+}
+function addJobEntry(contactId, input, db) {
+  const _db2 = db || getDatabase();
+  if (input.is_current) {
+    _db2.query(`UPDATE job_history SET is_current=0, end_date=COALESCE(end_date,?) WHERE contact_id=? AND is_current=1`).run(new Date().toISOString().slice(0, 10), contactId);
+  }
   const id = uuid();
-  const timestamp = now();
-  d.run(`INSERT INTO events (id, title, type, event_date, duration_min, contact_ids, company_id, notes, outcome, deal_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-    id,
-    input.title,
-    input.type ?? "meeting",
-    input.event_date,
-    input.duration_min ?? null,
-    JSON.stringify(input.contact_ids ?? []),
-    input.company_id ?? null,
-    input.notes ?? null,
-    input.outcome ?? null,
-    input.deal_id ?? null,
-    timestamp
-  ]);
-  return rowToEvent(d.query(`SELECT * FROM events WHERE id = ?`).get(id));
+  _db2.query(`INSERT INTO job_history(id,contact_id,company_id,company_name,title,start_date,end_date,is_current,inferred,source,created_at) VALUES(?,?,?,?,?,?,?,?,?,?,?)`).run(id, contactId, input.company_id || null, input.company_name, input.title || null, input.start_date || null, input.end_date || null, input.is_current ? 1 : 0, input.inferred ? 1 : 0, input.source || null, now());
+  return rowToJob(_db2.query(`SELECT * FROM job_history WHERE id=?`).get(id));
 }
-function listEvents(opts = {}, db) {
-  const d = db || getDatabase();
-  const conditions = [];
-  const params = [];
-  if (opts.contact_id) {
-    conditions.push("contact_ids LIKE ?");
-    params.push(`%${opts.contact_id}%`);
+function getJobHistory(contactId, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT * FROM job_history WHERE contact_id=? ORDER BY is_current DESC, start_date DESC`).all(contactId).map(rowToJob);
+}
+
+// src/db/learnings.ts
+init_database();
+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.company_id) {
-    conditions.push("company_id = ?");
-    params.push(opts.company_id);
+  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) {
-    conditions.push("type = ?");
+    sql += ` AND type=?`;
     params.push(opts.type);
   }
-  if (opts.date_from) {
-    conditions.push("event_date >= ?");
-    params.push(opts.date_from);
-  }
-  if (opts.date_to) {
-    conditions.push("event_date <= ?");
-    params.push(opts.date_to);
+  if (opts.contact_id) {
+    sql += ` AND contact_id=?`;
+    params.push(opts.contact_id);
   }
-  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const rows = d.query(`SELECT * FROM events ${where} ORDER BY event_date DESC`).all(...params);
-  return rows.map(rowToEvent);
+  sql += ` ORDER BY importance DESC, confidence DESC LIMIT 50`;
+  return _db2.query(sql).all(...params).map(rowToLearning);
 }
-function deleteEvent(id, db) {
-  const d = db || getDatabase();
-  d.run(`DELETE FROM events WHERE id = ?`, [id]);
+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;
 }
 
-// src/mcp/index.ts
-var server = new Server({ name: "contacts", version: "0.1.0" }, { capabilities: { tools: {} } });
+// src/db/coordination.ts
+init_database();
+function acquireLock(contactId, agentName, ttlSeconds = 300, reason, sessionId, db) {
+  const _db2 = db || getDatabase();
+  cleanExpiredLocks(_db2);
+  const existing = _db2.query(`SELECT * FROM contact_locks WHERE contact_id=?`).get(contactId);
+  if (existing)
+    return { acquired: false, held_by: existing.agent_name, lock: existing };
+  const id = uuid();
+  const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+  _db2.query(`INSERT INTO contact_locks(id,contact_id,agent_name,reason,acquired_at,expires_at,session_id) VALUES(?,?,?,?,?,?,?)`).run(id, contactId, agentName, reason || null, now(), expiresAt, sessionId || null);
+  return {
+    acquired: true,
+    lock: _db2.query(`SELECT * FROM contact_locks WHERE id=?`).get(id)
+  };
+}
+function releaseLock(contactId, agentName, db) {
+  const _db2 = db || getDatabase();
+  const result = _db2.query(`DELETE FROM contact_locks WHERE contact_id=? AND agent_name=?`).run(contactId, agentName);
+  return (result.changes || 0) > 0;
+}
+function checkLock(contactId, db) {
+  const _db2 = db || getDatabase();
+  cleanExpiredLocks(_db2);
+  return _db2.query(`SELECT * FROM contact_locks WHERE contact_id=?`).get(contactId);
+}
+function cleanExpiredLocks(db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`DELETE FROM contact_locks WHERE expires_at<?`).run(now());
+}
+function logAgentActivity(contactId, agentName, action, details, sessionId, db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`INSERT INTO contact_agent_activity(id,contact_id,agent_name,action,details,session_id,created_at) VALUES(?,?,?,?,?,?,?)`).run(uuid(), contactId, agentName, action, details || null, sessionId || null, now());
+}
+function getAgentActivity(contactId, limit = 20, db) {
+  const _db2 = db || getDatabase();
+  return _db2.query(`SELECT * FROM contact_agent_activity WHERE contact_id=? ORDER BY created_at DESC LIMIT ?`).all(contactId, limit);
+}
+
+// src/db/graph.ts
+init_database();
+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);
+}
+
+// src/db/identity.ts
+init_database();
+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 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);
+}
+
+// src/lib/embeddings.ts
+init_database();
+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;
+}
+
+// src/db/signals.ts
+init_database();
+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 };
+}
+
+// src/lib/context.ts
+init_database();
+init_contacts();
+function getContactCard(contactId, db) {
+  const _db2 = db || getDatabase();
+  const c = getContact(contactId, _db2);
+  const emails = c.emails;
+  const phones = c.phones;
+  const company = c.company;
+  return {
+    id: c.id,
+    display_name: c.display_name,
+    job_title: c.job_title,
+    company: company?.name,
+    primary_email: emails?.find((e) => e.is_primary)?.address || emails?.[0]?.address,
+    primary_phone: phones?.find((p) => p.is_primary)?.number || phones?.[0]?.number
+  };
+}
+function getContactBrief(contactId, taskContext, db) {
+  const _db2 = db || getDatabase();
+  const c = getContact(contactId, _db2);
+  const notes = listNotes(contactId, _db2).slice(0, 3);
+  const learnings = getLearnings(contactId, { min_importance: 7 }, _db2).slice(0, 5);
+  const ctx = (taskContext ?? "").toLowerCase();
+  const lastContactedAt = c.last_contacted_at;
+  const daysSince = lastContactedAt ? Math.floor((Date.now() - new Date(lastContactedAt).getTime()) / 86400000) : null;
+  const company = c.company;
+  const brief = {
+    id: c.id,
+    display_name: c.display_name,
+    job_title: c.job_title,
+    company: company?.name,
+    status: c.status,
+    last_contacted: daysSince !== null ? `${daysSince}d ago` : "never",
+    relationship_health: c.relationship_health,
+    engagement_status: c.engagement_status,
+    preferred_contact: c.preferred_contact_method || c.preferred_channel
+  };
+  if (ctx.includes("meeting") || ctx.includes("call") || ctx.includes("prep")) {
+    brief.recent_notes = notes.map((n) => ({ date: n.created_at?.slice(0, 10), content: n.body }));
+    brief.key_learnings = learnings.map((l) => l.content);
+  }
+  if (ctx.includes("outreach") || ctx.includes("email")) {
+    brief.preferred_channel = c.preferred_channel;
+    brief.follow_up_at = c.follow_up_at;
+  }
+  if (ctx.includes("deal")) {
+    const dealCompany = c.company;
+    brief.company_details = dealCompany ? { name: dealCompany.name, domain: dealCompany.domain } : null;
+  }
+  if (learnings.length)
+    brief.top_learnings = learnings.map((l) => l.content);
+  return brief;
+}
+async function assembleContext(contactIds, format = "meeting_prep", db) {
+  const _db2 = db || getDatabase();
+  const briefs = contactIds.map((id) => {
+    try {
+      return getContactBrief(id, format, _db2);
+    } catch {
+      return { id, error: "not found" };
+    }
+  });
+  return { format, contact_count: contactIds.length, assembled_at: new Date().toISOString(), contacts: briefs };
+}
+
+// src/lib/signature-parser.ts
+function parseEmailSignature(text) {
+  const result = {};
+  const phoneMatch = text.match(/(\+?[\d\s\-\(\)]{7,20})/);
+  if (phoneMatch)
+    result.phone = phoneMatch[1]?.trim();
+  const emailMatch = text.match(/[\w.+-]+@[\w-]+\.[a-z]{2,}/i);
+  if (emailMatch)
+    result.email = emailMatch[0];
+  const linkedinMatch = text.match(/(?:linkedin\.com\/in\/)([\w-]+)/i);
+  if (linkedinMatch)
+    result.linkedin = `https://linkedin.com/in/${linkedinMatch[1]}`;
+  const websiteMatch = text.match(/https?:\/\/(?!linkedin)(?!twitter)[\w.-]+\.[a-z]{2,}/i);
+  if (websiteMatch)
+    result.website = websiteMatch[0];
+  const lines = text.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 2 && l.length < 80);
+  if (lines[0])
+    result.name = lines[0];
+  for (const line of lines.slice(1)) {
+    if (line.match(/\b(CEO|CTO|VP|Director|Manager|Engineer|Partner|Associate|Consultant|Analyst|President|Founder)\b/i)) {
+      result.title = line;
+    } else if (!result.company && line.match(/^[A-Z][A-Za-z\s,\.]+$/) && !line.includes("@")) {
+      result.company = line;
+    }
+  }
+  return result;
+}
+function extractContactsFromEmailThread(participants) {
+  return participants.map((p) => {
+    const sig = p.signature ? parseEmailSignature(p.signature) : {};
+    const name = p.name || sig.name || p.email.split("@")[0] || "Unknown";
+    const contact = {
+      display_name: name,
+      emails: [{ address: p.email, type: "work", is_primary: true }],
+      source: "import"
+    };
+    if (sig.title)
+      contact.job_title = sig.title;
+    if (sig.phone)
+      contact.phones = [{ number: sig.phone, type: "work", is_primary: true }];
+    if (sig.linkedin)
+      contact.social_profiles = [{ platform: "linkedin", url: sig.linkedin, is_primary: true }];
+    if (sig.website)
+      contact.website = sig.website;
+    return contact;
+  });
+}
+
+// src/lib/meeting-capture.ts
+init_database();
+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 };
+}
+
+// src/db/freshness.ts
+init_database();
+var SCORED_FIELDS = ["display_name", "job_title", "company_id", "emails", "phones", "last_contacted_at"];
+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 * FROM (
+        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
+      ) WHERE 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());
+  }
+}
+
+// src/db/org-chart.ts
+init_database();
+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"
+  };
+}
+
+// src/lib/images.ts
+init_database();
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, unlinkSync, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join3, extname, basename } from "path";
+var IMAGES_DIR = join3(getDataDir(), "images");
+function ensureImagesDir() {
+  if (!existsSync3(IMAGES_DIR))
+    mkdirSync2(IMAGES_DIR, { recursive: true });
+}
+function saveImage(entityId, source, options) {
+  ensureImagesDir();
+  deleteImage(entityId);
+  const base64Match = source.match(/^data:image\/(\w+);base64,(.+)$/s);
+  if (base64Match) {
+    const ext2 = base64Match[1] === "jpeg" ? "jpg" : base64Match[1];
+    const data = Buffer.from(base64Match[2], "base64");
+    const filename2 = `${entityId}.${ext2}`;
+    writeFileSync(join3(IMAGES_DIR, filename2), data);
+    return filename2;
+  }
+  if (!existsSync3(source) && /^[A-Za-z0-9+/=\n\r]+$/.test(source.trim()) && source.length > 100) {
+    const ext2 = options?.format || "jpg";
+    const data = Buffer.from(source.trim(), "base64");
+    const filename2 = `${entityId}.${ext2}`;
+    writeFileSync(join3(IMAGES_DIR, filename2), data);
+    return filename2;
+  }
+  if (!existsSync3(source)) {
+    throw new Error(`Image file not found: ${source}`);
+  }
+  const ext = extname(source).slice(1).toLowerCase() || "jpg";
+  const validExts = ["jpg", "jpeg", "png", "gif", "webp", "svg", "avif", "ico"];
+  if (!validExts.includes(ext)) {
+    throw new Error(`Unsupported image format: ${ext}. Supported: ${validExts.join(", ")}`);
+  }
+  const filename = `${entityId}.${ext === "jpeg" ? "jpg" : ext}`;
+  copyFileSync2(source, join3(IMAGES_DIR, filename));
+  return filename;
+}
+function getImagePath(entityId) {
+  ensureImagesDir();
+  const files = readdirSync2(IMAGES_DIR);
+  const match = files.find((f) => f.startsWith(`${entityId}.`));
+  return match ? join3(IMAGES_DIR, match) : null;
+}
+function getImageAsBase64(entityId) {
+  const path = getImagePath(entityId);
+  if (!path)
+    return null;
+  const ext = extname(path).slice(1);
+  const mime = ext === "jpg" ? "image/jpeg" : ext === "svg" ? "image/svg+xml" : `image/${ext}`;
+  const data = readFileSync2(path);
+  return `data:${mime};base64,${data.toString("base64")}`;
+}
+function deleteImage(entityId) {
+  ensureImagesDir();
+  const files = readdirSync2(IMAGES_DIR);
+  let deleted = false;
+  for (const f of files) {
+    if (f.startsWith(`${entityId}.`)) {
+      unlinkSync(join3(IMAGES_DIR, f));
+      deleted = true;
+    }
+  }
+  return deleted;
+}
+
+// src/lib/vault.ts
+init_database();
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join4 } from "path";
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync, createHash } from "crypto";
+var VAULT_DIR = getDataDir();
+var VAULT_CONFIG = join4(VAULT_DIR, "vault.json");
+var VAULT_SESSION = join4(VAULT_DIR, ".vault-session");
+var DOCUMENTS_DIR = join4(VAULT_DIR, "documents");
+var SESSION_TTL_MS = 30 * 60 * 1000;
+var _derivedKey = null;
+function deriveKey(passphrase, salt) {
+  return pbkdf2Sync(passphrase, salt, 1e5, 32, "sha512");
+}
+function saveSession(key) {
+  const session = {
+    key: key.toString("hex"),
+    expires_at: new Date(Date.now() + SESSION_TTL_MS).toISOString()
+  };
+  writeFileSync2(VAULT_SESSION, JSON.stringify(session), { mode: 384 });
+}
+function loadSession() {
+  if (!existsSync4(VAULT_SESSION))
+    return null;
+  try {
+    const session = JSON.parse(readFileSync3(VAULT_SESSION, "utf-8"));
+    if (new Date(session.expires_at).getTime() < Date.now()) {
+      try {
+        unlinkSync2(VAULT_SESSION);
+      } catch {}
+      return null;
+    }
+    return Buffer.from(session.key, "hex");
+  } catch {
+    return null;
+  }
+}
+function clearSession() {
+  try {
+    if (existsSync4(VAULT_SESSION))
+      unlinkSync2(VAULT_SESSION);
+  } catch {}
+}
+function initVault(passphrase) {
+  if (!existsSync4(VAULT_DIR))
+    mkdirSync3(VAULT_DIR, { recursive: true });
+  if (!existsSync4(DOCUMENTS_DIR))
+    mkdirSync3(DOCUMENTS_DIR, { recursive: true });
+  const salt = randomBytes(32);
+  const key = deriveKey(passphrase, salt);
+  const keyHash = createHash("sha256").update(key).digest("hex");
+  const config = { salt: salt.toString("hex"), key_hash: keyHash, created_at: new Date().toISOString() };
+  writeFileSync2(VAULT_CONFIG, JSON.stringify(config, null, 2));
+  _derivedKey = key;
+  saveSession(key);
+}
+function isVaultInitialized() {
+  return existsSync4(VAULT_CONFIG);
+}
+function unlockVault(passphrase) {
+  if (!existsSync4(VAULT_CONFIG))
+    throw new Error("Vault not initialized. Run 'contacts vault init' first.");
+  const config = JSON.parse(readFileSync3(VAULT_CONFIG, "utf-8"));
+  const salt = Buffer.from(config.salt, "hex");
+  const key = deriveKey(passphrase, salt);
+  const keyHash = createHash("sha256").update(key).digest("hex");
+  if (keyHash !== config.key_hash)
+    return false;
+  _derivedKey = key;
+  saveSession(key);
+  return true;
+}
+function lockVault() {
+  _derivedKey = null;
+  clearSession();
+}
+function isVaultUnlocked() {
+  if (_derivedKey)
+    return true;
+  const sessionKey = loadSession();
+  if (sessionKey) {
+    _derivedKey = sessionKey;
+    return true;
+  }
+  return false;
+}
+function requireVault() {
+  if (_derivedKey)
+    return _derivedKey;
+  const sessionKey = loadSession();
+  if (sessionKey) {
+    _derivedKey = sessionKey;
+    return _derivedKey;
+  }
+  throw new Error("Vault is locked. Unlock with 'contacts vault unlock --passphrase <pass>' or vault_unlock MCP tool first.");
+}
+function encrypt(plaintext) {
+  const key = requireVault();
+  const iv = randomBytes(16);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  let encrypted = cipher.update(plaintext, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const authTag = cipher.getAuthTag().toString("hex");
+  return { ciphertext: encrypted + ":" + authTag, iv: iv.toString("hex") };
+}
+function decrypt(ciphertext, iv) {
+  const key = requireVault();
+  const [encData, authTag] = ciphertext.split(":");
+  if (!encData || !authTag)
+    throw new Error("Invalid ciphertext format");
+  const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "hex"));
+  decipher.setAuthTag(Buffer.from(authTag, "hex"));
+  let decrypted = decipher.update(encData, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function storeFile(sourcePath, entityId) {
+  if (!existsSync4(DOCUMENTS_DIR))
+    mkdirSync3(DOCUMENTS_DIR, { recursive: true });
+  const ext = sourcePath.split(".").pop() || "bin";
+  const destPath = join4(DOCUMENTS_DIR, `${entityId}.${ext}`);
+  const data = readFileSync3(sourcePath);
+  writeFileSync2(destPath, data);
+  return destPath;
+}
+
+// src/db/documents.ts
+init_database();
+import { existsSync as existsSync5, unlinkSync as unlinkSync3 } from "fs";
+var DOCUMENT_TYPES = [
+  "passport",
+  "national_id",
+  "tax_id",
+  "ssn",
+  "drivers_license",
+  "bank_account",
+  "visa",
+  "insurance",
+  "contract",
+  "certificate",
+  "medical_record",
+  "prescription",
+  "allergy_list",
+  "vaccination",
+  "blood_type",
+  "health_insurance",
+  "medical_condition",
+  "emergency_contact_medical",
+  "other"
+];
+function addDocument(input, db) {
+  requireVault();
+  const _db2 = db || getDatabase();
+  const id = uuid();
+  const { ciphertext, iv } = encrypt(input.value);
+  let filePath = null;
+  if (input.file_path) {
+    filePath = storeFile(input.file_path, id);
+  }
+  _db2.query(`INSERT INTO contact_documents (id, contact_id, doc_type, label, encrypted_value, iv, encrypted_file_path, metadata, expires_at, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)`).run(id, input.contact_id, input.doc_type, input.label ?? null, ciphertext, iv, filePath, JSON.stringify(input.metadata || {}), input.expires_at ?? null, now(), now());
+  return getDocument(id, _db2);
+}
+function getDocument(id, db) {
+  requireVault();
+  const _db2 = db || getDatabase();
+  const row = _db2.query(`SELECT * FROM contact_documents WHERE id = ?`).get(id);
+  if (!row)
+    throw new Error(`Document not found: ${id}`);
+  return rowToDoc(row);
+}
+function listDocuments(contactId, db) {
+  const _db2 = db || getDatabase();
+  const rows = _db2.query(`SELECT id, doc_type, label, encrypted_file_path, expires_at, created_at FROM contact_documents WHERE contact_id = ? ORDER BY created_at DESC`).all(contactId);
+  return rows.map((r) => ({
+    id: r.id,
+    doc_type: r.doc_type,
+    label: r.label,
+    has_file: !!r.encrypted_file_path,
+    expires_at: r.expires_at,
+    created_at: r.created_at
+  }));
+}
+function deleteDocument(id, db) {
+  const _db2 = db || getDatabase();
+  const row = _db2.query(`SELECT encrypted_file_path FROM contact_documents WHERE id = ?`).get(id);
+  if (row?.encrypted_file_path && existsSync5(row.encrypted_file_path)) {
+    try {
+      unlinkSync3(row.encrypted_file_path);
+    } catch {}
+  }
+  _db2.query(`DELETE FROM contact_documents WHERE id = ?`).run(id);
+}
+function rowToDoc(row) {
+  return {
+    id: row.id,
+    contact_id: row.contact_id,
+    doc_type: row.doc_type,
+    label: row.label,
+    value: decrypt(row.encrypted_value, row.iv),
+    has_file: !!row.encrypted_file_path,
+    file_path: row.encrypted_file_path,
+    metadata: JSON.parse(row.metadata || "{}"),
+    expires_at: row.expires_at,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+
+// src/db/health.ts
+init_database();
+function setHealthData(contactId, input, db) {
+  requireVault();
+  const _db2 = db || getDatabase();
+  const existing = _db2.query(`SELECT id FROM contact_health WHERE contact_id = ?`).get(contactId);
+  if (existing) {
+    const sets = [];
+    const params = [];
+    if (input.blood_type !== undefined) {
+      sets.push("blood_type = ?");
+      params.push(input.blood_type);
+    }
+    if (input.allergies !== undefined) {
+      sets.push("allergies = ?");
+      params.push(JSON.stringify(input.allergies));
+    }
+    if (input.medical_conditions !== undefined) {
+      sets.push("medical_conditions = ?");
+      params.push(JSON.stringify(input.medical_conditions));
+    }
+    if (input.medications !== undefined) {
+      sets.push("medications = ?");
+      params.push(JSON.stringify(input.medications));
+    }
+    if (input.emergency_contacts !== undefined) {
+      sets.push("emergency_contacts = ?");
+      params.push(JSON.stringify(input.emergency_contacts));
+    }
+    if (input.health_insurance_provider !== undefined) {
+      sets.push("health_insurance_provider = ?");
+      params.push(input.health_insurance_provider);
+    }
+    if (input.health_insurance_id !== undefined) {
+      sets.push("health_insurance_id = ?");
+      params.push(input.health_insurance_id);
+    }
+    if (input.primary_physician !== undefined) {
+      sets.push("primary_physician = ?");
+      params.push(input.primary_physician);
+    }
+    if (input.primary_physician_phone !== undefined) {
+      sets.push("primary_physician_phone = ?");
+      params.push(input.primary_physician_phone);
+    }
+    if (input.organ_donor !== undefined) {
+      sets.push("organ_donor = ?");
+      params.push(input.organ_donor ? 1 : 0);
+    }
+    if (input.notes !== undefined) {
+      sets.push("notes = ?");
+      params.push(input.notes);
+    }
+    if (sets.length) {
+      sets.push("updated_at = ?");
+      params.push(now());
+      params.push(contactId);
+      _db2.query(`UPDATE contact_health SET ${sets.join(", ")} WHERE contact_id = ?`).run(...params);
+    }
+  } else {
+    const id = uuid();
+    _db2.query(`INSERT INTO contact_health (id, contact_id, blood_type, allergies, medical_conditions, medications, emergency_contacts, health_insurance_provider, health_insurance_id, primary_physician, primary_physician_phone, organ_donor, notes, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(id, contactId, input.blood_type ?? null, JSON.stringify(input.allergies || []), JSON.stringify(input.medical_conditions || []), JSON.stringify(input.medications || []), JSON.stringify(input.emergency_contacts || []), input.health_insurance_provider ?? null, input.health_insurance_id ?? null, input.primary_physician ?? null, input.primary_physician_phone ?? null, input.organ_donor ? 1 : 0, input.notes ?? null, now(), now());
+  }
+  return getHealthData(contactId, _db2);
+}
+function getHealthData(contactId, db) {
+  requireVault();
+  const _db2 = db || getDatabase();
+  const row = _db2.query(`SELECT * FROM contact_health WHERE contact_id = ?`).get(contactId);
+  if (!row)
+    return null;
+  return {
+    id: row.id,
+    contact_id: row.contact_id,
+    blood_type: row.blood_type,
+    allergies: JSON.parse(row.allergies || "[]"),
+    medical_conditions: JSON.parse(row.medical_conditions || "[]"),
+    medications: JSON.parse(row.medications || "[]"),
+    emergency_contacts: JSON.parse(row.emergency_contacts || "[]"),
+    health_insurance_provider: row.health_insurance_provider,
+    health_insurance_id: row.health_insurance_id,
+    primary_physician: row.primary_physician,
+    primary_physician_phone: row.primary_physician_phone,
+    organ_donor: !!row.organ_donor,
+    notes: row.notes,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function deleteHealthData(contactId, db) {
+  const _db2 = db || getDatabase();
+  _db2.query(`DELETE FROM contact_health WHERE contact_id = ?`).run(contactId);
+}
+
+// src/lib/document-scanner.ts
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
+import { extname as extname2 } from "path";
+async function scanDocument(imageSource, docType) {
+  const apiKey = process.env["OPENAI_API_KEY"];
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set. Set it in ~/.secrets or environment to use document scanning.");
+  }
+  let imageData;
+  if (imageSource.startsWith("data:image/")) {
+    imageData = imageSource;
+  } else if (existsSync6(imageSource)) {
+    const buffer = readFileSync4(imageSource);
+    const ext = extname2(imageSource).slice(1).toLowerCase();
+    const mime = ext === "jpg" || ext === "jpeg" ? "image/jpeg" : ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : ext === "gif" ? "image/gif" : "image/jpeg";
+    imageData = `data:${mime};base64,${buffer.toString("base64")}`;
+  } else if (/^[A-Za-z0-9+/=\n\r]+$/.test(imageSource.trim()) && imageSource.length > 100) {
+    imageData = `data:image/jpeg;base64,${imageSource.trim()}`;
+  } else {
+    throw new Error(`Image source not found or invalid: ${imageSource.slice(0, 50)}...`);
+  }
+  const typeHint = docType ? ` This is a ${docType} document.` : "";
+  const prompt = `Extract all text and structured data from this document image.${typeHint} Return a JSON object with these fields:
+- document_type: detected type (passport, national_id, drivers_license, tax_document, medical_record, prescription, insurance_card, bank_statement, visa, certificate, contract, other)
+- full_name: full name as shown
+- date_of_birth: in YYYY-MM-DD format if visible
+- document_number: main ID/document number
+- issuing_country: country code or name
+- issue_date: in YYYY-MM-DD format if visible
+- expiry_date: in YYYY-MM-DD format if visible
+- address: full address if visible
+- nationality: if visible
+- gender: if visible
+- mrz_code: Machine Readable Zone text if this is a passport/ID with MRZ
+- phone: any phone numbers visible
+- email: any email addresses visible
+- additional_fields: object with any other visible structured data
+- raw_text: all visible text transcribed
+
+Only include fields that are actually visible in the document. Return valid JSON only.`;
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "gpt-4o",
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: imageData, detail: "high" } }
+          ]
+        }
+      ],
+      max_tokens: 2000,
+      temperature: 0
+    })
+  });
+  if (!response.ok) {
+    const err = await response.text();
+    throw new Error(`OpenAI API error: ${response.status} \u2014 ${err}`);
+  }
+  const data = await response.json();
+  const content = data.choices?.[0]?.message?.content || "";
+  const jsonMatch = content.match(/```json\s*([\s\S]*?)```/) || content.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    return { fields: {}, raw_text: content, document_type: docType || "unknown", confidence: 0.3 };
+  }
+  try {
+    const parsed = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+    const { document_type, raw_text, additional_fields, ...mainFields } = parsed;
+    const fields = {};
+    for (const [k, v] of Object.entries(mainFields)) {
+      if (v && typeof v === "string")
+        fields[k] = v;
+    }
+    if (additional_fields && typeof additional_fields === "object") {
+      for (const [k, v] of Object.entries(additional_fields)) {
+        if (v && typeof v === "string")
+          fields[k] = v;
+      }
+    }
+    return {
+      fields,
+      raw_text: raw_text || content,
+      document_type: document_type || docType || "unknown",
+      confidence: Object.keys(fields).length > 3 ? 0.9 : Object.keys(fields).length > 0 ? 0.7 : 0.3
+    };
+  } catch {
+    return { fields: {}, raw_text: content, document_type: docType || "unknown", confidence: 0.3 };
+  }
+}
+
+// src/mcp/index.ts
+var server = new Server({ name: "contacts", version: "0.1.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     {
@@ -3433,7 +4799,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
             }
           },
           tag_ids: { type: "array", items: { type: "string" }, description: "Tag IDs to assign" },
-          source: { type: "string", enum: ["manual", "import", "linkedin", "github", "twitter", "email", "calendar", "crm", "other"] }
+          source: { type: "string", enum: ["manual", "import", "linkedin", "github", "twitter", "email", "calendar", "crm", "other"] },
+          sensitivity: { type: "string", enum: ["normal", "confidential", "restricted"], description: "Contact sensitivity level (default: normal)" }
         }
       }
     },
@@ -3469,6 +4836,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           project_id: { type: "string", description: "Primary project ID (single, null to clear)" },
           project_ids: { type: "array", items: { type: "string" }, description: "Replace all project links with this array of todos project IDs" },
           source: { type: "string", enum: ["manual", "import", "linkedin", "github", "twitter", "email", "calendar", "crm", "other"] },
+          sensitivity: { type: "string", enum: ["normal", "confidential", "restricted"] },
           emails_add: { type: "array", items: { type: "object", properties: { address: { type: "string" }, type: { type: "string" }, is_primary: { type: "boolean" } }, required: ["address"] }, description: "New email addresses to append (duplicates are skipped)" },
           phones_add: { type: "array", items: { type: "object", properties: { number: { type: "string" }, type: { type: "string" }, country_code: { type: "string" }, is_primary: { type: "boolean" } }, required: ["number"] }, description: "New phone numbers to append (duplicates are skipped)" }
         },
@@ -3497,6 +4865,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
           status: { type: "string", enum: ["active", "pending_reply", "converted", "closed", "other"] },
           project_id: { type: "string", description: "Filter by project ID" },
           archived: { type: "boolean", description: "Include archived contacts (default false)" },
+          include_restricted: { type: "boolean", description: "Include restricted-sensitivity contacts (default false)" },
           follow_up_due: { type: "boolean", description: "Only return contacts whose follow_up_at is in the past" },
           last_contacted_after: { type: "string", description: "ISO 8601 date \u2014 only contacts last contacted after this date" },
           last_contacted_before: { type: "string", description: "ISO 8601 date \u2014 only contacts last contacted before this date" },
@@ -4773,7 +6142,69 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         required: ["contact_id", "do_not_contact"]
       }
-    }
+    },
+    { name: "get_field_history", description: "Get the change history for one or all fields of a contact (temporal audit trail).", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, field_name: { type: "string", description: "Optional \u2014 filter to a single field" } }, required: ["contact_id"] } },
+    { name: "get_contact_at", description: "Reconstruct a contact's profile as it was at a specific point in time, using field history.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, timestamp: { type: "string", description: "ISO 8601 datetime \u2014 reconstruct profile at this point in time" } }, required: ["contact_id", "timestamp"] } },
+    { name: "get_job_history", description: "Get the employment timeline for a contact \u2014 all past and current job entries in reverse chronological order.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "add_job_entry", description: "Add a job history entry to a contact's employment timeline.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, company_name: { type: "string" }, title: { type: "string" }, start_date: { type: "string" }, end_date: { type: "string" }, is_current: { type: "boolean" } }, required: ["contact_id", "company_name"] } },
+    { name: "save_learning", description: "Save a structured learning about a contact \u2014 preferences, facts, inferences, warnings, or signals. Include confidence (0-100) and importance (1-10).", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, content: { type: "string" }, type: { type: "string", enum: ["preference", "fact", "inference", "warning", "signal"] }, confidence: { type: "number" }, importance: { type: "number" }, learned_by: { type: "string" }, visibility: { type: "string", enum: ["private", "shared", "human"] }, tags: { type: "array", items: { type: "string" } } }, required: ["contact_id", "content"] } },
+    { name: "get_learnings", description: "Get all learnings for a contact, optionally filtered by type and minimum importance.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, type: { type: "string", enum: ["preference", "fact", "inference", "warning", "signal"] }, min_importance: { type: "number" } }, required: ["contact_id"] } },
+    { name: "search_learnings", description: "Cross-contact search across all learnings for a keyword or phrase.", inputSchema: { type: "object", properties: { query: { type: "string" }, type: { type: "string" }, contact_id: { type: "string", description: "Optional \u2014 limit to a specific contact" } }, required: ["query"] } },
+    { name: "confirm_learning", description: "Confirm a learning as correct, boosting its confidence score.", inputSchema: { type: "object", properties: { learning_id: { type: "string" }, agent_name: { type: "string" } }, required: ["learning_id", "agent_name"] } },
+    { name: "get_stale_learnings", description: "Find learnings that haven't been confirmed recently and may need review.", inputSchema: { type: "object", properties: { days_old: { type: "number" }, min_confidence: { type: "number" } } } },
+    { name: "run_learning_maintenance", description: "Run decay (reduce confidence on old unconfirmed learnings) and contradiction detection across all learnings.", inputSchema: { type: "object", properties: {} } },
+    { name: "acquire_contact_lock", description: "Acquire a write lock on a contact to prevent conflicts when multiple agents edit the same record. Returns {acquired, lock, held_by}.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, agent_name: { type: "string" }, ttl_seconds: { type: "number" }, reason: { type: "string" }, session_id: { type: "string" } }, required: ["contact_id", "agent_name"] } },
+    { name: "release_contact_lock", description: "Release a contact write lock previously acquired by this agent.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, agent_name: { type: "string" } }, required: ["contact_id", "agent_name"] } },
+    { name: "check_contact_lock", description: "Check if a contact is currently locked by any agent.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "log_agent_activity", description: "Log an agent action against a contact for audit/coordination purposes.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, agent_name: { type: "string" }, action: { type: "string" }, details: { type: "string" }, session_id: { type: "string" } }, required: ["contact_id", "agent_name", "action"] } },
+    { name: "get_contact_agent_activity", description: "Get the recent agent activity log for a contact.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, limit: { type: "number" } }, required: ["contact_id"] } },
+    { name: "get_relationship_strength", description: "Compute and return the relationship strength score (0-100) for a contact based on interaction frequency and recency.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "find_warm_path", description: "Find the shortest warm introduction path between two contacts through the relationship graph.", inputSchema: { type: "object", properties: { from_contact_id: { type: "string" }, to_contact_id: { type: "string" } }, required: ["from_contact_id", "to_contact_id"] } },
+    { name: "find_connections_at_company", description: "Find all contacts linked to a specific company, with relationship strength scores.", inputSchema: { type: "object", properties: { company_id: { type: "string" } }, required: ["company_id"] } },
+    { name: "get_cooling_relationships", description: "Get all relationships that are cooling (no contact in 45+ days) \u2014 use to prioritize re-engagement outreach.", inputSchema: { type: "object", properties: {} } },
+    { name: "resolve_contact_identity", description: "Resolve a contact's identity from partial signals (email, name, LinkedIn URL, phone, or external system ID). Returns ranked matches with confidence scores.", inputSchema: { type: "object", properties: { email: { type: "string" }, name: { type: "string" }, linkedin_url: { type: "string" }, phone: { type: "string" }, system: { type: "string" }, external_id: { type: "string" } } } },
+    { name: "add_contact_identity", description: "Register an external system identity (e.g. Salesforce ID, LinkedIn URL) for a contact.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, system: { type: "string" }, external_id: { type: "string" }, external_url: { type: "string" }, confidence: { type: "string", enum: ["verified", "inferred"] } }, required: ["contact_id", "system", "external_id"] } },
+    { name: "get_contact_identities", description: "Get all registered external system identities for a contact.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "semantic_search_contacts", description: "Search contacts by capability or context using TF-IDF semantic similarity \u2014 finds contacts based on meaning, not just keyword match.", inputSchema: { type: "object", properties: { query: { type: "string" }, limit: { type: "number" } }, required: ["query"] } },
+    { name: "embed_all_contacts", description: "Build TF-IDF embeddings for all contacts in the database \u2014 run once to enable semantic_search_contacts.", inputSchema: { type: "object", properties: {} } },
+    { name: "get_relationship_signals", description: "Get relationship health signals for a contact: warming/cooling/ghost/healthy status with reasons.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "get_ghost_contacts", description: "List contacts you haven't been in touch with for 180+ days \u2014 relationships at risk of becoming permanently cold.", inputSchema: { type: "object", properties: {} } },
+    { name: "get_warming_contacts", description: "List contacts with rising interaction frequency \u2014 relationships gaining momentum.", inputSchema: { type: "object", properties: {} } },
+    { name: "recompute_signals", description: "Recompute engagement_status for all contacts based on interaction counts and recency.", inputSchema: { type: "object", properties: {} } },
+    { name: "get_contact_card", description: "Get a minimal ~50-token contact summary: name, title, company, primary email and phone. Ideal for lists and agent context injection.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "assemble_context", description: "Assemble a multi-contact context package for meetings, deals, outreach, or research. Returns task-relevant briefs for each contact.", inputSchema: { type: "object", properties: { contact_ids: { type: "array", items: { type: "string" } }, format: { type: "string", enum: ["meeting_prep", "deal_review", "outreach", "research"] } }, required: ["contact_ids"] } },
+    { name: "parse_email_signature", description: "Parse an email signature text to extract contact fields (name, title, company, phone, email, LinkedIn, website). Does NOT create a contact.", inputSchema: { type: "object", properties: { signature_text: { type: "string" } }, required: ["signature_text"] } },
+    { name: "ingest_email_participants", description: "Find or create contacts from email thread participants (with optional signatures). Returns { created, updated, contacts }.", inputSchema: { type: "object", properties: { participants: { type: "array", items: { type: "object", properties: { name: { type: "string" }, email: { type: "string" }, signature: { type: "string" } }, required: ["email"] } }, context: { type: "string" } }, required: ["participants"] } },
+    { name: "ingest_meeting_participants", description: "Ingest meeting attendees: find-or-create contacts and log the meeting as an event. Returns { created, updated, contact_ids }.", inputSchema: { type: "object", properties: { title: { type: "string" }, event_date: { type: "string" }, attendees: { type: "array", items: { type: "object", properties: { name: { type: "string" }, email: { type: "string" } }, required: ["name", "email"] } }, context: { type: "string" } }, required: ["title", "event_date", "attendees"] } },
+    { name: "get_freshness_score", description: "Get a per-field freshness and confidence breakdown for a contact \u2014 shows which fields are verified, stale, or missing.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "get_stale_contacts", description: "List contacts with low data completeness scores (below threshold). Default threshold: 40.", inputSchema: { type: "object", properties: { threshold: { type: "number", description: "Score threshold 0-100 (default 40)" } } } },
+    { name: "mark_field_verified", description: "Mark a specific contact field as verified by a human or trusted source.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, field_name: { type: "string" }, source: { type: "string" } }, required: ["contact_id", "field_name"] } },
+    { name: "add_org_chart_edge", description: "Add a relationship edge to the org chart for a company (reports_to, manages, peer, collaborates_with).", inputSchema: { type: "object", properties: { company_id: { type: "string" }, contact_a_id: { type: "string" }, contact_b_id: { type: "string" }, edge_type: { type: "string", enum: ["reports_to", "manages", "collaborates_with", "peer"] } }, required: ["company_id", "contact_a_id", "contact_b_id", "edge_type"] } },
+    { name: "get_org_chart", description: "Get the org chart for a company as a list of directed edges with contact names.", inputSchema: { type: "object", properties: { company_id: { type: "string" } }, required: ["company_id"] } },
+    { name: "set_deal_contact_role", description: "Assign a contact a buying committee role in a deal (economic_buyer, technical_evaluator, champion, blocker, influencer, user, sponsor, other).", inputSchema: { type: "object", properties: { deal_id: { type: "string" }, contact_id: { type: "string" }, account_role: { type: "string", enum: ["economic_buyer", "technical_evaluator", "champion", "blocker", "influencer", "user", "sponsor", "other"] } }, required: ["deal_id", "contact_id", "account_role"] } },
+    { name: "get_deal_team", description: "Get the full buying committee for a deal with contact names and roles.", inputSchema: { type: "object", properties: { deal_id: { type: "string" } }, required: ["deal_id"] } },
+    { name: "get_coverage_gaps", description: "Identify coverage gaps in a company account \u2014 missing economic buyer, technical evaluator, or org chart relationships.", inputSchema: { type: "object", properties: { company_id: { type: "string" } }, required: ["company_id"] } },
+    { name: "get_recent_contact_events", description: "Polling fallback for change events \u2014 returns recent activity log entries, optionally filtered by event type or date.", inputSchema: { type: "object", properties: { since: { type: "string", description: "ISO 8601 datetime \u2014 only events after this date" }, event_types: { type: "array", items: { type: "string" } } } } },
+    { name: "set_contact_photo", description: "Set a contact's profile photo. Provide either a local file path or base64-encoded image data (with or without data URI prefix). Stores image in ~/.hasna/contacts/images/ and updates avatar_url. Supported formats: jpg, png, gif, webp, svg, avif.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, image: { type: "string", description: "File path (e.g. /tmp/photo.jpg) OR base64 data (e.g. data:image/png;base64,...) OR raw base64 string" }, format: { type: "string", description: "Image format hint when using raw base64 (jpg, png, webp). Not needed for file paths or data URIs." } }, required: ["contact_id", "image"] } },
+    { name: "get_contact_photo", description: "Get a contact's profile photo as base64 data URI. Returns null if no photo is set.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "delete_contact_photo", description: "Remove a contact's profile photo.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "set_company_logo", description: "Set a company's logo image. Provide either a local file path or base64-encoded image data. Stores image in ~/.hasna/contacts/images/ and updates logo_url.", inputSchema: { type: "object", properties: { company_id: { type: "string" }, image: { type: "string", description: "File path or base64 data" }, format: { type: "string", description: "Image format hint for raw base64" } }, required: ["company_id", "image"] } },
+    { name: "get_company_logo", description: "Get a company's logo as base64 data URI.", inputSchema: { type: "object", properties: { company_id: { type: "string" } }, required: ["company_id"] } },
+    { name: "delete_company_logo", description: "Remove a company's logo image.", inputSchema: { type: "object", properties: { company_id: { type: "string" } }, required: ["company_id"] } },
+    { name: "set_sensitivity", description: "Set a contact's sensitivity level (normal, confidential, restricted). Restricted contacts are hidden from list/search unless explicitly requested.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, sensitivity: { type: "string", enum: ["normal", "confidential", "restricted"] } }, required: ["contact_id", "sensitivity"] } },
+    { name: "vault_init", description: "Initialize the encrypted document vault with a passphrase. Must be called before storing documents or health data.", inputSchema: { type: "object", properties: { passphrase: { type: "string" } }, required: ["passphrase"] } },
+    { name: "vault_unlock", description: "Unlock the vault for this session with a passphrase.", inputSchema: { type: "object", properties: { passphrase: { type: "string" } }, required: ["passphrase"] } },
+    { name: "vault_lock", description: "Lock the vault, clearing the encryption key from memory.", inputSchema: { type: "object", properties: {} } },
+    { name: "vault_status", description: "Check vault initialization and lock status.", inputSchema: { type: "object", properties: {} } },
+    { name: "add_document", description: "Store a document for a contact (passport, tax_id, medical_record, etc.). Text values are encrypted; file attachments are stored plain so agents can read them. Vault must be unlocked.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, doc_type: { type: "string", enum: [...DOCUMENT_TYPES] }, label: { type: "string" }, value: { type: "string", description: "Plaintext value (will be encrypted in DB)" }, file_path: { type: "string", description: "File to attach \u2014 stored PLAIN in ~/.hasna/contacts/documents/ for agent access" }, metadata: { type: "object" }, expires_at: { type: "string" } }, required: ["contact_id", "doc_type", "value"] } },
+    { name: "list_documents", description: "List documents for a contact (metadata only \u2014 no decryption needed). Returns file_path for attachments so agents can read them directly.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "get_document", description: "Get a document with decrypted value and file_path. Vault must be unlocked for the text value; file is always accessible.", inputSchema: { type: "object", properties: { document_id: { type: "string" } }, required: ["document_id"] } },
+    { name: "get_document_file", description: "Get the plain file path for a document attachment. Agents can read this file directly \u2014 it is NOT encrypted. Returns null if no file attached.", inputSchema: { type: "object", properties: { document_id: { type: "string" } }, required: ["document_id"] } },
+    { name: "delete_document", description: "Delete a document and its file attachment.", inputSchema: { type: "object", properties: { document_id: { type: "string" } }, required: ["document_id"] } },
+    { name: "scan_document", description: "Scan a document image using AI vision (OpenAI GPT-4o) to extract structured data. Optionally auto-save to vault.", inputSchema: { type: "object", properties: { image: { type: "string", description: "File path or base64 image data" }, doc_type: { type: "string", description: "Hint: passport, national_id, drivers_license, etc." }, contact_id: { type: "string", description: "Contact to associate scanned document with" }, auto_save: { type: "boolean", description: "Automatically save extracted data as a vault document" } }, required: ["image"] } },
+    { name: "set_health_data", description: "Set or update health data for a contact. Vault must be unlocked.", inputSchema: { type: "object", properties: { contact_id: { type: "string" }, blood_type: { type: "string" }, allergies: { type: "array", items: { type: "string" } }, medical_conditions: { type: "array", items: { type: "string" } }, medications: { type: "array", items: { type: "string" } }, emergency_contacts: { type: "array", items: { type: "object", properties: { name: { type: "string" }, phone: { type: "string" }, relationship: { type: "string" } }, required: ["name", "phone", "relationship"] } }, health_insurance_provider: { type: "string" }, health_insurance_id: { type: "string" }, primary_physician: { type: "string" }, primary_physician_phone: { type: "string" }, organ_donor: { type: "boolean" }, notes: { type: "string" } }, required: ["contact_id"] } },
+    { name: "get_health_data", description: "Get health data for a contact. Vault must be unlocked.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } },
+    { name: "delete_health_data", description: "Delete all health data for a contact.", inputSchema: { type: "object", properties: { contact_id: { type: "string" } }, required: ["contact_id"] } }
   ]
 }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -4802,7 +6233,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           addresses: a.addresses,
           social_profiles: a.social_profiles,
           tag_ids: a.tag_ids,
-          source: a.source
+          source: a.source,
+          sensitivity: a.sensitivity
         };
         const contact = createContact(input);
         if (Array.isArray(a.project_ids) && a.project_ids.length > 0) {
@@ -4837,6 +6269,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           follow_up_at: rest.follow_up_at,
           project_id: rest.project_id,
           source: rest.source,
+          sensitivity: rest.sensitivity,
           emails_add: rest.emails_add,
           phones_add: rest.phones_add
         };
@@ -4860,6 +6293,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           status: a.status,
           project_id: a.project_id,
           archived: a.archived,
+          include_restricted: a.include_restricted,
           follow_up_due: a.follow_up_due,
           last_contacted_after: a.last_contacted_after,
           last_contacted_before: a.last_contacted_before,
@@ -5720,11 +7154,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const team = listCompanyRelationships({ company_id: a.company_id }, db);
         return { content: [{ type: "text", text: JSON.stringify({ company, team }, null, 2) }] };
       }
-      case "get_contact_brief": {
-        const db = getDatabase();
-        const brief = generateBrief(a.contact_id, db);
-        return { content: [{ type: "text", text: JSON.stringify({ brief }, null, 2) }] };
-      }
       case "list_cold_contacts": {
         const db = getDatabase();
         const contacts = listColdContacts(a.days ?? 30, db);
@@ -5972,6 +7401,447 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const output = await exportContacts(format, contactList);
         return { content: [{ type: "text", text: output }] };
       }
+      case "get_field_history": {
+        const db = getDatabase();
+        const history = getFieldHistory(a.contact_id, a.field_name, db);
+        return { content: [{ type: "text", text: JSON.stringify({ history }, null, 2) }] };
+      }
+      case "get_contact_at": {
+        const db = getDatabase();
+        const snapshot = getContactAt(a.contact_id, a.timestamp, db);
+        return { content: [{ type: "text", text: JSON.stringify({ contact_id: a.contact_id, timestamp: a.timestamp, snapshot }, null, 2) }] };
+      }
+      case "get_job_history": {
+        const db = getDatabase();
+        const history = getJobHistory(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ history }, null, 2) }] };
+      }
+      case "add_job_entry": {
+        const db = getDatabase();
+        const entry = addJobEntry(a.contact_id, {
+          company_name: a.company_name,
+          title: a.title,
+          start_date: a.start_date,
+          end_date: a.end_date,
+          is_current: a.is_current
+        }, db);
+        return { content: [{ type: "text", text: JSON.stringify(entry, null, 2) }] };
+      }
+      case "save_learning": {
+        const db = getDatabase();
+        const input = {
+          content: a.content,
+          type: a.type,
+          confidence: a.confidence,
+          importance: a.importance,
+          learned_by: a.learned_by,
+          visibility: a.visibility,
+          tags: a.tags
+        };
+        const learning = saveLearning(a.contact_id, input, db);
+        return { content: [{ type: "text", text: JSON.stringify(learning, null, 2) }] };
+      }
+      case "get_learnings": {
+        const db = getDatabase();
+        const learnings = getLearnings(a.contact_id, {
+          type: a.type,
+          min_importance: a.min_importance
+        }, db);
+        return { content: [{ type: "text", text: JSON.stringify({ learnings }, null, 2) }] };
+      }
+      case "search_learnings": {
+        const db = getDatabase();
+        const results = searchLearnings(a.query, {
+          type: a.type,
+          contact_id: a.contact_id
+        }, db);
+        return { content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }] };
+      }
+      case "confirm_learning": {
+        const db = getDatabase();
+        confirmLearning(a.learning_id, a.agent_name, db);
+        return { content: [{ type: "text", text: JSON.stringify({ confirmed: true }) }] };
+      }
+      case "get_stale_learnings": {
+        const db = getDatabase();
+        const daysOld = a.days_old ?? 30;
+        const minConf = a.min_confidence ?? 0;
+        const cutoff = new Date(Date.now() - daysOld * 86400000).toISOString();
+        const rows = db.query(`SELECT * FROM contact_learnings WHERE confirmed_count=0 AND created_at<? AND confidence>=? ORDER BY confidence ASC LIMIT 50`).all(cutoff, minConf);
+        return { content: [{ type: "text", text: JSON.stringify({ stale_learnings: rows }, null, 2) }] };
+      }
+      case "run_learning_maintenance": {
+        const db = getDatabase();
+        const decayed = decayLearnings(db);
+        const duplicates = db.query(`SELECT contact_id, COUNT(*) as cnt FROM contact_learnings GROUP BY contact_id, LOWER(SUBSTR(content,1,30)) HAVING cnt > 1`).all();
+        return { content: [{ type: "text", text: JSON.stringify({ decayed_count: decayed, potential_contradictions: duplicates }, null, 2) }] };
+      }
+      case "acquire_contact_lock": {
+        const db = getDatabase();
+        const result = acquireLock(a.contact_id, a.agent_name, a.ttl_seconds, a.reason, a.session_id, db);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "release_contact_lock": {
+        const db = getDatabase();
+        const released = releaseLock(a.contact_id, a.agent_name, db);
+        return { content: [{ type: "text", text: JSON.stringify({ released }, null, 2) }] };
+      }
+      case "check_contact_lock": {
+        const db = getDatabase();
+        const lock = checkLock(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ locked: !!lock, lock }, null, 2) }] };
+      }
+      case "log_agent_activity": {
+        const db = getDatabase();
+        logAgentActivity(a.contact_id, a.agent_name, a.action, a.details, a.session_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ logged: true }) }] };
+      }
+      case "get_contact_agent_activity": {
+        const db = getDatabase();
+        const activity = getAgentActivity(a.contact_id, a.limit ?? 20, db);
+        return { content: [{ type: "text", text: JSON.stringify({ activity }, null, 2) }] };
+      }
+      case "get_relationship_strength": {
+        const db = getDatabase();
+        const score = computeRelationshipStrength(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ contact_id: a.contact_id, strength_score: score }, null, 2) }] };
+      }
+      case "find_warm_path": {
+        const db = getDatabase();
+        const path = findWarmPath(a.from_contact_id, a.to_contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ path, hops: path.length }, null, 2) }] };
+      }
+      case "find_connections_at_company": {
+        const db = getDatabase();
+        const connections = findConnectionsAtCompany(a.company_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ connections }, null, 2) }] };
+      }
+      case "get_cooling_relationships": {
+        const db = getDatabase();
+        const cooling = detectCoolingRelationships(db);
+        return { content: [{ type: "text", text: JSON.stringify({ cooling }, null, 2) }] };
+      }
+      case "resolve_contact_identity": {
+        const db = getDatabase();
+        const matches = resolveByPartial({
+          email: a.email,
+          name: a.name,
+          linkedin_url: a.linkedin_url,
+          phone: a.phone
+        }, db);
+        return { content: [{ type: "text", text: JSON.stringify({ matches }, null, 2) }] };
+      }
+      case "add_contact_identity": {
+        const db = getDatabase();
+        const identity = addIdentity(a.contact_id, a.system, a.external_id, a.external_url, a.confidence ?? "inferred", db);
+        return { content: [{ type: "text", text: JSON.stringify(identity, null, 2) }] };
+      }
+      case "get_contact_identities": {
+        const db = getDatabase();
+        const identities = getIdentities(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ identities }, null, 2) }] };
+      }
+      case "semantic_search_contacts": {
+        const db = getDatabase();
+        const results = semanticSearch(a.query, a.limit ?? 10, db);
+        const enriched = results.map((r) => {
+          try {
+            return { ...r, contact: getContact(r.contact_id) };
+          } catch {
+            return r;
+          }
+        });
+        return { content: [{ type: "text", text: JSON.stringify({ results: enriched }, null, 2) }] };
+      }
+      case "embed_all_contacts": {
+        const db = getDatabase();
+        const count = await embedAllContacts(db);
+        return { content: [{ type: "text", text: JSON.stringify({ embedded: count }) }] };
+      }
+      case "get_relationship_signals": {
+        const db = getDatabase();
+        const signals = getRelationshipSignals(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ signals }, null, 2) }] };
+      }
+      case "get_ghost_contacts": {
+        const db = getDatabase();
+        const ghosts = getGhostContacts(db);
+        return { content: [{ type: "text", text: JSON.stringify({ ghosts }, null, 2) }] };
+      }
+      case "get_warming_contacts": {
+        const db = getDatabase();
+        const warming = getWarmingContacts(db);
+        return { content: [{ type: "text", text: JSON.stringify({ warming }, null, 2) }] };
+      }
+      case "recompute_signals": {
+        const db = getDatabase();
+        const result = recomputeAllSignals(db);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_contact_card": {
+        const db = getDatabase();
+        const card = getContactCard(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify(card, null, 2) }] };
+      }
+      case "get_contact_brief": {
+        const db = getDatabase();
+        const taskContext = a.task_context ?? a.format;
+        if (taskContext) {
+          const brief2 = getContactBrief(a.contact_id, taskContext, db);
+          return { content: [{ type: "text", text: JSON.stringify(brief2, null, 2) }] };
+        }
+        const brief = generateBrief(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ brief }, null, 2) }] };
+      }
+      case "assemble_context": {
+        const db = getDatabase();
+        const ctx = await assembleContext(a.contact_ids, a.format ?? "meeting_prep", db);
+        return { content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }] };
+      }
+      case "parse_email_signature": {
+        const parsed = parseEmailSignature(a.signature_text);
+        return { content: [{ type: "text", text: JSON.stringify(parsed, null, 2) }] };
+      }
+      case "ingest_email_participants": {
+        const db = getDatabase();
+        const participants = a.participants;
+        const extracted = extractContactsFromEmailThread(participants);
+        let created = 0;
+        let updated = 0;
+        const contacts = [];
+        const { findOrCreateContact: findOrCreate } = await Promise.resolve().then(() => (init_contacts(), exports_contacts));
+        for (const ci of extracted) {
+          try {
+            const result = await findOrCreate({
+              display_name: ci.display_name,
+              job_title: ci.job_title,
+              website: ci.website,
+              emails: ci.emails?.map((e) => ({ address: e.address, type: e.type, is_primary: e.is_primary })),
+              phones: ci.phones?.map((p) => ({ number: p.number, type: p.type, is_primary: p.is_primary })),
+              social_profiles: ci.social_profiles?.map((s) => ({ platform: "linkedin", url: s.url, is_primary: s.is_primary })),
+              source: "import"
+            }, db);
+            contacts.push(result.contact);
+            if (result.created)
+              created++;
+            else
+              updated++;
+          } catch {}
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ created, updated, contacts }, null, 2) }] };
+      }
+      case "ingest_meeting_participants": {
+        const db = getDatabase();
+        const result = await ingestMeetingParticipants({
+          title: a.title,
+          event_date: a.event_date,
+          attendees: a.attendees,
+          context: a.context
+        }, db);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "get_freshness_score": {
+        const db = getDatabase();
+        const score = getFreshnessScore(a.contact_id, db);
+        return { content: [{ type: "text", text: JSON.stringify(score, null, 2) }] };
+      }
+      case "get_stale_contacts": {
+        const db = getDatabase();
+        const contacts = getStaleContacts(a.threshold ?? 40, db);
+        return { content: [{ type: "text", text: JSON.stringify({ contacts }, null, 2) }] };
+      }
+      case "mark_field_verified": {
+        const db = getDatabase();
+        markFieldVerified(a.contact_id, a.field_name, a.source, db);
+        return { content: [{ type: "text", text: JSON.stringify({ verified: true }) }] };
+      }
+      case "add_org_chart_edge": {
+        const db = getDatabase();
+        const edge = addOrgChartEdge(a.company_id, a.contact_a_id, a.contact_b_id, a.edge_type, false, db);
+        return { content: [{ type: "text", text: JSON.stringify(edge, null, 2) }] };
+      }
+      case "get_org_chart": {
+        const db = getDatabase();
+        const edges = listOrgChart(a.company_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ company_id: a.company_id, edges }, null, 2) }] };
+      }
+      case "set_deal_contact_role": {
+        const db = getDatabase();
+        const role = setDealContactRole(a.deal_id, a.contact_id, a.account_role, db);
+        return { content: [{ type: "text", text: JSON.stringify(role, null, 2) }] };
+      }
+      case "get_deal_team": {
+        const db = getDatabase();
+        const team = getDealTeam(a.deal_id, db);
+        return { content: [{ type: "text", text: JSON.stringify({ deal_id: a.deal_id, team }, null, 2) }] };
+      }
+      case "get_coverage_gaps": {
+        const db = getDatabase();
+        const gaps = getCoverageGaps(a.company_id, db);
+        return { content: [{ type: "text", text: JSON.stringify(gaps, null, 2) }] };
+      }
+      case "get_recent_contact_events": {
+        const db = getDatabase();
+        const since = a.since;
+        const eventTypes = a.event_types;
+        let sql = `SELECT * FROM activity_log WHERE 1=1`;
+        const params = [];
+        if (since) {
+          sql += ` AND created_at >= ?`;
+          params.push(since);
+        }
+        if (eventTypes?.length) {
+          sql += ` AND action IN (${eventTypes.map(() => "?").join(",")})`;
+          params.push(...eventTypes);
+        }
+        sql += ` ORDER BY created_at DESC LIMIT 100`;
+        const events = db.query(sql).all(...params);
+        return { content: [{ type: "text", text: JSON.stringify({ events }, null, 2) }] };
+      }
+      case "set_contact_photo": {
+        const { contact_id, image, format } = a;
+        const contact = getContact(contact_id);
+        const filename = saveImage(contact_id, image, { format });
+        updateContact(contact_id, { avatar_url: `~/.hasna/contacts/images/${filename}` });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, contact_id, filename, avatar_url: `~/.hasna/contacts/images/${filename}` }) }] };
+      }
+      case "get_contact_photo": {
+        const { contact_id } = a;
+        const dataUri = getImageAsBase64(contact_id);
+        if (!dataUri)
+          return { content: [{ type: "text", text: JSON.stringify({ contact_id, has_photo: false, data: null }) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ contact_id, has_photo: true, data: dataUri }) }] };
+      }
+      case "delete_contact_photo": {
+        const { contact_id } = a;
+        const deleted = deleteImage(contact_id);
+        if (deleted)
+          updateContact(contact_id, { avatar_url: null });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, deleted }) }] };
+      }
+      case "set_company_logo": {
+        const { company_id, image, format } = a;
+        const co = getCompany(company_id);
+        const filename = saveImage(company_id, image, { format });
+        updateCompany(company_id, { logo_url: `~/.hasna/contacts/images/${filename}` });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, company_id, filename, logo_url: `~/.hasna/contacts/images/${filename}` }) }] };
+      }
+      case "get_company_logo": {
+        const { company_id } = a;
+        const dataUri = getImageAsBase64(company_id);
+        if (!dataUri)
+          return { content: [{ type: "text", text: JSON.stringify({ company_id, has_logo: false, data: null }) }] };
+        return { content: [{ type: "text", text: JSON.stringify({ company_id, has_logo: true, data: dataUri }) }] };
+      }
+      case "delete_company_logo": {
+        const { company_id } = a;
+        const deleted = deleteImage(company_id);
+        if (deleted)
+          updateCompany(company_id, { logo_url: null });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, deleted }) }] };
+      }
+      case "set_sensitivity": {
+        const contact = updateContact(a.contact_id, { sensitivity: a.sensitivity });
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, contact_id: a.contact_id, sensitivity: a.sensitivity }) }] };
+      }
+      case "vault_init": {
+        initVault(a.passphrase);
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, message: "Vault initialized and unlocked" }) }] };
+      }
+      case "vault_unlock": {
+        const ok = unlockVault(a.passphrase);
+        if (!ok)
+          return { content: [{ type: "text", text: "Invalid passphrase" }], isError: true };
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, message: "Vault unlocked" }) }] };
+      }
+      case "vault_lock": {
+        lockVault();
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true, message: "Vault locked" }) }] };
+      }
+      case "vault_status": {
+        const initialized = isVaultInitialized();
+        const unlocked = isVaultUnlocked();
+        const db = getDatabase();
+        let docCount = 0;
+        try {
+          docCount = db.query("SELECT COUNT(*) as n FROM contact_documents").get().n;
+        } catch {}
+        return { content: [{ type: "text", text: JSON.stringify({ initialized, unlocked, document_count: docCount }) }] };
+      }
+      case "add_document": {
+        const doc = addDocument({
+          contact_id: a.contact_id,
+          doc_type: a.doc_type,
+          label: a.label,
+          value: a.value,
+          file_path: a.file_path,
+          metadata: a.metadata,
+          expires_at: a.expires_at
+        });
+        return { content: [{ type: "text", text: JSON.stringify(doc, null, 2) }] };
+      }
+      case "list_documents": {
+        const docs = listDocuments(a.contact_id);
+        return { content: [{ type: "text", text: JSON.stringify(docs, null, 2) }] };
+      }
+      case "get_document": {
+        const doc = getDocument(a.document_id);
+        return { content: [{ type: "text", text: JSON.stringify(doc, null, 2) }] };
+      }
+      case "get_document_file": {
+        const db = getDatabase();
+        const row = db.query(`SELECT encrypted_file_path FROM contact_documents WHERE id = ?`).get(a.document_id);
+        if (!row)
+          return { content: [{ type: "text", text: JSON.stringify({ error: "Document not found" }) }], isError: true };
+        const filePath = row.encrypted_file_path;
+        return { content: [{ type: "text", text: JSON.stringify({ document_id: a.document_id, file_path: filePath, has_file: !!filePath }) }] };
+      }
+      case "delete_document": {
+        deleteDocument(a.document_id);
+        return { content: [{ type: "text", text: JSON.stringify({ deleted: true }) }] };
+      }
+      case "scan_document": {
+        const result = await scanDocument(a.image, a.doc_type);
+        if (a.auto_save && a.contact_id && isVaultUnlocked()) {
+          try {
+            const doc = addDocument({
+              contact_id: a.contact_id,
+              doc_type: result.document_type || "other",
+              label: `Scanned ${result.document_type}`,
+              value: JSON.stringify(result.fields),
+              metadata: { raw_text: result.raw_text, confidence: result.confidence }
+            });
+            return { content: [{ type: "text", text: JSON.stringify({ scan: result, saved_document: doc }, null, 2) }] };
+          } catch (saveErr) {
+            return { content: [{ type: "text", text: JSON.stringify({ scan: result, save_error: saveErr instanceof Error ? saveErr.message : String(saveErr) }, null, 2) }] };
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      }
+      case "set_health_data": {
+        const health = setHealthData(a.contact_id, {
+          blood_type: a.blood_type,
+          allergies: a.allergies,
+          medical_conditions: a.medical_conditions,
+          medications: a.medications,
+          emergency_contacts: a.emergency_contacts,
+          health_insurance_provider: a.health_insurance_provider,
+          health_insurance_id: a.health_insurance_id,
+          primary_physician: a.primary_physician,
+          primary_physician_phone: a.primary_physician_phone,
+          organ_donor: a.organ_donor,
+          notes: a.notes
+        });
+        return { content: [{ type: "text", text: JSON.stringify(health, null, 2) }] };
+      }
+      case "get_health_data": {
+        const health = getHealthData(a.contact_id);
+        return { content: [{ type: "text", text: JSON.stringify(health, null, 2) }] };
+      }
+      case "delete_health_data": {
+        deleteHealthData(a.contact_id);
+        return { content: [{ type: "text", text: JSON.stringify({ deleted: true }) }] };
+      }
       default:
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
     }