@hasna/contacts 0.6.22 → 0.6.23

package/dist/cli/index.js

@@ -2178,22 +2178,44 @@ __export(exports_database, {
   getDatabase: () => getDatabase,
   getDataDir: () => getDataDir
 });
-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() {
@@ -2207,8 +2229,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)
@@ -2219,10 +2240,12 @@ function getDatabase(path) {
   db.exec("PRAGMA journal_mode=WAL");
   db.exec("PRAGMA foreign_keys=ON");
   runMigrations(db);
+  protectDatabaseArtifacts(dbPath);
   _db = db;
   return db;
 }
 function resetDatabase() {
+  _db?.close();
   _db = null;
 }
 function uuid() {
@@ -14653,241 +14676,1241 @@ var init_storage = __esm(() => {
   ];
 });
 
-// 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
-  }));
-  server.tool("contacts_cloud_feedback", "Save contacts feedback locally", {
-    message: exports_external.string().describe("Feedback message"),
-    email: exports_external.string().optional().describe("Contact email")
-  }, async ({ message, email }) => {
-    try {
-      return ok(saveLocalFeedback({ message, email, category: "general" }));
-    } catch (error) {
-      return err(error);
-    }
-  });
-}
-var init_storage_tools = __esm(() => {
-  init_zod();
-  init_feedback();
-  init_storage();
-});
+// src/db/pg-migrations.ts
+var PG_MIGRATIONS;
+var init_pg_migrations = __esm(() => {
+  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()
+  );
 
-// src/mcp/index.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-function getServerVersion() {
-  try {
-    const packageJsonPath = join7(import.meta.dir, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
-    return pkg.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-function buildServer() {
-  const server = new McpServer({ name: "contacts", version: getServerVersion() });
-  registerContactsTools(server);
-  registerContactsStorageTools(server);
-  return server;
-}
-async function main() {
-  const args = process.argv.slice(2);
-  if (isHttpMode(args)) {
-    startMcpHttpServer({
-      name: "contacts",
-      port: resolveMcpHttpPort(args),
-      buildServer
-    });
-    return;
-  }
-  const transport = new StdioServerTransport;
-  await buildServer().connect(transport);
-  console.error("Contacts MCP server running on stdio");
-}
-var isDirectRun;
-var init_mcp = __esm(() => {
-  init_register_tools();
-  init_storage_tools();
-  init_http();
-  isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp/index.ts") || process.argv[1]?.endsWith("mcp/index.js");
-  if (isDirectRun) {
-    main().catch((err2) => {
-      console.error("Fatal error:", err2);
-      process.exit(1);
-    });
-  }
-});
+  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()
+  );
 
-// src/server/serve.ts
-var exports_serve = {};
-__export(exports_serve, {
-  startServer: () => startServer
-});
-import { existsSync as existsSync9 } from "fs";
-import { join as join8 } from "path";
-function json3(data, status = 200) {
-  return new Response(JSON.stringify(data), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function apiError(message, status = 400) {
-  return json3({ error: message }, status);
-}
-async function parseJson(req) {
-  try {
-    return await req.json();
-  } catch {
-    return null;
-  }
-}
-function getSegments(url) {
-  return url.pathname.split("/").filter(Boolean);
-}
-async function handleContacts(req, url, segments) {
-  const method = req.method;
-  const id = segments[2];
-  if (method === "GET" && !id) {
-    const q = url.searchParams.get("q");
-    if (q) {
-      const contacts = searchContacts(q);
-      return json3(contacts);
-    }
-    const result = listContacts({
-      tag_id: url.searchParams.get("tag_id") ?? url.searchParams.get("tag") ?? undefined,
-      company_id: url.searchParams.get("company_id") ?? undefined,
-      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
-      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
-    });
-    return json3(result);
-  }
-  if (method === "POST" && !id) {
-    const body = await parseJson(req);
-    if (!body || typeof body !== "object")
-      return apiError("Invalid body");
-    try {
-      const contact = createContact(body);
-      return json3(contact, 201);
-    } catch (err2) {
-      return apiError(err2 instanceof Error ? err2.message : "Failed to create contact");
-    }
-  }
-  if (method === "GET" && id) {
-    try {
-      const contact = getContact(id);
-      return json3(contact);
-    } catch {
-      return apiError("Contact not found", 404);
-    }
-  }
-  if (method === "PATCH" && id) {
-    const body = await parseJson(req);
-    if (!body || typeof body !== "object")
-      return apiError("Invalid body");
-    try {
-      const contact = updateContact(id, body);
-      return json3(contact);
-    } catch {
-      return apiError("Contact not found", 404);
-    }
-  }
-  if (method === "DELETE" && id) {
-    try {
-      deleteContact(id);
-      return json3({ ok: true });
-    } catch {
-      return apiError("Contact not found", 404);
-    }
-  }
-  return apiError("Method not allowed", 405);
-}
-async function handleCompanies(req, url, segments) {
-  const method = req.method;
-  const id = segments[2];
-  if (method === "GET" && !id) {
-    const result = listCompanies({
-      tag_id: url.searchParams.get("tag_id") ?? undefined,
-      industry: url.searchParams.get("industry") ?? undefined,
-      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
-      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
-    });
-    return json3(result);
-  }
-  if (method === "POST" && !id) {
-    const body = await parseJson(req);
-    if (!body || typeof body !== "object")
-      return apiError("Invalid body");
-    try {
-      const company = createCompany(body);
-      return json3(company, 201);
-    } catch (err2) {
-      return apiError(err2 instanceof Error ? err2.message : "Failed to create company");
-    }
-  }
-  if (method === "GET" && id) {
-    const company = getCompany(id);
-    if (!company)
-      return apiError("Company not found", 404);
-    return json3(company);
-  }
-  if (method === "PATCH" && id) {
-    const body = await parseJson(req);
-    if (!body || typeof body !== "object")
-      return apiError("Invalid body");
+  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";
+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();
+  }
+}
+var LOCAL_PG_HOSTS;
+var init_remote_storage = __esm(() => {
+  LOCAL_PG_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+});
+
+// src/db/remote-sync.ts
+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 now4 = 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, now4);
+  }
+}
+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('"', '""')}"`;
+}
+var CONTACTS_REMOTE_TABLES, CONTACTS_REMOTE_SENSITIVE_TABLES, CONTACTS_REMOTE_DEFAULT_TABLES, PRIMARY_KEYS, CONTACTS_REMOTE_ENV, ContactsRemoteSyncError;
+var init_remote_sync = __esm(() => {
+  init_database();
+  init_pg_migrations();
+  init_remote_storage();
+  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"
+  ];
+  CONTACTS_REMOTE_SENSITIVE_TABLES = [
+    "webhooks",
+    "contact_documents",
+    "contact_health"
+  ];
+  CONTACTS_REMOTE_DEFAULT_TABLES = CONTACTS_REMOTE_TABLES.filter((table) => !CONTACTS_REMOTE_SENSITIVE_TABLES.includes(table));
+  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"]
+  };
+  CONTACTS_REMOTE_ENV = [
+    "HASNA_CONTACTS_POSTGRES_URL",
+    "OPEN_CONTACTS_POSTGRES_URL",
+    "CONTACTS_POSTGRES_URL",
+    "HASNA_CONTACTS_DATABASE_URL",
+    "CONTACTS_DATABASE_URL"
+  ];
+  ContactsRemoteSyncError = class ContactsRemoteSyncError extends Error {
+    results;
+    constructor(message, results) {
+      super(message);
+      this.results = results;
+      this.name = "ContactsRemoteSyncError";
+    }
+  };
+});
+
+// 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")
+  }, async ({ message, email }) => {
+    try {
+      return ok(saveLocalFeedback({ message, email, category: "general" }));
+    } catch (error) {
+      return err(error);
+    }
+  });
+}
+var init_storage_tools = __esm(() => {
+  init_zod();
+  init_feedback();
+  init_storage();
+  init_remote_sync();
+});
+
+// src/mcp/index.ts
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function getServerVersion() {
+  try {
+    const packageJsonPath = join7(import.meta.dir, "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync6(packageJsonPath, "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function buildServer() {
+  const server = new McpServer({ name: "contacts", version: getServerVersion() });
+  registerContactsTools(server);
+  registerContactsStorageTools(server);
+  return server;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  if (isHttpMode(args)) {
+    startMcpHttpServer({
+      name: "contacts",
+      port: resolveMcpHttpPort(args),
+      buildServer
+    });
+    return;
+  }
+  const transport = new StdioServerTransport;
+  await buildServer().connect(transport);
+  console.error("Contacts MCP server running on stdio");
+}
+var isDirectRun;
+var init_mcp = __esm(() => {
+  init_register_tools();
+  init_storage_tools();
+  init_http();
+  isDirectRun = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("mcp/index.ts") || process.argv[1]?.endsWith("mcp/index.js");
+  if (isDirectRun) {
+    main().catch((err2) => {
+      console.error("Fatal error:", err2);
+      process.exit(1);
+    });
+  }
+});
+
+// src/server/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  startServer: () => startServer
+});
+import { existsSync as existsSync9 } from "fs";
+import { join as join8 } from "path";
+function json3(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function apiError(message, status = 400) {
+  return json3({ error: message }, status);
+}
+async function parseJson(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
+function getSegments(url) {
+  return url.pathname.split("/").filter(Boolean);
+}
+async function handleContacts(req, url, segments) {
+  const method = req.method;
+  const id = segments[2];
+  if (method === "GET" && !id) {
+    const q = url.searchParams.get("q");
+    if (q) {
+      const contacts = searchContacts(q);
+      return json3(contacts);
+    }
+    const result = listContacts({
+      tag_id: url.searchParams.get("tag_id") ?? url.searchParams.get("tag") ?? undefined,
+      company_id: url.searchParams.get("company_id") ?? undefined,
+      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
+      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
+    });
+    return json3(result);
+  }
+  if (method === "POST" && !id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const contact = createContact(body);
+      return json3(contact, 201);
+    } catch (err2) {
+      return apiError(err2 instanceof Error ? err2.message : "Failed to create contact");
+    }
+  }
+  if (method === "GET" && id) {
+    try {
+      const contact = getContact(id);
+      return json3(contact);
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  if (method === "PATCH" && id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const contact = updateContact(id, body);
+      return json3(contact);
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  if (method === "DELETE" && id) {
+    try {
+      deleteContact(id);
+      return json3({ ok: true });
+    } catch {
+      return apiError("Contact not found", 404);
+    }
+  }
+  return apiError("Method not allowed", 405);
+}
+async function handleCompanies(req, url, segments) {
+  const method = req.method;
+  const id = segments[2];
+  if (method === "GET" && !id) {
+    const result = listCompanies({
+      tag_id: url.searchParams.get("tag_id") ?? undefined,
+      industry: url.searchParams.get("industry") ?? undefined,
+      limit: parseInt(url.searchParams.get("limit") ?? "50", 10),
+      offset: parseInt(url.searchParams.get("offset") ?? "0", 10)
+    });
+    return json3(result);
+  }
+  if (method === "POST" && !id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
+    try {
+      const company = createCompany(body);
+      return json3(company, 201);
+    } catch (err2) {
+      return apiError(err2 instanceof Error ? err2.message : "Failed to create company");
+    }
+  }
+  if (method === "GET" && id) {
+    const company = getCompany(id);
+    if (!company)
+      return apiError("Company not found", 404);
+    return json3(company);
+  }
+  if (method === "PATCH" && id) {
+    const body = await parseJson(req);
+    if (!body || typeof body !== "object")
+      return apiError("Invalid body");
     try {
       const company = updateCompany(id, body);
       return json3(company);
@@ -15860,7 +16883,7 @@ function readConfig() {
 }
 
 // src/cli/commands/core.tsx
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync10, copyFileSync as copyFileSync3, statSync as statSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync10, copyFileSync as copyFileSync3, statSync as statSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync3, chmodSync as chmodSync3 } from "fs";
 import { extname as extname3, join as join9 } from "path";
 
 // src/cli/utils.tsx
@@ -16634,8 +17657,7 @@ Group not found: ${groupId}
     console.log();
   });
   program2.command("backup").description("Backup the contacts database").option("--output <path>", "Output path").option("--list", "List existing backups").action((opts) => {
-    const { getDataDir: getDataDir2 } = (init_database(), __toCommonJS(exports_database));
-    const backupDir = join9(getDataDir2(), "backups");
+    const backupDir = join9(getDataDir(), "backups");
     if (opts.list) {
       if (!existsSync10(backupDir)) {
         console.log(chalk2.gray(`
@@ -16669,10 +17691,15 @@ Database not found: ${src}
 `));
       process.exit(1);
     }
-    mkdirSync5(backupDir, { recursive: true });
+    mkdirSync5(backupDir, { recursive: true, mode: 448 });
+    chmodSync3(backupDir, 448);
+    const db = getDatabase();
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+    resetDatabase();
     const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
     const dest = opts.output || join9(backupDir, `contacts-${ts}.db`);
     copyFileSync3(src, dest);
+    chmodSync3(dest, 384);
     const size = statSync2(dest).size;
     console.log(chalk2.green(`
 \u2713 Backed up to ${dest} (${(size / 1024).toFixed(1)} KB)
@@ -18347,49 +19374,99 @@ Health data cleared for ${contact.display_name}
 // src/cli/storage.ts
 init_storage();
 init_feedback();
+init_remote_sync();
 import chalk5 from "chalk";
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
 function printStorageStatus(json4) {
-  const status = getStorageStatus();
+  const status = {
+    mode: "local-first",
+    local: getStorageStatus(),
+    remote: getRemoteStatus()
+  };
   if (json4) {
     printJson(status);
     return;
   }
   console.log(`Mode: ${status.mode}`);
-  console.log(`Scope: ${chalk5.gray("local-only contacts storage")}`);
-  console.log(`Database: ${status.db_path}`);
-  for (const table of status.tables) {
+  console.log(`Scope: ${chalk5.gray("contacts-owned local SQLite with optional PostgreSQL sync")}`);
+  console.log(`Database: ${status.local.db_path}`);
+  console.log(`Remote sync: ${status.remote.configured ? chalk5.green("configured") : chalk5.yellow("not configured")}`);
+  for (const table of status.local.tables) {
     const value = table.ok ? String(table.rows) : chalk5.red(table.error ?? "unavailable");
     console.log(`  ${table.table}: ${value}`);
   }
 }
 function cloudStatus2() {
+  const remote = getRemoteStatus();
   return {
     service: "contacts",
-    mode: "local",
+    mode: "local-first",
     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."
+      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 printUnsupportedCloudSync(operation, json4) {
-  const payload = {
-    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."
-  };
-  if (json4)
-    printJson(payload);
-  else
-    console.error(payload.error);
-  process.exitCode = 1;
+function parseTables2(value) {
+  if (!value)
+    return;
+  return value.split(",").map((table) => table.trim()).filter(Boolean);
+}
+function printSyncResults(results, label) {
+  const total = results.reduce((sum, result) => sum + result.rowsWritten, 0);
+  for (const result of results) {
+    const errors2 = result.errors.length > 0 ? ` (${result.errors.join("; ")})` : "";
+    console.log(`  ${result.table}: ${result.rowsWritten}/${result.rowsRead} rows ${label}${errors2}`);
+  }
+  console.log(`Done. ${total} rows ${label}.`);
+}
+async function runSyncAction(action, json4, label) {
+  try {
+    const result = await action();
+    if (json4) {
+      printJson(result);
+      return;
+    }
+    if ("pull" in result) {
+      printSyncResults(result.pull, "pulled");
+      printSyncResults(result.push, "pushed");
+    } else {
+      printSyncResults(result, label);
+    }
+  } catch (error) {
+    const payload = {
+      ok: false,
+      service: "contacts",
+      mode: "local-first",
+      error: error instanceof Error ? error.message : String(error),
+      env: CONTACTS_REMOTE_ENV,
+      results: error instanceof ContactsRemoteSyncError ? error.results : undefined
+    };
+    if (json4)
+      printJson(payload);
+    else
+      console.error(payload.error);
+    process.exitCode = 1;
+  }
+}
+function addSyncCommands(command) {
+  command.command("push").description("Push local contacts data to contacts-owned PostgreSQL storage").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => pushRemote({ tables: parseTables2(opts.tables) }), opts.json, "pushed");
+  });
+  command.command("pull").description("Pull contacts data from contacts-owned PostgreSQL storage").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => pullRemote({ tables: parseTables2(opts.tables) }), opts.json, "pulled");
+  });
+  command.command("sync").description("Bidirectional contacts sync: pull then push").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => syncRemote({ tables: parseTables2(opts.tables) }), opts.json, "synced");
+  });
 }
 function registerCloudCompatibilityCommands(program2) {
   const cloud = program2.command("cloud").description("Compatibility commands for contacts-owned storage");
@@ -18401,15 +19478,18 @@ function registerCloudCompatibilityCommands(program2) {
     }
     console.log(`Mode: ${status.mode}`);
     console.log(`Service: ${status.service}`);
-    console.log(`Remote sync: ${chalk5.yellow("not configured")}`);
+    console.log(`Remote sync: ${status.remote_sync.configured ? chalk5.green("configured") : chalk5.yellow("not configured")}`);
     console.log(`Reason: ${status.remote_sync.reason}`);
     console.log(`Database: ${status.storage.db_path}`);
   });
-  cloud.command("push").description("Report remote push availability").option("--tables <tables>", "Accepted for compatibility; remote sync is not configured").option("--json", "Output as JSON").action((opts) => {
-    printUnsupportedCloudSync("push", opts.json);
+  cloud.command("push").description("Compatibility alias for contacts storage push").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => pushRemote({ tables: parseTables2(opts.tables) }), opts.json, "pushed");
+  });
+  cloud.command("pull").description("Compatibility alias for contacts storage pull").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => pullRemote({ tables: parseTables2(opts.tables) }), opts.json, "pulled");
   });
-  cloud.command("pull").description("Report remote pull availability").option("--tables <tables>", "Accepted for compatibility; remote sync is not configured").option("--json", "Output as JSON").action((opts) => {
-    printUnsupportedCloudSync("pull", opts.json);
+  cloud.command("sync").description("Compatibility alias for contacts storage sync").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+    await runSyncAction(() => syncRemote({ tables: parseTables2(opts.tables) }), opts.json, "synced");
   });
   cloud.command("feedback").description("Save feedback locally").requiredOption("--message <msg>", "Feedback message").option("--email <email>", "Contact email").option("--json", "Output as JSON").action((opts) => {
     const result = saveLocalFeedback({ message: opts.message, email: opts.email, category: "general" });
@@ -18425,6 +19505,7 @@ function registerStorageCommands(program2) {
   storage.command("status").description("Show local contacts database storage status").option("--json", "Output as JSON").action((opts) => {
     printStorageStatus(opts.json);
   });
+  addSyncCommands(storage);
   registerCloudCompatibilityCommands(program2);
 }