@hasna/contacts 0.6.22 → 0.6.23

package/dist/mcp/index.js

@@ -58,22 +58,44 @@ class SqliteAdapter {
 var init_sqlite_adapter = () => {};
 
 // src/db/database.ts
-import { copyFileSync, existsSync as existsSync2, mkdirSync, readdirSync, statSync } from "fs";
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync, readdirSync, statSync } from "fs";
 import { dirname, join as join2, resolve } from "path";
+function ensurePrivateDir(dir) {
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+}
+function ensureCreatedPrivateDir(dir) {
+  if (!existsSync2(dir))
+    mkdirSync(dir, { recursive: true, mode: 448 });
+}
+function protectDatabaseArtifacts(dbPath) {
+  if (dbPath === ":memory:")
+    return;
+  for (const artifact of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+    if (existsSync2(artifact))
+      chmodSync(artifact, 384);
+  }
+}
 function getDataDir() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  const hasnaDir = join2(home, ".hasna");
   const newDir = join2(home, ".hasna", "contacts");
   const oldDir = join2(home, ".contacts");
   if (existsSync2(oldDir) && !existsSync2(newDir)) {
-    mkdirSync(newDir, { recursive: true });
+    ensurePrivateDir(hasnaDir);
+    ensurePrivateDir(newDir);
     for (const file of readdirSync(oldDir)) {
       const oldPath = join2(oldDir, file);
       if (statSync(oldPath).isFile()) {
-        copyFileSync(oldPath, join2(newDir, file));
+        const newPath = join2(newDir, file);
+        copyFileSync(oldPath, newPath);
+        chmodSync(newPath, 384);
       }
     }
   }
-  mkdirSync(newDir, { recursive: true });
+  ensurePrivateDir(hasnaDir);
+  ensurePrivateDir(newDir);
   return newDir;
 }
 function getDbPath() {
@@ -87,8 +109,7 @@ function ensureDir(filePath) {
   if (filePath === ":memory:")
     return;
   const dir = dirname(resolve(filePath));
-  if (!existsSync2(dir))
-    mkdirSync(dir, { recursive: true });
+  ensureCreatedPrivateDir(dir);
 }
 function getDatabase(path) {
   if (_db)
@@ -99,6 +120,7 @@ function getDatabase(path) {
   db.exec("PRAGMA journal_mode=WAL");
   db.exec("PRAGMA foreign_keys=ON");
   runMigrations(db);
+  protectDatabaseArtifacts(dbPath);
   _db = db;
   return db;
 }
@@ -12032,60 +12054,1051 @@ function getStorageStatus(db = getDatabase()) {
   };
 }
 
-// src/mcp/storage-tools.ts
-function ok(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-function err(error) {
-  return {
-    content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
-    isError: true
-  };
-}
-function cloudStatus() {
-  return {
-    service: "contacts",
-    mode: "local",
-    remote_sync: {
-      configured: false,
-      reason: "Contacts no longer uses the deprecated shared cloud runtime. Use contacts-owned storage until repo-native remote sync is configured."
-    },
-    storage: getStorageStatus()
-  };
-}
-function unsupportedCloudSync(operation) {
-  return {
-    ok: false,
-    operation,
-    service: "contacts",
-    mode: "local",
-    error: "Repo-native contacts remote sync is not configured in this package yet.",
-    next: "Use contacts_storage_status to inspect local data."
-  };
-}
-function registerContactsStorageTools(server) {
-  server.tool("contacts_storage_status", "Show contacts-owned local database storage status", {}, async () => {
-    try {
-      return ok(getStorageStatus());
-    } catch (error) {
-      return err(error);
-    }
-  });
-  server.tool("contacts_cloud_status", "Compatibility status for contacts-owned storage and remote sync availability", {}, async () => {
-    try {
-      return ok(cloudStatus());
-    } catch (error) {
-      return err(error);
-    }
-  });
-  server.tool("contacts_cloud_push", "Report contacts remote push availability", { tables: exports_external.string().optional().describe("Accepted for compatibility; remote sync is not configured") }, async () => ({
-    content: [{ type: "text", text: JSON.stringify(unsupportedCloudSync("push"), null, 2) }],
-    isError: true
-  }));
-  server.tool("contacts_cloud_pull", "Report contacts remote pull availability", { tables: exports_external.string().optional().describe("Accepted for compatibility; remote sync is not configured") }, async () => ({
-    content: [{ type: "text", text: JSON.stringify(unsupportedCloudSync("pull"), null, 2) }],
-    isError: true
-  }));
+// src/db/remote-sync.ts
+init_database();
+
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS companies (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    domain TEXT,
+    logo_url TEXT,
+    description TEXT,
+    industry TEXT,
+    size TEXT,
+    founded_year INTEGER,
+    notes TEXT,
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS contacts (
+    id TEXT PRIMARY KEY,
+    first_name TEXT NOT NULL DEFAULT '',
+    last_name TEXT NOT NULL DEFAULT '',
+    display_name TEXT NOT NULL,
+    nickname TEXT,
+    avatar_url TEXT,
+    notes TEXT,
+    birthday TEXT,
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    job_title TEXT,
+    source TEXT NOT NULL DEFAULT 'manual',
+    custom_fields TEXT NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS tags (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    color TEXT NOT NULL DEFAULT '#6366f1',
+    description TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_tags (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (contact_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS company_tags (
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    tag_id TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (company_id, tag_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS emails (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    address TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'work' CHECK(type IN ('work','personal','other')),
+    is_primary BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS phones (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    number TEXT NOT NULL,
+    country_code TEXT,
+    type TEXT NOT NULL DEFAULT 'mobile' CHECK(type IN ('mobile','work','home','fax','whatsapp','other')),
+    is_primary BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS addresses (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'physical' CHECK(type IN ('physical','mailing','billing','virtual','other')),
+    street TEXT,
+    city TEXT,
+    state TEXT,
+    zip TEXT,
+    country TEXT,
+    is_primary BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS social_profiles (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    platform TEXT NOT NULL CHECK(platform IN ('twitter','linkedin','github','instagram','telegram','discord','youtube','tiktok','bluesky','facebook','whatsapp','snapchat','reddit','other')),
+    handle TEXT,
+    url TEXT,
+    is_primary BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_relationships (
+    id TEXT PRIMARY KEY,
+    contact_a_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    contact_b_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('colleague','friend','family','reports_to','mentor','investor','partner','client','vendor','other')),
+    notes TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS activity_log (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT REFERENCES companies(id) ON DELETE CASCADE,
+    action TEXT NOT NULL,
+    details TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS webhooks (
+    id TEXT PRIMARY KEY,
+    url TEXT NOT NULL,
+    events TEXT NOT NULL DEFAULT '["*"]',
+    secret TEXT,
+    active BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  -- Full-text search using PostgreSQL tsvector instead of FTS5
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS search_vector tsvector;
+  CREATE INDEX IF NOT EXISTS idx_contacts_search ON contacts USING GIN(search_vector);
+
+  CREATE OR REPLACE FUNCTION contacts_search_vector_update() RETURNS trigger AS $$
+  BEGIN
+    NEW.search_vector :=
+      setweight(to_tsvector('simple', COALESCE(NEW.display_name, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(NEW.first_name, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(NEW.last_name, '')), 'A') ||
+      setweight(to_tsvector('simple', COALESCE(NEW.nickname, '')), 'B') ||
+      setweight(to_tsvector('english', COALESCE(NEW.notes, '')), 'C') ||
+      setweight(to_tsvector('simple', COALESCE(NEW.job_title, '')), 'B');
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+
+  DROP TRIGGER IF EXISTS contacts_search_vector_trigger ON contacts;
+  CREATE TRIGGER contacts_search_vector_trigger
+    BEFORE INSERT OR UPDATE OF display_name, first_name, last_name, nickname, notes, job_title ON contacts
+    FOR EACH ROW EXECUTE FUNCTION contacts_search_vector_update();
+
+  -- Backfill
+  UPDATE contacts SET search_vector =
+    setweight(to_tsvector('simple', COALESCE(display_name, '')), 'A') ||
+    setweight(to_tsvector('simple', COALESCE(first_name, '')), 'A') ||
+    setweight(to_tsvector('simple', COALESCE(last_name, '')), 'A') ||
+    setweight(to_tsvector('simple', COALESCE(nickname, '')), 'B') ||
+    setweight(to_tsvector('english', COALESCE(notes, '')), 'C') ||
+    setweight(to_tsvector('simple', COALESCE(job_title, '')), 'B')
+  WHERE search_vector IS NULL;
+
+  CREATE TABLE IF NOT EXISTS _migrations (version INTEGER PRIMARY KEY);
+  INSERT INTO _migrations (version) VALUES (0) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS last_contacted_at TEXT;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS website TEXT;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS preferred_contact_method TEXT;
+
+  CREATE TABLE IF NOT EXISTS groups (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_groups (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
+    PRIMARY KEY (contact_id, group_id)
+  );
+
+  INSERT INTO _migrations (version) VALUES (1) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS status TEXT DEFAULT 'active';
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS follow_up_at TEXT;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS archived BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS project_id TEXT;
+  ALTER TABLE companies ADD COLUMN IF NOT EXISTS archived BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE companies ADD COLUMN IF NOT EXISTS project_id TEXT;
+
+  CREATE TABLE IF NOT EXISTS company_groups (
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE,
+    PRIMARY KEY (company_id, group_id)
+  );
+
+  INSERT INTO _migrations (version) VALUES (2) ON CONFLICT DO NOTHING;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS company_relationships (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('client','vendor','partner','employee','contractor','investor','advisor','other')),
+    notes TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_company_relationships_contact ON company_relationships(contact_id);
+  CREATE INDEX IF NOT EXISTS idx_company_relationships_company ON company_relationships(company_id);
+
+  INSERT INTO _migrations (version) VALUES (3) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE groups ADD COLUMN IF NOT EXISTS project_id TEXT;
+
+  CREATE TABLE IF NOT EXISTS contact_projects (
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    project_id TEXT NOT NULL,
+    PRIMARY KEY (contact_id, project_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_contact_projects_project ON contact_projects(project_id);
+  CREATE INDEX IF NOT EXISTS idx_contact_projects_contact ON contact_projects(contact_id);
+
+  INSERT INTO contact_projects (contact_id, project_id)
+  SELECT id, project_id FROM contacts WHERE project_id IS NOT NULL
+  ON CONFLICT DO NOTHING;
+
+  INSERT INTO _migrations (version) VALUES (4) ON CONFLICT DO NOTHING;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS contact_notes (
+    id TEXT PRIMARY KEY,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    body TEXT NOT NULL,
+    created_by TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_contact_notes_contact ON contact_notes(contact_id);
+
+  INSERT INTO _migrations (version) VALUES (5) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE companies ADD COLUMN IF NOT EXISTS is_owned_entity BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE companies ADD COLUMN IF NOT EXISTS entity_type TEXT CHECK(entity_type IN ('operating','holding','dissolved','nonprofit','trust','branch','other'));
+
+  ALTER TABLE company_relationships ADD COLUMN IF NOT EXISTS start_date TEXT;
+  ALTER TABLE company_relationships ADD COLUMN IF NOT EXISTS end_date TEXT;
+  ALTER TABLE company_relationships ADD COLUMN IF NOT EXISTS is_primary BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE company_relationships ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active','inactive','ended'));
+
+  CREATE TABLE IF NOT EXISTS org_members (
+    id TEXT PRIMARY KEY,
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    title TEXT,
+    specialization TEXT,
+    office_phone TEXT,
+    response_sla_hours INTEGER,
+    notes TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(company_id, contact_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS vendor_communications (
+    id TEXT PRIMARY KEY,
+    company_id TEXT NOT NULL REFERENCES companies(id) ON DELETE CASCADE,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE SET NULL,
+    comm_date TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'email' CHECK(type IN ('email','call','meeting','invoice_request','invoice_received','payment','dispute','other')),
+    direction TEXT NOT NULL DEFAULT 'outbound' CHECK(direction IN ('inbound','outbound')),
+    subject TEXT,
+    body TEXT,
+    status TEXT NOT NULL DEFAULT 'sent' CHECK(status IN ('sent','awaiting_response','responded','no_response','resolved')),
+    invoice_amount DOUBLE PRECISION,
+    invoice_currency TEXT,
+    invoice_ref TEXT,
+    follow_up_date TEXT,
+    follow_up_done BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS contact_tasks (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    description TEXT,
+    contact_id TEXT NOT NULL REFERENCES contacts(id) ON DELETE CASCADE,
+    assigned_by TEXT,
+    deadline TEXT,
+    status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending','awaiting_response','in_progress','completed','cancelled','escalated')),
+    priority TEXT NOT NULL DEFAULT 'medium' CHECK(priority IN ('low','medium','high','critical')),
+    entity_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    linked_todos_task_id TEXT,
+    escalation_rules TEXT NOT NULL DEFAULT '[]',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS applications (
+    id TEXT PRIMARY KEY,
+    program_name TEXT NOT NULL,
+    provider_company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    type TEXT NOT NULL DEFAULT 'other' CHECK(type IN ('ai_credits','grant','startup_program','visa','trademark','tax_filing','loan','other')),
+    value_usd DOUBLE PRECISION,
+    applicant_contact_id TEXT REFERENCES contacts(id) ON DELETE SET NULL,
+    primary_contact_id TEXT REFERENCES contacts(id) ON DELETE SET NULL,
+    status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('draft','submitted','pending','approved','rejected','follow_up_needed','expired','cancelled')),
+    submitted_date TEXT,
+    decision_date TEXT,
+    follow_up_date TEXT,
+    notes TEXT,
+    method TEXT CHECK(method IN ('email','form','typeform','hubspot','manual','browser','feathery','other')),
+    form_url TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  ALTER TABLE contact_notes ADD COLUMN IF NOT EXISTS company_id TEXT REFERENCES companies(id) ON DELETE SET NULL;
+
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (version) VALUES (6) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS do_not_contact BOOLEAN NOT NULL DEFAULT FALSE;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS priority INTEGER NOT NULL DEFAULT 3 CHECK(priority BETWEEN 1 AND 5);
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS timezone TEXT;
+
+  CREATE TABLE IF NOT EXISTS deals (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    contact_id TEXT REFERENCES contacts(id) ON DELETE SET NULL,
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    stage TEXT NOT NULL DEFAULT 'lead' CHECK(stage IN ('lead','qualified','proposal','negotiation','won','lost','cancelled')),
+    value_usd DOUBLE PRECISION,
+    currency TEXT NOT NULL DEFAULT 'USD',
+    close_date TEXT,
+    notes TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS events (
+    id TEXT PRIMARY KEY,
+    title TEXT NOT NULL,
+    type TEXT NOT NULL DEFAULT 'meeting' CHECK(type IN ('meeting','call','lunch','email','demo','conference','intro','other')),
+    event_date TEXT NOT NULL,
+    duration_min INTEGER,
+    contact_ids TEXT NOT NULL DEFAULT '[]',
+    company_id TEXT REFERENCES companies(id) ON DELETE SET NULL,
+    notes TEXT,
+    outcome TEXT,
+    deal_id TEXT REFERENCES deals(id) ON DELETE SET NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (version) VALUES (7) ON CONFLICT DO NOTHING;
+  `,
+  `
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    source TEXT,
+    confidence TEXT NOT NULL DEFAULT 'imported' CHECK(confidence IN ('verified','inferred','imported','stale')),
+    created_by TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  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 BOOLEAN NOT NULL DEFAULT FALSE,
+    inferred BOOLEAN NOT NULL DEFAULT FALSE,
+    source TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    expires_at TIMESTAMPTZ 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 TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  ALTER TABLE contact_relationships ADD COLUMN IF NOT EXISTS strength_score INTEGER NOT NULL DEFAULT 50;
+  ALTER TABLE contact_relationships ADD COLUMN IF NOT EXISTS interaction_count INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE contact_relationships ADD COLUMN IF NOT EXISTS last_interaction TEXT;
+  ALTER TABLE contact_relationships ADD COLUMN IF NOT EXISTS relationship_status TEXT NOT NULL DEFAULT 'stable' CHECK(relationship_status IN ('warming','stable','cooling','ghost'));
+
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(system, external_id)
+  );
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS canonical_id TEXT;
+
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS relationship_health INTEGER NOT NULL DEFAULT 50;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS avg_response_hours DOUBLE PRECISION;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS preferred_channel TEXT;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS engagement_status TEXT NOT NULL DEFAULT 'new' CHECK(engagement_status IN ('warming','stable','cooling','ghost','new'));
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS interaction_count_30d INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS interaction_count_90d INTEGER NOT NULL DEFAULT 0;
+
+  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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(contact_id, field_name)
+  );
+
+  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 BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT 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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    UNIQUE(deal_id, contact_id)
+  );
+
+  INSERT INTO _migrations (version) VALUES (8) ON CONFLICT DO NOTHING;
+  `,
+  `
+  ALTER TABLE contacts ADD COLUMN IF NOT EXISTS 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 TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT 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 BOOLEAN NOT NULL DEFAULT FALSE,
+    notes TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (version) VALUES (9) ON CONFLICT DO NOTHING;
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS feedback (
+    id TEXT PRIMARY KEY DEFAULT gen_random_uuid()::text,
+    message TEXT NOT NULL,
+    email TEXT,
+    category TEXT DEFAULT 'general',
+    version TEXT,
+    machine_id TEXT,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+  );
+
+  INSERT INTO _migrations (version) VALUES (10) ON CONFLICT DO NOTHING;
+  `
+];
+
+// src/db/remote-storage.ts
+import pg from "pg";
+var LOCAL_PG_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+function parsePgUrl(connectionString) {
+  try {
+    return new URL(connectionString);
+  } catch {
+    return;
+  }
+}
+function isLocalPgHost(hostname2) {
+  return LOCAL_PG_HOSTS.has(hostname2.replace(/^\[|\]$/g, ""));
+}
+function normalizedParams(url, name) {
+  return url.searchParams.getAll(name).map((value) => value.trim().toLowerCase());
+}
+function isFalseySslValue(value) {
+  return value === "0" || value === "false" || value === "no" || value === "disable" || value === "disabled";
+}
+function isTruthyValue(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function sanitizedConnectionString(url) {
+  for (const param of ["ssl", "sslmode", "uselibpqcompat"]) {
+    url.searchParams.delete(param);
+  }
+  return url.toString();
+}
+function buildPgPoolConfig(connectionString) {
+  const url = parsePgUrl(connectionString);
+  if (!url) {
+    return { connectionString, ssl: { rejectUnauthorized: true } };
+  }
+  const localHost = isLocalPgHost(url.hostname);
+  const sslModes = normalizedParams(url, "sslmode");
+  const sslParams = normalizedParams(url, "ssl");
+  const libpqCompatParams = normalizedParams(url, "uselibpqcompat");
+  const explicitTlsOff = sslModes.includes("disable") || sslParams.some(isFalseySslValue);
+  const weakTlsMode = sslModes.some((mode) => mode === "allow" || mode === "prefer" || mode === "no-verify");
+  const libpqCompatibility = libpqCompatParams.some(isTruthyValue);
+  const sanitized = sanitizedConnectionString(url);
+  if ((explicitTlsOff || weakTlsMode || libpqCompatibility) && !localHost) {
+    throw new Error("Remote contacts PostgreSQL storage must use verified TLS.");
+  }
+  if (localHost && (explicitTlsOff || sslModes.length === 0 && sslParams.length === 0)) {
+    return { connectionString: sanitized };
+  }
+  return { connectionString: sanitized, ssl: { rejectUnauthorized: true } };
+}
+function translatePlaceholders(sql) {
+  let index = 0;
+  return sql.replace(/\?/g, () => `$${++index}`);
+}
+function normalizeParams2(params) {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params;
+  return flat.map((value) => value === undefined ? null : value);
+}
+
+class PgAdapterAsync {
+  pool;
+  constructor(connectionString) {
+    this.pool = new pg.Pool(buildPgPoolConfig(connectionString));
+  }
+  async run(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams2(params));
+    return { changes: result.rowCount ?? 0 };
+  }
+  async get(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams2(params));
+    return result.rows[0] ?? null;
+  }
+  async all(sql, ...params) {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams2(params));
+    return result.rows;
+  }
+  async exec(sql) {
+    await this.pool.query(sql);
+  }
+  async close() {
+    await this.pool.end();
+  }
+}
+
+// src/db/remote-sync.ts
+var CONTACTS_REMOTE_TABLES = [
+  "companies",
+  "contacts",
+  "tags",
+  "contact_tags",
+  "company_tags",
+  "emails",
+  "phones",
+  "addresses",
+  "social_profiles",
+  "contact_relationships",
+  "activity_log",
+  "webhooks",
+  "groups",
+  "contact_groups",
+  "company_groups",
+  "company_relationships",
+  "contact_projects",
+  "contact_notes",
+  "org_members",
+  "vendor_communications",
+  "contact_tasks",
+  "applications",
+  "deals",
+  "events",
+  "contact_field_history",
+  "job_history",
+  "contact_learnings",
+  "contact_locks",
+  "contact_agent_activity",
+  "contact_identities",
+  "contact_field_confidence",
+  "org_chart_edges",
+  "deal_contact_roles",
+  "contact_embeddings",
+  "contact_documents",
+  "contact_health",
+  "feedback"
+];
+var CONTACTS_REMOTE_SENSITIVE_TABLES = [
+  "webhooks",
+  "contact_documents",
+  "contact_health"
+];
+var CONTACTS_REMOTE_DEFAULT_TABLES = CONTACTS_REMOTE_TABLES.filter((table) => !CONTACTS_REMOTE_SENSITIVE_TABLES.includes(table));
+var PRIMARY_KEYS = {
+  companies: ["id"],
+  contacts: ["id"],
+  tags: ["id"],
+  contact_tags: ["contact_id", "tag_id"],
+  company_tags: ["company_id", "tag_id"],
+  emails: ["id"],
+  phones: ["id"],
+  addresses: ["id"],
+  social_profiles: ["id"],
+  contact_relationships: ["id"],
+  activity_log: ["id"],
+  webhooks: ["id"],
+  groups: ["id"],
+  contact_groups: ["contact_id", "group_id"],
+  company_groups: ["company_id", "group_id"],
+  company_relationships: ["id"],
+  contact_projects: ["contact_id", "project_id"],
+  contact_notes: ["id"],
+  org_members: ["id"],
+  vendor_communications: ["id"],
+  contact_tasks: ["id"],
+  applications: ["id"],
+  deals: ["id"],
+  events: ["id"],
+  contact_field_history: ["id"],
+  job_history: ["id"],
+  contact_learnings: ["id"],
+  contact_locks: ["id"],
+  contact_agent_activity: ["id"],
+  contact_identities: ["id"],
+  contact_field_confidence: ["id"],
+  org_chart_edges: ["id"],
+  deal_contact_roles: ["id"],
+  contact_embeddings: ["contact_id"],
+  contact_documents: ["id"],
+  contact_health: ["id"],
+  feedback: ["id"]
+};
+var CONTACTS_REMOTE_ENV = [
+  "HASNA_CONTACTS_POSTGRES_URL",
+  "OPEN_CONTACTS_POSTGRES_URL",
+  "CONTACTS_POSTGRES_URL",
+  "HASNA_CONTACTS_DATABASE_URL",
+  "CONTACTS_DATABASE_URL"
+];
+
+class ContactsRemoteSyncError extends Error {
+  results;
+  constructor(message, results) {
+    super(message);
+    this.results = results;
+    this.name = "ContactsRemoteSyncError";
+  }
+}
+function getRemoteDatabaseUrl() {
+  for (const name of CONTACTS_REMOTE_ENV) {
+    const value = process.env[name];
+    if (value)
+      return value;
+  }
+  return null;
+}
+async function getRemotePg() {
+  const url = getRemoteDatabaseUrl();
+  if (!url)
+    throw new Error(`Missing contacts remote database URL. Set one of: ${CONTACTS_REMOTE_ENV.join(", ")}`);
+  return new PgAdapterAsync(url);
+}
+async function runRemoteMigrations(remote) {
+  await remote.run("CREATE EXTENSION IF NOT EXISTS pgcrypto");
+  for (const sql of PG_MIGRATIONS)
+    await remote.run(sql);
+}
+async function pushRemote(options) {
+  const remote = await getRemotePg();
+  const db = getDatabase();
+  try {
+    await runRemoteMigrations(remote);
+    const results = [];
+    for (const table of resolveRemoteTables(options?.tables))
+      results.push(await pushTable(db, remote, table));
+    recordSyncMeta(db, "push", results);
+    throwIfSyncErrors("push", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function pullRemote(options) {
+  const remote = await getRemotePg();
+  const db = getDatabase();
+  try {
+    await runRemoteMigrations(remote);
+    const results = [];
+    for (const table of resolveRemoteTables(options?.tables))
+      results.push(await pullTable(remote, db, table));
+    recordSyncMeta(db, "pull", results);
+    throwIfSyncErrors("pull", results);
+    return results;
+  } finally {
+    await remote.close();
+  }
+}
+async function syncRemote(options) {
+  const pull = await pullRemote(options);
+  const push = await pushRemote(options);
+  return { pull, push };
+}
+function getSyncMetaAll() {
+  const db = getDatabase();
+  ensureSyncMetaTable(db);
+  return db.query("SELECT table_name, last_synced_at, direction FROM _contacts_sync_meta ORDER BY table_name, direction").all();
+}
+function getRemoteStatus() {
+  return {
+    configured: Boolean(getRemoteDatabaseUrl()),
+    env: CONTACTS_REMOTE_ENV,
+    default_tables: CONTACTS_REMOTE_DEFAULT_TABLES,
+    sensitive_tables: CONTACTS_REMOTE_SENSITIVE_TABLES,
+    tables: CONTACTS_REMOTE_TABLES,
+    sync: getSyncMetaAll()
+  };
+}
+function resolveRemoteTables(tables) {
+  if (!tables || tables.length === 0)
+    return [...CONTACTS_REMOTE_DEFAULT_TABLES];
+  const allowed = new Set(CONTACTS_REMOTE_TABLES);
+  const requested = tables.map((table) => table.trim()).filter(Boolean);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown contacts sync table(s): ${invalid.join(", ")}`);
+  return requested;
+}
+async function pushTable(db, remote, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all();
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const remoteColumns = await getRemoteColumns(remote, table);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, rows, remoteColumns);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function pullTable(remote, db, table) {
+  const result = { table, rowsRead: 0, rowsWritten: 0, errors: [] };
+  try {
+    const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`);
+    result.rowsRead = rows.length;
+    if (rows.length === 0)
+      return result;
+    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, rows);
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}
+async function getRemoteColumns(remote, table) {
+  const rows = await remote.all("SELECT column_name, data_type FROM information_schema.columns WHERE table_schema = 'public' AND table_name = ?", table);
+  return new Map(rows.map((row) => [row.column_name, row.data_type]));
+}
+function filterRemoteColumns(remoteColumns, columns) {
+  if (remoteColumns.size === 0)
+    return columns;
+  return columns.filter((column) => remoteColumns.has(column));
+}
+function filterLocalColumns(db, table, columns) {
+  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all();
+  const allowed = new Set(rows.map((row) => row.name));
+  return columns.filter((column) => allowed.has(column));
+}
+async function upsertPg(remote, table, columns, rows, remoteColumns) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = EXCLUDED.${quoteIdent(fallbackKey)}`;
+  const whereClause = conflictWhereClause(table, columns, "EXCLUDED");
+  for (const row of rows) {
+    await remote.run(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders}) ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`, columns.map((column) => toPostgresValue(row[column], remoteColumns.get(column))));
+  }
+  return rows.length;
+}
+function upsertSqlite(db, table, columns, rows) {
+  if (columns.length === 0)
+    return 0;
+  const primaryKeys = PRIMARY_KEYS[table];
+  const columnList = columns.map(quoteIdent).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const keyList = primaryKeys.map(quoteIdent).join(", ");
+  const updateColumns = columns.filter((column) => !primaryKeys.includes(column));
+  const fallbackKey = primaryKeys[0];
+  const setClause = updateColumns.length > 0 ? updateColumns.map((column) => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ") : `${quoteIdent(fallbackKey)} = excluded.${quoteIdent(fallbackKey)}`;
+  const whereClause = conflictWhereClause(table, columns, "excluded");
+  const statement = db.prepare(`INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders}) ON CONFLICT (${keyList}) DO UPDATE SET ${setClause}${whereClause}`);
+  for (const row of rows) {
+    const values = columns.map((column) => normalizeSqliteSyncValue(row[column]));
+    statement.run(...values);
+  }
+  return rows.length;
+}
+function conflictWhereClause(table, columns, incomingAlias) {
+  const timestampColumn = columns.includes("updated_at") ? "updated_at" : columns.includes("created_at") ? "created_at" : null;
+  if (!timestampColumn)
+    return "";
+  const existing = `${quoteIdent(table)}.${quoteIdent(timestampColumn)}`;
+  const incoming = `${incomingAlias}.${quoteIdent(timestampColumn)}`;
+  return ` WHERE ${existing} IS NULL OR ${incoming} IS NULL OR ${incoming} >= ${existing}`;
+}
+function toPostgresValue(value, dataType) {
+  if (value === undefined)
+    return null;
+  if (dataType === "boolean") {
+    if (value === null)
+      return null;
+    if (typeof value === "number")
+      return value !== 0;
+    if (typeof value === "string")
+      return !["0", "false", "no", ""].includes(value.toLowerCase());
+    return Boolean(value);
+  }
+  return value;
+}
+function normalizeSqliteSyncValue(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (value instanceof Date)
+    return value.toISOString();
+  if (typeof value === "boolean")
+    return value ? 1 : 0;
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer)
+    return value;
+  if (typeof value === "object")
+    return JSON.stringify(value);
+  return value;
+}
+function ensureSyncMetaTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _contacts_sync_meta (
+      table_name TEXT NOT NULL,
+      direction TEXT NOT NULL CHECK(direction IN ('push','pull')),
+      last_synced_at TEXT NOT NULL,
+      PRIMARY KEY (table_name, direction)
+    )
+  `);
+}
+function recordSyncMeta(db, direction, results) {
+  ensureSyncMetaTable(db);
+  const now3 = new Date().toISOString();
+  const statement = db.prepare(`
+    INSERT INTO _contacts_sync_meta (table_name, direction, last_synced_at)
+    VALUES (?, ?, ?)
+    ON CONFLICT(table_name, direction) DO UPDATE SET last_synced_at = excluded.last_synced_at
+  `);
+  for (const result of results) {
+    if (result.errors.length === 0)
+      statement.run(result.table, direction, now3);
+  }
+}
+function throwIfSyncErrors(operation, results) {
+  const failures = results.filter((result) => result.errors.length > 0);
+  if (failures.length === 0)
+    return;
+  const details = failures.map((result) => `${result.table}: ${result.errors.join("; ")}`).join("; ");
+  throw new ContactsRemoteSyncError(`Contacts remote ${operation} failed for ${failures.length} table(s): ${details}`, results);
+}
+function quoteIdent(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+// src/mcp/storage-tools.ts
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function err(error) {
+  return {
+    content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+    isError: true
+  };
+}
+function cloudStatus() {
+  const remote = getRemoteStatus();
+  return {
+    service: "contacts",
+    mode: "local-first",
+    remote_sync: {
+      configured: Boolean(getRemoteDatabaseUrl()),
+      env: CONTACTS_REMOTE_ENV,
+      default_tables: remote.default_tables,
+      sensitive_tables: remote.sensitive_tables,
+      tables: CONTACTS_REMOTE_TABLES,
+      sync: remote.sync,
+      reason: getRemoteDatabaseUrl() ? "Contacts uses repo-owned PostgreSQL sync; the deprecated shared cloud runtime is not used." : "Set a contacts-owned PostgreSQL URL to enable sync; the deprecated shared cloud runtime is not used."
+    },
+    storage: getStorageStatus()
+  };
+}
+function parseTables(tables) {
+  if (!tables)
+    return;
+  return tables.split(",").map((table) => table.trim()).filter(Boolean);
+}
+function registerContactsStorageTools(server) {
+  server.tool("contacts_storage_status", "Show contacts-owned local database storage status", {}, async () => {
+    try {
+      return ok({ mode: "local-first", local: getStorageStatus(), remote: getRemoteStatus() });
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_storage_push", "Push local contacts data to contacts-owned PostgreSQL storage", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await pushRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_storage_pull", "Pull contacts data from contacts-owned PostgreSQL storage", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await pullRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_storage_sync", "Bidirectional contacts sync: pull then push", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await syncRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_cloud_status", "Compatibility status for contacts-owned storage and remote sync availability", {}, async () => {
+    try {
+      return ok(cloudStatus());
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_cloud_push", "Compatibility alias for contacts_storage_push", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await pushRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_cloud_pull", "Compatibility alias for contacts_storage_pull", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await pullRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+  server.tool("contacts_cloud_sync", "Compatibility alias for contacts_storage_sync", { tables: exports_external.string().optional().describe("Comma-separated table names") }, async ({ tables }) => {
+    try {
+      return ok(await syncRemote({ tables: parseTables(tables) }));
+    } catch (error) {
+      return err(error);
+    }
+  });
   server.tool("contacts_cloud_feedback", "Save contacts feedback locally", {
     message: exports_external.string().describe("Feedback message"),
     email: exports_external.string().optional().describe("Contact email")