@dzhng/crm.cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,4291 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/db.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+import { createClient } from "@libsql/client";
+import { sql as sql2 } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/libsql";
+
+// src/drizzle-schema.ts
+var exports_drizzle_schema = {};
+__export(exports_drizzle_schema, {
+  deals: () => deals,
+  contacts: () => contacts,
+  companies: () => companies,
+  activities: () => activities
+});
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+var contacts = sqliteTable("contacts", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  emails: text("emails").notNull().default("[]"),
+  phones: text("phones").notNull().default("[]"),
+  companies: text("companies").notNull().default("[]"),
+  linkedin: text("linkedin"),
+  x: text("x"),
+  bluesky: text("bluesky"),
+  telegram: text("telegram"),
+  tags: text("tags").notNull().default("[]"),
+  custom_fields: text("custom_fields").notNull().default("{}"),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+});
+var companies = sqliteTable("companies", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  websites: text("websites").notNull().default("[]"),
+  phones: text("phones").notNull().default("[]"),
+  tags: text("tags").notNull().default("[]"),
+  custom_fields: text("custom_fields").notNull().default("{}"),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+});
+var deals = sqliteTable("deals", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  value: integer("value"),
+  stage: text("stage").notNull(),
+  contacts: text("contacts").notNull().default("[]"),
+  company: text("company"),
+  expected_close: text("expected_close"),
+  probability: integer("probability"),
+  tags: text("tags").notNull().default("[]"),
+  custom_fields: text("custom_fields").notNull().default("{}"),
+  created_at: text("created_at").notNull(),
+  updated_at: text("updated_at").notNull()
+});
+var activities = sqliteTable("activities", {
+  id: text("id").primaryKey(),
+  type: text("type").notNull(),
+  body: text("body").notNull().default(""),
+  contacts: text("contacts").notNull().default("[]"),
+  company: text("company"),
+  deal: text("deal"),
+  custom_fields: text("custom_fields").notNull().default("{}"),
+  created_at: text("created_at").notNull()
+});
+
+// src/lib/helpers.ts
+import { eq as eq2, sql } from "drizzle-orm";
+import { ulid } from "ulid";
+
+// src/config.ts
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { parse as parseTOML } from "toml";
+var DEFAULT_STAGES = [
+  "lead",
+  "qualified",
+  "proposal",
+  "negotiation",
+  "closed-won",
+  "closed-lost"
+];
+function defaultConfig() {
+  return {
+    database: { path: join(homedir(), ".crm", "crm.db") },
+    pipeline: {
+      stages: [...DEFAULT_STAGES],
+      won_stage: "closed-won",
+      lost_stage: "closed-lost"
+    },
+    defaults: { format: "table" },
+    phone: { display: "international" },
+    hooks: {},
+    mount: {
+      default_path: join(homedir(), "crm"),
+      readonly: false,
+      max_recent_activity: 10,
+      search_limit: 20
+    }
+  };
+}
+function findConfigFile(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, "crm.toml");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  const global = join(homedir(), ".crm", "config.toml");
+  if (existsSync(global)) {
+    return global;
+  }
+  return null;
+}
+function mergeConfig(base, override) {
+  const result = { ...base };
+  if (override.database?.path) {
+    result.database = { ...result.database, path: override.database.path };
+  }
+  if (override.pipeline) {
+    result.pipeline = { ...result.pipeline };
+    if (override.pipeline.stages) {
+      result.pipeline.stages = override.pipeline.stages;
+    }
+    if (override.pipeline.won_stage) {
+      result.pipeline.won_stage = override.pipeline.won_stage;
+    }
+    if (override.pipeline.lost_stage) {
+      result.pipeline.lost_stage = override.pipeline.lost_stage;
+    }
+  }
+  if (override.defaults?.format) {
+    result.defaults = { ...result.defaults, format: override.defaults.format };
+  }
+  if (override.phone) {
+    result.phone = { ...result.phone };
+    if (override.phone.default_country) {
+      result.phone.default_country = override.phone.default_country;
+    }
+    if (override.phone.display) {
+      result.phone.display = override.phone.display;
+    }
+  }
+  if (override.hooks) {
+    result.hooks = { ...result.hooks, ...override.hooks };
+  }
+  if (override.mount) {
+    result.mount = { ...result.mount, ...override.mount };
+  }
+  return result;
+}
+function detectCountry() {
+  try {
+    if (process.platform === "darwin") {
+      const locale = execSync("defaults read NSGlobalDomain AppleLocale", {
+        stdio: ["pipe", "pipe", "pipe"]
+      }).toString().trim();
+      const match2 = locale.match(/_([A-Z]{2})/);
+      if (match2) {
+        return match2[1];
+      }
+    }
+    const lang = process.env.LC_ALL || process.env.LANG || "";
+    const match = lang.match(/_([A-Z]{2})/);
+    if (match) {
+      return match[1];
+    }
+  } catch {}
+  return;
+}
+function createDefaultConfig(configPath) {
+  const country = detectCountry() || "US";
+  const content = `# CRM CLI configuration
+# Docs: https://github.com/dzhng/crm.cli#configuration
+
+[phone]
+default_country = "${country}"
+display = "national"
+
+[pipeline]
+stages = ["lead", "qualified", "proposal", "negotiation", "closed-won", "closed-lost"]
+won_stage = "closed-won"
+lost_stage = "closed-lost"
+`;
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, content);
+  console.log(`Created default config at ${configPath}`);
+  console.log(`  phone.default_country = "${country}" (detected from system locale)`);
+  console.log(`  Edit this file to customize.
+`);
+}
+function loadConfig(opts) {
+  let config = defaultConfig();
+  const configPath = opts.configPath || process.env.CRM_CONFIG || findConfigFile(process.cwd()) || (() => {
+    const p = join(homedir(), ".crm", "config.toml");
+    createDefaultConfig(p);
+    return p;
+  })();
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = parseTOML(raw);
+    config = mergeConfig(config, parsed);
+  } catch (_e) {
+    console.error(`Warning: could not parse config file ${configPath}`);
+  }
+  if (process.env.CRM_PHONE_DEFAULT_COUNTRY) {
+    config.phone.default_country = process.env.CRM_PHONE_DEFAULT_COUNTRY;
+  }
+  if (process.env.CRM_PHONE_DISPLAY) {
+    config.phone.display = process.env.CRM_PHONE_DISPLAY;
+  }
+  if (opts.dbPath) {
+    config.database.path = opts.dbPath;
+  } else if (process.env.CRM_DB) {
+    config.database.path = process.env.CRM_DB;
+  }
+  if (opts.format) {
+    config.defaults.format = opts.format;
+  } else if (process.env.CRM_FORMAT) {
+    config.defaults.format = process.env.CRM_FORMAT;
+  }
+  return config;
+}
+
+// src/normalize.ts
+import { parsePhoneNumberFromString } from "libphonenumber-js";
+import normalizeUrl from "normalize-url";
+function normalizePhone(input, defaultCountry) {
+  const cleaned = input.trim();
+  const country = defaultCountry;
+  let phone = parsePhoneNumberFromString(cleaned, country);
+  if (!(phone || cleaned.startsWith("+") || country)) {
+    phone = parsePhoneNumberFromString(cleaned, "US");
+    if (phone?.isValid()) {
+      const hasFormatting = /[()\-\s]/.test(cleaned);
+      if (!hasFormatting) {
+        throw new Error(`Invalid phone number: "${input}". No country code provided — set phone.default_country in config or prefix with +`);
+      }
+    }
+  }
+  if (!phone) {
+    if (!(defaultCountry || cleaned.startsWith("+"))) {
+      throw new Error(`Invalid phone number: "${input}". No country code provided — set phone.default_country in config or prefix with +`);
+    }
+    throw new Error(`Invalid phone number: "${input}"`);
+  }
+  if (!phone.isValid()) {
+    throw new Error(`Invalid phone number: "${input}"`);
+  }
+  return phone.format("E.164");
+}
+function formatPhone(e164, display, defaultCountry) {
+  const phone = parsePhoneNumberFromString(e164);
+  if (!phone) {
+    return e164;
+  }
+  switch (display) {
+    case "e164":
+      return phone.format("E.164");
+    case "national":
+      if (defaultCountry && phone.country !== defaultCountry.toUpperCase()) {
+        return phone.formatInternational();
+      }
+      return phone.formatNational();
+    default:
+      return phone.formatInternational();
+  }
+}
+function tryNormalizePhone(input, defaultCountry) {
+  try {
+    return normalizePhone(input, defaultCountry);
+  } catch {
+    return null;
+  }
+}
+function extractPhoneDigits(input) {
+  return input.replace(/[^\d]/g, "");
+}
+function phoneMatchesByDigits(e164, digits) {
+  const stored = extractPhoneDigits(e164);
+  return stored.endsWith(digits) || digits.endsWith(stored);
+}
+var NORMALIZE_URL_OPTS = {
+  stripProtocol: true,
+  stripHash: true,
+  removeQueryParameters: true,
+  stripWWW: true,
+  removeSingleSlash: true,
+  sortQueryParameters: false
+};
+function normalizeWebsite(input) {
+  return normalizeUrl(input.trim(), NORMALIZE_URL_OPTS);
+}
+function tryNormalizeWebsite(input) {
+  try {
+    return normalizeUrl(input.trim(), NORMALIZE_URL_OPTS);
+  } catch {
+    return null;
+  }
+}
+var SOCIAL_PATTERNS = {
+  linkedin: [/(?:https?:\/\/)?(?:www\.)?linkedin\.com\/in\/([^/?#]+)\/?/i],
+  x: [/(?:https?:\/\/)?(?:www\.)?(?:x\.com|twitter\.com)\/([^/?#]+)\/?/i],
+  bluesky: [/(?:https?:\/\/)?(?:www\.)?bsky\.app\/profile\/([^/?#]+)\/?/i],
+  telegram: [/(?:https?:\/\/)?(?:www\.)?t\.me\/([^/?#]+)\/?/i]
+};
+function normalizeSocialHandle(platform, input) {
+  const trimmed = input.trim();
+  const patterns = SOCIAL_PATTERNS[platform];
+  if (patterns) {
+    for (const pattern of patterns) {
+      const match = trimmed.match(pattern);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
+  if (trimmed.startsWith("@")) {
+    return trimmed.slice(1);
+  }
+  return trimmed;
+}
+function tryExtractSocialHandle(input) {
+  for (const [platform, patterns] of Object.entries(SOCIAL_PATTERNS)) {
+    for (const pattern of patterns) {
+      const match = input.match(pattern);
+      if (match) {
+        return { platform, handle: match[1] };
+      }
+    }
+  }
+  return null;
+}
+
+// src/format.ts
+function formatOutput(data, format, config) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(data, null, 2);
+    case "csv":
+      return formatCSV(data);
+    case "tsv":
+      return formatTSV(data);
+    case "ids":
+      return formatIDs(data);
+    default:
+      return formatTable(data, config);
+  }
+}
+function formatIDs(data) {
+  if (!Array.isArray(data)) {
+    return "";
+  }
+  return data.map((r) => r.id).join(`
+`);
+}
+function formatCSV(data) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return "";
+  }
+  const keys = Object.keys(data[0]);
+  const header = keys.map(csvEscape).join(",");
+  const rows = data.map((row) => keys.map((k) => {
+    const v = row[k];
+    if (Array.isArray(v)) {
+      return csvEscape(v.join(", "));
+    }
+    if (v && typeof v === "object") {
+      return csvEscape(JSON.stringify(v));
+    }
+    return csvEscape(String(v ?? ""));
+  }).join(","));
+  return [header, ...rows].join(`
+`);
+}
+function csvEscape(s) {
+  if (s.includes(",") || s.includes('"') || s.includes(`
+`)) {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return s;
+}
+function formatTSV(data) {
+  if (!Array.isArray(data) || data.length === 0) {
+    return "";
+  }
+  const keys = Object.keys(data[0]);
+  const header = keys.join("\t");
+  const rows = data.map((row) => keys.map((k) => {
+    const v = row[k];
+    if (Array.isArray(v)) {
+      return v.join(", ");
+    }
+    if (v && typeof v === "object") {
+      return JSON.stringify(v);
+    }
+    return String(v ?? "");
+  }).join("\t"));
+  return [header, ...rows].join(`
+`);
+}
+function formatTable(data, config) {
+  if (!data || Array.isArray(data) && data.length === 0) {
+    return "";
+  }
+  if (!Array.isArray(data)) {
+    return formatEntityDetail(data);
+  }
+  const keys = Object.keys(data[0]).filter((k) => data.some((row) => {
+    const v = row[k];
+    if (v === null || v === undefined || v === "") {
+      return false;
+    }
+    if (Array.isArray(v) && v.length === 0) {
+      return false;
+    }
+    if (typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 0) {
+      return false;
+    }
+    return true;
+  }));
+  if (keys.length === 0) {
+    return "";
+  }
+  const widths = {};
+  for (const k of keys) {
+    widths[k] = k.length;
+  }
+  for (const row of data) {
+    for (const k of keys) {
+      const v = displayValue(row[k], config);
+      widths[k] = Math.max(widths[k], v.length);
+    }
+  }
+  const header = keys.map((k) => k.padEnd(widths[k])).join("  ");
+  const separator = keys.map((k) => "─".repeat(widths[k])).join("──");
+  const rows = data.map((row) => keys.map((k) => displayValue(row[k], config).padEnd(widths[k])).join("  "));
+  return [header, separator, ...rows].join(`
+`);
+}
+function displayValue(v, config) {
+  if (v === null || v === undefined) {
+    return "";
+  }
+  if (Array.isArray(v)) {
+    return v.map((item) => displayValue(item, config)).join(", ");
+  }
+  if (typeof v === "object") {
+    return JSON.stringify(v);
+  }
+  const s = String(v);
+  if (/^\+\d{7,15}$/.test(s)) {
+    return formatPhone(s, config?.phone?.display || "international", config?.phone?.default_country);
+  }
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(s)) {
+    const d = new Date(s);
+    if (!Number.isNaN(d.getTime())) {
+      return d.toLocaleString(undefined, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "numeric",
+        minute: "2-digit"
+      });
+    }
+  }
+  return s;
+}
+function formatEntityDetail(entity) {
+  const lines = [];
+  for (const [key, value] of Object.entries(entity)) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        continue;
+      }
+      if (typeof value[0] === "object") {
+        lines.push(`${key}:`);
+        for (const item of value) {
+          lines.push(`  ${JSON.stringify(item)}`);
+        }
+      } else {
+        lines.push(`${key}: ${value.join(", ")}`);
+      }
+    } else if (typeof value === "object") {
+      lines.push(`${key}:`);
+      for (const [k, v] of Object.entries(value)) {
+        lines.push(`  ${k}: ${v}`);
+      }
+    } else {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function contactToRow(c) {
+  const emails = safeJSON(c.emails);
+  const phones = safeJSON(c.phones);
+  const companies2 = safeJSON(c.companies);
+  const tags = safeJSON(c.tags);
+  const custom = safeJSON(c.custom_fields);
+  return {
+    id: c.id,
+    name: c.name,
+    emails,
+    phones,
+    companies: companies2,
+    linkedin: c.linkedin || null,
+    x: c.x || null,
+    bluesky: c.bluesky || null,
+    telegram: c.telegram || null,
+    tags,
+    custom_fields: custom,
+    created_at: c.created_at,
+    updated_at: c.updated_at
+  };
+}
+function companyToRow(c) {
+  return {
+    id: c.id,
+    name: c.name,
+    websites: safeJSON(c.websites),
+    phones: safeJSON(c.phones),
+    tags: safeJSON(c.tags),
+    custom_fields: safeJSON(c.custom_fields),
+    created_at: c.created_at,
+    updated_at: c.updated_at
+  };
+}
+function dealToRow(d) {
+  return {
+    id: d.id,
+    title: d.title,
+    value: d.value ?? null,
+    stage: d.stage,
+    contacts: safeJSON(d.contacts),
+    company: d.company || null,
+    expected_close: d.expected_close || null,
+    probability: d.probability ?? null,
+    tags: safeJSON(d.tags),
+    custom_fields: safeJSON(d.custom_fields),
+    created_at: d.created_at,
+    updated_at: d.updated_at
+  };
+}
+function activityToRow(a) {
+  return {
+    id: a.id,
+    type: a.type,
+    body: a.body,
+    contacts: safeJSON(a.contacts),
+    company: a.company || null,
+    deal: a.deal || null,
+    custom_fields: safeJSON(a.custom_fields),
+    created_at: a.created_at
+  };
+}
+function safeJSON(val) {
+  if (val === null || val === undefined) {
+    if (typeof val === "string") {
+      return val;
+    }
+    return Array.isArray(val) ? [] : {};
+  }
+  if (typeof val === "string") {
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  return val;
+}
+
+// src/resolve.ts
+import { eq } from "drizzle-orm";
+async function resolveContact(db, rawRef, config) {
+  const ref = rawRef.trim();
+  if (ref.startsWith("ct_")) {
+    const results = await db.select().from(contacts).where(eq(contacts.id, ref));
+    return results[0] || null;
+  }
+  if (ref.includes("@") && !ref.includes("/")) {
+    const handle = ref.startsWith("@") ? ref.slice(1) : ref;
+    const all = await db.select().from(contacts);
+    for (const c of all) {
+      const emails = safeJSON(c.emails);
+      if (emails.some((e) => e.toLowerCase() === ref.toLowerCase())) {
+        return c;
+      }
+    }
+    for (const c of all) {
+      if (c.linkedin === handle || c.x === handle || c.bluesky === handle || c.telegram === handle) {
+        return c;
+      }
+    }
+    return null;
+  }
+  const extracted = tryExtractSocialHandle(ref);
+  if (extracted) {
+    const col = extracted.platform;
+    const results = await db.select().from(contacts).where(eq(contacts[col], extracted.handle));
+    if (results[0]) {
+      return results[0];
+    }
+  }
+  const phoneNorm = tryNormalizePhone(ref, config?.phone?.default_country);
+  if (phoneNorm) {
+    const all = await db.select().from(contacts);
+    for (const c of all) {
+      const phones = safeJSON(c.phones);
+      if (phones.includes(phoneNorm)) {
+        return c;
+      }
+    }
+  }
+  const digits = extractPhoneDigits(ref);
+  if (digits.length >= 7) {
+    const all = await db.select().from(contacts);
+    for (const c of all) {
+      const phones = safeJSON(c.phones);
+      for (const p of phones) {
+        if (phoneMatchesByDigits(p, digits)) {
+          return c;
+        }
+      }
+    }
+  }
+  {
+    const handle = ref.startsWith("@") ? ref.slice(1) : ref;
+    const all = await db.select().from(contacts);
+    for (const c of all) {
+      if (c.linkedin === handle || c.x === handle || c.bluesky === handle || c.telegram === handle) {
+        return c;
+      }
+    }
+  }
+  return null;
+}
+async function resolveCompany(db, rawRef, config) {
+  const ref = rawRef.trim();
+  if (ref.startsWith("co_")) {
+    const results = await db.select().from(companies).where(eq(companies.id, ref));
+    return results[0] || null;
+  }
+  const all = await db.select().from(companies);
+  const normalizedWeb = tryNormalizeWebsite(ref);
+  if (normalizedWeb) {
+    for (const co of all) {
+      const websites = safeJSON(co.websites);
+      if (websites.some((w) => w === normalizedWeb)) {
+        return co;
+      }
+    }
+  }
+  const phoneNorm = tryNormalizePhone(ref, config?.phone?.default_country);
+  if (phoneNorm) {
+    for (const co of all) {
+      const phones = safeJSON(co.phones);
+      if (phones.includes(phoneNorm)) {
+        return co;
+      }
+    }
+  }
+  const digits = extractPhoneDigits(ref);
+  if (digits.length >= 7) {
+    for (const co of all) {
+      const phones = safeJSON(co.phones);
+      for (const p of phones) {
+        if (phoneMatchesByDigits(p, digits)) {
+          return co;
+        }
+      }
+    }
+  }
+  for (const co of all) {
+    if (co.name === ref) {
+      return co;
+    }
+  }
+  return null;
+}
+async function resolveDeal(db, rawRef) {
+  const ref = rawRef.trim();
+  if (ref.startsWith("dl_")) {
+    const results = await db.select().from(deals).where(eq(deals.id, ref));
+    return results[0] || null;
+  }
+  return null;
+}
+async function resolveEntity(db, rawRef, config) {
+  const ref = rawRef.trim();
+  const contact = await resolveContact(db, ref, config);
+  if (contact) {
+    return { type: "contact", entity: contact };
+  }
+  const company = await resolveCompany(db, ref, config);
+  if (company) {
+    return { type: "company", entity: company };
+  }
+  const deal = await resolveDeal(db, ref);
+  if (deal) {
+    return { type: "deal", entity: deal };
+  }
+  return null;
+}
+async function resolveCompanyForLink(db, rawRef) {
+  const ref = rawRef.trim();
+  if (ref.startsWith("co_")) {
+    const results = await db.select().from(companies).where(eq(companies.id, ref));
+    return results[0] || null;
+  }
+  const all = await db.select().from(companies);
+  const normalizedWeb = tryNormalizeWebsite(ref);
+  if (normalizedWeb) {
+    for (const co of all) {
+      const websites = safeJSON(co.websites);
+      if (websites.some((w) => w === normalizedWeb)) {
+        return co;
+      }
+    }
+  }
+  for (const co of all) {
+    if (co.name === ref) {
+      return co;
+    }
+  }
+  return null;
+}
+
+// src/lib/helpers.ts
+var rawArgv = process.argv.slice(2);
+var gDb;
+var gConfig;
+var gFmt;
+var cleanArgv = [];
+var _argIdx = 0;
+while (_argIdx < rawArgv.length) {
+  const arg = rawArgv[_argIdx];
+  if (arg === "--db") {
+    _argIdx++;
+    gDb = rawArgv[_argIdx];
+  } else if (arg === "--config") {
+    _argIdx++;
+    gConfig = rawArgv[_argIdx];
+  } else if (arg === "--format") {
+    _argIdx++;
+    gFmt = rawArgv[_argIdx];
+  } else if (arg !== "--no-color") {
+    cleanArgv.push(arg);
+  }
+  _argIdx++;
+}
+async function getCtx() {
+  const config = loadConfig({ configPath: gConfig, dbPath: gDb, format: gFmt });
+  const db = await openDB(config.database.path);
+  return { config, db, fmt: config.defaults.format };
+}
+function makeId(prefix) {
+  return `${prefix}_${ulid()}`;
+}
+function now() {
+  return new Date().toISOString();
+}
+function die(msg) {
+  console.error(msg);
+  process.exit(1);
+}
+function collect(v, prev) {
+  prev.push(v);
+  return prev;
+}
+function confirmOrForce(force, label) {
+  if (force) {
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    die(`Error: refusing to delete ${label} without --force (non-interactive)`);
+  }
+  const fs = __require("node:fs");
+  process.stdout.write(`Delete ${label}? [y/N] `);
+  const buf = Buffer.alloc(64);
+  const fd = fs.openSync("/dev/tty", "r");
+  try {
+    const n = fs.readSync(fd, buf, 0, 64, null);
+    const answer = buf.slice(0, n).toString().trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      die("Aborted");
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function parseKV(arr) {
+  const r = {};
+  for (const s of arr || []) {
+    const i = s.indexOf("=");
+    if (i > 0) {
+      const key = s.slice(0, i).trim();
+      const val = s.slice(i + 1).trim();
+      if (key.startsWith("json:")) {
+        try {
+          r[key.slice(5)] = JSON.parse(val);
+        } catch {
+          die(`Error: invalid JSON for custom field "${key.slice(5)}"`);
+        }
+      } else {
+        r[key] = val;
+      }
+    }
+  }
+  return r;
+}
+async function getOrCreateCompanyId(db, rawRef) {
+  const ref = rawRef.trim();
+  const co = await resolveCompanyForLink(db, ref);
+  if (co) {
+    return co.id;
+  }
+  const cid = makeId("co");
+  const n = now();
+  await db.insert(companies).values({
+    id: cid,
+    name: ref,
+    websites: "[]",
+    phones: "[]",
+    tags: "[]",
+    custom_fields: "{}",
+    created_at: n,
+    updated_at: n
+  });
+  await upsertSearchIndex(db, "company", cid, ref);
+  return cid;
+}
+async function getOrCreateContactId(db, rawRef, config) {
+  const ref = rawRef.trim();
+  const ct = await resolveContact(db, ref, config);
+  if (ct) {
+    return ct.id;
+  }
+  const cid = makeId("ct");
+  const n = now();
+  const isEmail = ref.includes("@") && !ref.includes("/");
+  const normalizedPhone = isEmail ? null : tryNormalizePhone(ref, config.phone?.default_country);
+  let name = ref;
+  if (isEmail) {
+    name = ref.split("@")[0];
+  }
+  await db.insert(contacts).values({
+    id: cid,
+    name,
+    emails: isEmail ? JSON.stringify([ref]) : "[]",
+    phones: normalizedPhone ? JSON.stringify([normalizedPhone]) : "[]",
+    companies: "[]",
+    tags: "[]",
+    custom_fields: "{}",
+    created_at: n,
+    updated_at: n
+  });
+  await upsertSearchIndex(db, "contact", cid, ref);
+  return cid;
+}
+function validateEmail(email) {
+  if (!email.includes("@") || email.startsWith("@") || email.endsWith("@")) {
+    die(`Error: invalid email "${email}" — must contain @`);
+  }
+}
+async function checkDupeEmail(db, email, excludeId) {
+  const all = await db.select().from(contacts);
+  for (const c of all) {
+    if (excludeId && c.id === excludeId) {
+      continue;
+    }
+    const emails = safeJSON(c.emails);
+    if (emails.some((e) => e.toLowerCase() === email.toLowerCase())) {
+      die(`Error: duplicate email "${email}" — already belongs to ${c.name} (${c.id})`);
+    }
+  }
+}
+async function checkDupePhone(db, phone, table, excludeId) {
+  const all = table === "contacts" ? await db.select().from(contacts) : await db.select().from(companies);
+  for (const c of all) {
+    if (excludeId && c.id === excludeId) {
+      continue;
+    }
+    const phones = safeJSON(c.phones);
+    if (phones.includes(phone)) {
+      die(`Error: duplicate phone "${phone}" — already belongs to ${c.name} (${c.id})`);
+    }
+  }
+}
+async function checkDupeWebsite(db, website, excludeId) {
+  const all = await db.select().from(companies);
+  for (const co of all) {
+    if (excludeId && co.id === excludeId) {
+      continue;
+    }
+    const websites = safeJSON(co.websites);
+    if (websites.includes(website)) {
+      die(`Error: duplicate website "${website}" — already belongs to ${co.name} (${co.id})`);
+    }
+  }
+}
+async function checkDupeSocial(db, platform, handle, excludeId) {
+  const col = platform;
+  const existing = await db.select().from(contacts).where(eq2(contacts[col], handle));
+  const match = existing[0];
+  if (match && match.id !== excludeId) {
+    die(`Error: duplicate ${platform} handle "${handle}" — already belongs to ${match.name} (${match.id})`);
+  }
+}
+async function buildContactSearch(db, c) {
+  const companyIds = safeJSON(c.companies);
+  const allCompanies = await db.select().from(companies);
+  const companyNames = companyIds.map((id) => allCompanies.find((co) => co.id === id)?.name).filter(Boolean);
+  return [
+    c.name,
+    c.emails,
+    c.phones,
+    companyNames.join(" "),
+    c.linkedin,
+    c.x,
+    c.bluesky,
+    c.telegram,
+    JSON.stringify(safeJSON(c.custom_fields)),
+    c.tags
+  ].filter(Boolean).join(" ");
+}
+function buildCompanySearch(co) {
+  return [
+    co.name,
+    co.websites,
+    co.phones,
+    JSON.stringify(safeJSON(co.custom_fields)),
+    co.tags
+  ].filter(Boolean).join(" ");
+}
+function buildDealSearch(d) {
+  return [d.title, d.stage, JSON.stringify(safeJSON(d.custom_fields)), d.tags].filter(Boolean).join(" ");
+}
+async function contactDetail(db, c, config) {
+  const row = contactToRow(c);
+  const phones = safeJSON(c.phones);
+  row._display_phones = phones.map((p) => formatPhone(p, config.phone.display, config.phone.default_country));
+  const companyIds = safeJSON(c.companies);
+  const allCompanies = await db.select().from(companies);
+  row.companies = companyIds.map((id) => {
+    const co = allCompanies.find((x) => x.id === id);
+    return co ? co.name : id;
+  });
+  const allDeals = await db.select().from(deals);
+  row.deals = allDeals.filter((d) => {
+    const contacts2 = safeJSON(d.contacts);
+    return contacts2.includes(c.id);
+  }).map((d) => ({ id: d.id, title: d.title, stage: d.stage, value: d.value }));
+  return row;
+}
+async function companyDetail(db, co, config) {
+  const row = companyToRow(co);
+  const phones = safeJSON(co.phones);
+  row._display_phones = phones.map((p) => formatPhone(p, config.phone.display, config.phone.default_country));
+  const linkedContacts = await db.select().from(contacts);
+  row.contacts = linkedContacts.filter((ct) => {
+    const companies2 = safeJSON(ct.companies);
+    return companies2.includes(co.id);
+  }).map((ct) => ({ id: ct.id, name: ct.name, emails: safeJSON(ct.emails) }));
+  const allDeals = await db.select().from(deals).where(eq2(deals.company, co.id));
+  row.deals = allDeals.map((d) => ({
+    id: d.id,
+    title: d.title,
+    stage: d.stage,
+    value: d.value
+  }));
+  return row;
+}
+async function dealDetail(db, d) {
+  const row = dealToRow(d);
+  const contactIds = safeJSON(d.contacts);
+  const contactPromises = contactIds.map(async (cid) => {
+    const results = await db.select().from(contacts).where(eq2(contacts.id, cid));
+    const ct = results[0];
+    return ct ? { id: ct.id, name: ct.name, emails: safeJSON(ct.emails) } : null;
+  });
+  row.contacts = (await Promise.all(contactPromises)).filter(Boolean);
+  if (d.company) {
+    const results = await db.select().from(companies).where(eq2(companies.id, d.company));
+    const co = results[0];
+    row.company = co ? { id: co.id, name: co.name } : null;
+  }
+  const stageChanges = await db.select().from(activities).where(sql`${activities.deal} = ${d.id} AND ${activities.type} = 'stage-change'`).orderBy(activities.created_at);
+  const history = [];
+  if (stageChanges.length > 0) {
+    const m = stageChanges[0].body.match(/from (\S+) to/);
+    history.push({ stage: m ? m[1] : d.stage, at: d.created_at });
+    for (const sc of stageChanges) {
+      const tm = sc.body.match(/to (\S+)/);
+      history.push({ stage: tm ? tm[1] : "", at: sc.created_at });
+    }
+  } else {
+    history.push({ stage: d.stage, at: d.created_at });
+  }
+  row.stage_history = history;
+  row.notes = stageChanges.filter((a) => a.body.includes("|")).map((a) => a.body);
+  return row;
+}
+function showEntity(detail, fmt) {
+  if (fmt === "json") {
+    console.log(JSON.stringify(detail, null, 2));
+    return;
+  }
+  const lines = [];
+  for (const [k, v] of Object.entries(detail)) {
+    if (k === "_display_phones") {
+      continue;
+    }
+    if (v === null || v === undefined) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        continue;
+      }
+      if (typeof v[0] === "object") {
+        lines.push(`${k}:`);
+        for (const item of v) {
+          lines.push(`  ${typeof item === "object" ? JSON.stringify(item) : item}`);
+        }
+      } else {
+        lines.push(`${k}: ${v.join(", ")}`);
+      }
+    } else if (typeof v === "object") {
+      lines.push(`${k}:`);
+      for (const [sk, sv] of Object.entries(v)) {
+        lines.push(`  ${sk}: ${sv}`);
+      }
+    } else {
+      lines.push(`${k}: ${v}`);
+    }
+  }
+  const displayPhones = detail._display_phones;
+  if (displayPhones?.length) {
+    const idx = lines.findIndex((l) => l.startsWith("phones:"));
+    if (idx >= 0) {
+      lines[idx] = `phones: ${displayPhones.join(", ")}`;
+    }
+  }
+  console.log(lines.join(`
+`));
+}
+function parseCSV(text2) {
+  const lines = text2.split(`
+`).filter((l) => l.trim());
+  if (lines.length < 1) {
+    return [];
+  }
+  const headers = parseCSVLine(lines[0]);
+  const rows = [];
+  for (let i = 1;i < lines.length; i++) {
+    const vals = parseCSVLine(lines[i]);
+    const row = {};
+    for (let j = 0;j < headers.length; j++) {
+      row[headers[j]] = vals[j] || "";
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function parseCSVLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0;i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+        continue;
+      }
+      if (ch === '"') {
+        inQuotes = false;
+        continue;
+      }
+      current += ch;
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+        continue;
+      }
+      if (ch === ",") {
+        result.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+  }
+  result.push(current);
+  return result;
+}
+function levenshtein(a, b) {
+  const la = a.length, lb = b.length;
+  const dp = Array.from({ length: la + 1 }, () => new Array(lb + 1).fill(0));
+  for (let i = 0;i <= la; i++) {
+    dp[i][0] = i;
+  }
+  for (let j = 0;j <= lb; j++) {
+    dp[0][j] = j;
+  }
+  for (let i = 1;i <= la; i++) {
+    for (let j = 1;j <= lb; j++) {
+      dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    }
+  }
+  return dp[la][lb];
+}
+
+// src/db.ts
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS contacts (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  emails TEXT NOT NULL DEFAULT '[]',
+  phones TEXT NOT NULL DEFAULT '[]',
+  companies TEXT NOT NULL DEFAULT '[]',
+  linkedin TEXT,
+  x TEXT,
+  bluesky TEXT,
+  telegram TEXT,
+  tags TEXT NOT NULL DEFAULT '[]',
+  custom_fields TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS idx_contacts_linkedin ON contacts(linkedin) WHERE linkedin IS NOT NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_contacts_x ON contacts(x) WHERE x IS NOT NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_contacts_bluesky ON contacts(bluesky) WHERE bluesky IS NOT NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS idx_contacts_telegram ON contacts(telegram) WHERE telegram IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS companies (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  websites TEXT NOT NULL DEFAULT '[]',
+  phones TEXT NOT NULL DEFAULT '[]',
+  tags TEXT NOT NULL DEFAULT '[]',
+  custom_fields TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS deals (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  value INTEGER,
+  stage TEXT NOT NULL,
+  contacts TEXT NOT NULL DEFAULT '[]',
+  company TEXT REFERENCES companies(id) ON DELETE SET NULL,
+  expected_close TEXT,
+  probability INTEGER,
+  tags TEXT NOT NULL DEFAULT '[]',
+  custom_fields TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS activities (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  body TEXT NOT NULL DEFAULT '',
+  contacts TEXT NOT NULL DEFAULT '[]',
+  company TEXT,
+  deal TEXT,
+  custom_fields TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(
+  entity_type, entity_id, content
+);
+`;
+async function openDB(dbPath) {
+  mkdirSync2(dirname2(dbPath), { recursive: true });
+  const client = createClient({ url: `file:${dbPath}` });
+  const db = drizzle(client, { schema: exports_drizzle_schema });
+  const statements = SCHEMA_SQL.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  for (const stmt of statements) {
+    await client.execute(stmt);
+  }
+  await client.execute("PRAGMA journal_mode=WAL");
+  await client.execute("PRAGMA foreign_keys=ON");
+  return db;
+}
+async function upsertSearchIndex(db, entityType, entityId, content) {
+  await db.run(sql2`DELETE FROM search_index WHERE entity_id = ${entityId}`);
+  await db.run(sql2`INSERT INTO search_index (entity_type, entity_id, content) VALUES (${entityType}, ${entityId}, ${content})`);
+}
+async function removeSearchIndex(db, entityId) {
+  await db.run(sql2`DELETE FROM search_index WHERE entity_id = ${entityId}`);
+}
+async function rebuildSearchIndex(db) {
+  await db.run(sql2`DELETE FROM search_index`);
+  const allContacts = await db.select().from(contacts);
+  for (const c of allContacts) {
+    const content = await buildContactSearch(db, c);
+    await db.run(sql2`INSERT INTO search_index (entity_type, entity_id, content) VALUES (${"contact"}, ${c.id}, ${content})`);
+  }
+  const allCompanies = await db.select().from(companies);
+  for (const co of allCompanies) {
+    const content = buildCompanySearch(co);
+    await db.run(sql2`INSERT INTO search_index (entity_type, entity_id, content) VALUES (${"company"}, ${co.id}, ${content})`);
+  }
+  const allDeals = await db.select().from(deals);
+  for (const d of allDeals) {
+    const content = buildDealSearch(d);
+    await db.run(sql2`INSERT INTO search_index (entity_type, entity_id, content) VALUES (${"deal"}, ${d.id}, ${content})`);
+  }
+  const allActivities = await db.select().from(activities);
+  for (const a of allActivities) {
+    const content = [a.type, a.body, a.custom_fields].filter(Boolean).join(" ");
+    await db.run(sql2`INSERT INTO search_index (entity_type, entity_id, content) VALUES (${"activity"}, ${a.id}, ${content})`);
+  }
+}
+
+// src/hooks.ts
+import { spawnSync } from "node:child_process";
+function runHook(config, hookName, data) {
+  const hookCmd = config.hooks[hookName];
+  if (!hookCmd) {
+    return true;
+  }
+  const jsonData = JSON.stringify(data);
+  const result = spawnSync(hookCmd, {
+    shell: true,
+    input: jsonData,
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 30000
+  });
+  return result.status === 0;
+}
+
+// src/commands/activity.ts
+var VALID_TYPES = ["note", "call", "meeting", "email"];
+function registerLogCommand(program) {
+  program.command("log").description("Log an activity").argument("<type>", "Activity type (note, call, meeting, email)").argument("<body>", "Activity body").option("--contact <ref>", "Link to contact (repeatable)", collect, []).option("--company <ref>", "Link to company (auto-creates if needed)").option("--deal <ref>", "Link to deal").option("--at <date>", "Custom timestamp").option("--set <kv>", "Custom field", collect, []).action(async (rawType, rawBody, opts) => {
+    const { db, config } = await getCtx();
+    const type = rawType.trim();
+    const body = rawBody.trim();
+    opts.contact = opts.contact.map((c) => c.trim());
+    if (opts.company) {
+      opts.company = opts.company.trim();
+    }
+    if (opts.deal) {
+      opts.deal = opts.deal.trim();
+    }
+    if (!VALID_TYPES.includes(type)) {
+      die(`Error: invalid activity type "${type}". Must be one of: ${VALID_TYPES.join(", ")}`);
+    }
+    const contacts2 = [];
+    let company = null;
+    let deal = null;
+    for (const cRef of opts.contact) {
+      const ctId = await getOrCreateContactId(db, cRef, config);
+      if (!contacts2.includes(ctId)) {
+        contacts2.push(ctId);
+      }
+    }
+    if (opts.company) {
+      company = await getOrCreateCompanyId(db, opts.company);
+    }
+    if (opts.deal) {
+      const d = await resolveDeal(db, opts.deal);
+      if (!d) {
+        die(`Error: deal not found: ${opts.deal}`);
+      }
+      deal = d.id;
+    }
+    if (opts.at) {
+      opts.at = opts.at.trim();
+      const d = new Date(opts.at);
+      if (Number.isNaN(d.getTime())) {
+        die("Error: invalid --at date");
+      }
+    }
+    const id = makeId("ac");
+    const ts = opts.at || now();
+    const custom = parseKV(opts.set);
+    if (!runHook(config, "pre-activity-add", {
+      type,
+      body,
+      contacts: contacts2,
+      company,
+      deal,
+      custom_fields: custom
+    })) {
+      die("Error: pre-activity-add hook rejected creation");
+    }
+    await db.insert(activities).values({
+      id,
+      type,
+      body,
+      contacts: JSON.stringify(contacts2),
+      company,
+      deal,
+      custom_fields: JSON.stringify(custom),
+      created_at: ts
+    });
+    await upsertSearchIndex(db, "activity", id, `${type} ${body}`);
+    runHook(config, "post-activity-add", {
+      id,
+      type,
+      body,
+      contacts: contacts2,
+      company,
+      deal,
+      custom_fields: custom
+    });
+  });
+}
+function registerActivityCommands(program) {
+  const cmd = program.command("activity").description("Activity management");
+  cmd.command("list").option("--contact <ref>").option("--company <ref>").option("--deal <id>").option("--type <type>").option("--since <date>").option("--sort <field>").option("--reverse", "Reverse sort order").option("--limit <n>").option("--offset <n>").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let rows = (await db.select().from(activities)).map((a) => activityToRow(a));
+    if (opts.contact) {
+      const ct = await resolveContact(db, opts.contact, config);
+      if (ct) {
+        rows = rows.filter((a) => a.contacts.includes(ct.id));
+      } else {
+        rows = [];
+      }
+    }
+    if (opts.company) {
+      const co = await resolveCompany(db, opts.company, config);
+      if (co) {
+        rows = rows.filter((a) => a.company === co.id);
+      } else {
+        rows = [];
+      }
+    }
+    if (opts.deal) {
+      rows = rows.filter((a) => a.deal === opts.deal);
+    }
+    if (opts.type) {
+      rows = rows.filter((a) => a.type === opts.type);
+    }
+    if (opts.since) {
+      rows = rows.filter((a) => a.created_at >= opts.since);
+    }
+    if (opts.sort) {
+      rows.sort((a, b) => String(a[opts.sort] ?? "").localeCompare(String(b[opts.sort] ?? "")));
+    }
+    if (opts.reverse) {
+      rows.reverse();
+    }
+    if (opts.offset) {
+      rows = rows.slice(Number(opts.offset));
+    }
+    if (opts.limit) {
+      rows = rows.slice(0, Number(opts.limit));
+    }
+    console.log(formatOutput(rows, fmt, config));
+  });
+}
+
+// src/commands/company.ts
+import { eq as eq3 } from "drizzle-orm";
+
+// src/filter.ts
+function parseFilter(expr) {
+  const orParts = expr.split(/\s+OR\s+/);
+  if (orParts.length > 1) {
+    const conditions2 = [];
+    for (const part of orParts) {
+      conditions2.push(parseSingleCondition(part.trim()));
+    }
+    return { conditions: conditions2, logic: "OR" };
+  }
+  const andParts = expr.split(/\s+AND\s+/);
+  const conditions = andParts.map((p) => parseSingleCondition(p.trim()));
+  return { conditions, logic: "AND" };
+}
+function parseSingleCondition(expr) {
+  const match = expr.match(/^([^!~<>=]+)(~=|!=|>=|<=|>|<|=)(.*)$/);
+  if (match) {
+    return {
+      field: match[1].trim(),
+      op: match[2],
+      value: match[3].trim()
+    };
+  }
+  throw new Error(`Invalid filter expression: ${expr}`);
+}
+function applyFilter(row, filter) {
+  if (filter.logic === "AND") {
+    return filter.conditions.every((c) => matchCondition(row, c));
+  }
+  return filter.conditions.some((c) => matchCondition(row, c));
+}
+function matchCondition(row, condition) {
+  const { field, op, value } = condition;
+  let fieldValue = row[field];
+  if (fieldValue === undefined || fieldValue === null) {
+    const custom = typeof row.custom_fields === "string" ? safeJSON(row.custom_fields) : row.custom_fields || {};
+    fieldValue = custom[field];
+  }
+  if (fieldValue === undefined || fieldValue === null) {
+    if (op === "!=") {
+      return true;
+    }
+    return false;
+  }
+  const strVal = String(fieldValue);
+  switch (op) {
+    case "=":
+      return strVal === value;
+    case "!=":
+      return strVal !== value;
+    case "~=":
+      return strVal.toLowerCase().includes(value.toLowerCase());
+    case ">":
+      return Number(strVal) > Number(value);
+    case "<":
+      return Number(strVal) < Number(value);
+    default:
+      return false;
+  }
+}
+
+// src/commands/company.ts
+function registerCompanyCommands(program) {
+  const cmd = program.command("company").description("Manage companies");
+  cmd.command("add").requiredOption("--name <name>", "Company name").option("--website <url>", "Website", collect, []).option("--phone <phone>", "Phone", collect, []).option("--tag <tag>", "Tag", collect, []).option("--set <kv>", "Custom field", collect, []).action(async (opts) => {
+    const { db, config } = await getCtx();
+    opts.name = opts.name.trim();
+    opts.website = opts.website.map((w) => w.trim());
+    opts.phone = opts.phone.map((p) => p.trim());
+    opts.tag = opts.tag.map((t) => t.trim());
+    const cid = makeId("co");
+    const n = now();
+    const websites = [];
+    for (const w of opts.website) {
+      const norm = normalizeWebsite(w);
+      await checkDupeWebsite(db, norm);
+      websites.push(norm);
+    }
+    const phones = [];
+    for (const p of opts.phone) {
+      try {
+        const norm = normalizePhone(p, config.phone.default_country);
+        await checkDupePhone(db, norm, "companies");
+        phones.push(norm);
+      } catch (e) {
+        die(`Error: invalid phone — ${e.message}`);
+      }
+    }
+    const custom = parseKV(opts.set);
+    if (!runHook(config, "pre-company-add", {
+      name: opts.name,
+      websites,
+      phones,
+      tags: opts.tag,
+      custom_fields: custom
+    })) {
+      die("Error: pre-company-add hook rejected creation");
+    }
+    await db.insert(companies).values({
+      id: cid,
+      name: opts.name,
+      websites: JSON.stringify(websites),
+      phones: JSON.stringify(phones),
+      tags: JSON.stringify(opts.tag),
+      custom_fields: JSON.stringify(custom),
+      created_at: n,
+      updated_at: n
+    });
+    const results = await db.select().from(companies).where(eq3(companies.id, cid));
+    const row = results[0];
+    await upsertSearchIndex(db, "company", cid, buildCompanySearch(row));
+    runHook(config, "post-company-add", {
+      id: cid,
+      name: opts.name,
+      websites,
+      phones,
+      tags: opts.tag,
+      custom_fields: custom
+    });
+    console.log(cid);
+  });
+  cmd.command("list").option("--tag <tag>").option("--sort <field>").option("--reverse", "Reverse sort order").option("--limit <n>").option("--offset <n>").option("--filter <expr>").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let rows = (await db.select().from(companies)).map((c) => companyToRow(c));
+    if (opts.filter) {
+      const f = parseFilter(opts.filter);
+      rows = rows.filter((c) => applyFilter(c, f));
+    }
+    if (opts.tag) {
+      rows = rows.filter((c) => c.tags?.includes(opts.tag));
+    }
+    if (opts.sort) {
+      rows.sort((a, b) => String(a[opts.sort] ?? "").localeCompare(String(b[opts.sort] ?? "")));
+    }
+    if (opts.reverse) {
+      rows.reverse();
+    }
+    if (opts.offset) {
+      rows = rows.slice(Number(opts.offset));
+    }
+    if (opts.limit) {
+      rows = rows.slice(0, Number(opts.limit));
+    }
+    console.log(formatOutput(rows, fmt, config));
+  });
+  cmd.command("show").argument("<ref>").action(async (ref) => {
+    const { db, config, fmt } = await getCtx();
+    const co = await resolveCompany(db, ref, config);
+    if (!co) {
+      die(`Error: company not found: ${ref}`);
+    }
+    showEntity(await companyDetail(db, co, config), fmt);
+  });
+  cmd.command("edit").argument("<ref>").option("--name <name>").option("--add-website <url>", "", collect, []).option("--rm-website <url>", "", collect, []).option("--add-phone <p>", "", collect, []).option("--rm-phone <p>", "", collect, []).option("--add-tag <t>", "", collect, []).option("--rm-tag <t>", "", collect, []).option("--set <kv>", "", collect, []).option("--unset <key>", "", collect, []).action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    if (opts.name) {
+      opts.name = opts.name.trim();
+    }
+    opts.addWebsite = opts.addWebsite.map((w) => w.trim());
+    opts.rmWebsite = opts.rmWebsite.map((w) => w.trim());
+    opts.addPhone = opts.addPhone.map((p) => p.trim());
+    opts.rmPhone = opts.rmPhone.map((p) => p.trim());
+    opts.addTag = opts.addTag.map((t) => t.trim());
+    opts.rmTag = opts.rmTag.map((t) => t.trim());
+    const co = await resolveCompany(db, ref.trim(), config);
+    if (!co) {
+      die(`Error: company not found: ${ref}`);
+    }
+    let websites = safeJSON(co.websites);
+    let phones = safeJSON(co.phones);
+    let tags = safeJSON(co.tags);
+    const custom = safeJSON(co.custom_fields);
+    let name = co.name;
+    if (opts.name) {
+      name = opts.name;
+    }
+    for (const w of opts.addWebsite) {
+      const norm = normalizeWebsite(w);
+      if (!websites.includes(norm)) {
+        await checkDupeWebsite(db, norm, co.id);
+        websites.push(norm);
+      }
+    }
+    for (const w of opts.rmWebsite) {
+      const norm = normalizeWebsite(w);
+      websites = websites.filter((v) => v !== norm);
+    }
+    for (const p of opts.addPhone) {
+      const norm = normalizePhone(p, config.phone.default_country);
+      if (!phones.includes(norm)) {
+        await checkDupePhone(db, norm, "companies", co.id);
+        phones.push(norm);
+      }
+    }
+    for (const p of opts.rmPhone) {
+      const norm = tryNormalizePhone(p, config.phone.default_country);
+      phones = norm ? phones.filter((v) => v !== norm) : phones.filter((v) => v !== p);
+    }
+    for (const t of opts.addTag) {
+      if (!tags.includes(t)) {
+        tags.push(t);
+      }
+    }
+    for (const t of opts.rmTag) {
+      tags = tags.filter((v) => v !== t);
+    }
+    const kvs = parseKV(opts.set);
+    for (const [k, v] of Object.entries(kvs)) {
+      custom[k] = v;
+    }
+    for (const k of opts.unset) {
+      delete custom[k];
+    }
+    if (!runHook(config, "pre-company-edit", {
+      id: co.id,
+      name,
+      websites,
+      phones,
+      tags,
+      custom_fields: custom
+    })) {
+      die("Error: pre-company-edit hook rejected edit");
+    }
+    await db.update(companies).set({
+      name,
+      websites: JSON.stringify(websites),
+      phones: JSON.stringify(phones),
+      tags: JSON.stringify(tags),
+      custom_fields: JSON.stringify(custom),
+      updated_at: now()
+    }).where(eq3(companies.id, co.id));
+    const results = await db.select().from(companies).where(eq3(companies.id, co.id));
+    const row = results[0];
+    await upsertSearchIndex(db, "company", co.id, buildCompanySearch(row));
+    console.log(co.id);
+    runHook(config, "post-company-edit", {
+      id: co.id,
+      name,
+      websites,
+      phones,
+      tags,
+      custom_fields: custom
+    });
+  });
+  cmd.command("rm").argument("<ref>").option("--force", "Skip confirmation").action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    const co = await resolveCompany(db, ref, config);
+    if (!co) {
+      die(`Error: company not found: ${ref}`);
+    }
+    confirmOrForce(opts.force, `company "${co.name}" (${co.id})`);
+    if (!runHook(config, "pre-company-rm", { id: co.id, name: co.name })) {
+      die("Error: pre-company-rm hook rejected deletion");
+    }
+    const allContacts = await db.select().from(contacts);
+    for (const ct of allContacts) {
+      const companies2 = safeJSON(ct.companies);
+      if (companies2.includes(co.id)) {
+        await db.update(contacts).set({
+          companies: JSON.stringify(companies2.filter((n) => n !== co.id))
+        }).where(eq3(contacts.id, ct.id));
+      }
+    }
+    await db.update(deals).set({ company: null }).where(eq3(deals.company, co.id));
+    await db.delete(companies).where(eq3(companies.id, co.id));
+    await removeSearchIndex(db, co.id);
+    runHook(config, "post-company-rm", { id: co.id, name: co.name });
+  });
+  cmd.command("merge").argument("<id1>").argument("<id2>").action(async (id1, id2) => {
+    const { db, config } = await getCtx();
+    const c1 = await resolveCompany(db, id1, config), c2 = await resolveCompany(db, id2, config);
+    if (!(c1 && c2)) {
+      die("Error: one or both companies not found");
+    }
+    const mergedWebsites = [
+      ...new Set([...safeJSON(c1.websites), ...safeJSON(c2.websites)])
+    ];
+    const mergedPhones = [
+      ...new Set([...safeJSON(c1.phones), ...safeJSON(c2.phones)])
+    ];
+    const mergedTags = [
+      ...new Set([...safeJSON(c1.tags), ...safeJSON(c2.tags)])
+    ];
+    const mergedCustom = {
+      ...safeJSON(c2.custom_fields),
+      ...safeJSON(c1.custom_fields)
+    };
+    await db.update(companies).set({
+      websites: JSON.stringify(mergedWebsites),
+      phones: JSON.stringify(mergedPhones),
+      tags: JSON.stringify(mergedTags),
+      custom_fields: JSON.stringify(mergedCustom),
+      updated_at: now()
+    }).where(eq3(companies.id, c1.id));
+    const allContacts = await db.select().from(contacts);
+    for (const ct of allContacts) {
+      const companies2 = safeJSON(ct.companies);
+      if (companies2.includes(c2.id)) {
+        const updated = [
+          ...new Set(companies2.map((n) => n === c2.id ? c1.id : n))
+        ];
+        await db.update(contacts).set({ companies: JSON.stringify(updated) }).where(eq3(contacts.id, ct.id));
+      }
+    }
+    await db.update(deals).set({ company: c1.id }).where(eq3(deals.company, c2.id));
+    await db.update(activities).set({ company: c1.id }).where(eq3(activities.company, c2.id));
+    await db.delete(companies).where(eq3(companies.id, c2.id));
+    await removeSearchIndex(db, c2.id);
+    const results = await db.select().from(companies).where(eq3(companies.id, c1.id));
+    const row = results[0];
+    await upsertSearchIndex(db, "company", c1.id, buildCompanySearch(row));
+    console.log(c1.id);
+  });
+}
+
+// src/commands/contact.ts
+import { eq as eq4 } from "drizzle-orm";
+function registerContactCommands(program) {
+  const cmd = program.command("contact").description("Manage contacts");
+  cmd.command("add").requiredOption("--name <name>", "Contact name").option("--email <email>", "Email", collect, []).option("--phone <phone>", "Phone", collect, []).option("--company <company>", "Company", collect, []).option("--tag <tag>", "Tag", collect, []).option("--linkedin <h>", "LinkedIn").option("--x <h>", "X/Twitter").option("--bluesky <h>", "Bluesky").option("--telegram <h>", "Telegram").option("--set <kv>", "Custom field", collect, []).action(async (opts) => {
+    const { db, config } = await getCtx();
+    opts.name = opts.name.trim();
+    opts.email = opts.email.map((e) => e.trim());
+    opts.phone = opts.phone.map((p) => p.trim());
+    opts.company = opts.company.map((c) => c.trim());
+    opts.tag = opts.tag.map((t) => t.trim());
+    const cid = makeId("ct");
+    const n = now();
+    for (const e of opts.email) {
+      validateEmail(e);
+      await checkDupeEmail(db, e);
+    }
+    const phones = [];
+    for (const p of opts.phone) {
+      try {
+        const norm = normalizePhone(p, config.phone.default_country);
+        await checkDupePhone(db, norm, "contacts");
+        phones.push(norm);
+      } catch (e) {
+        die(`Error: invalid phone — ${e.message}`);
+      }
+    }
+    const linkedin = opts.linkedin ? normalizeSocialHandle("linkedin", opts.linkedin.trim()) : null;
+    const x = opts.x ? normalizeSocialHandle("x", opts.x.trim()) : null;
+    const bluesky = opts.bluesky ? normalizeSocialHandle("bluesky", opts.bluesky.trim()) : null;
+    const telegram = opts.telegram ? normalizeSocialHandle("telegram", opts.telegram.trim()) : null;
+    if (linkedin) {
+      await checkDupeSocial(db, "linkedin", linkedin);
+    }
+    if (x) {
+      await checkDupeSocial(db, "x", x);
+    }
+    if (bluesky) {
+      await checkDupeSocial(db, "bluesky", bluesky);
+    }
+    if (telegram) {
+      await checkDupeSocial(db, "telegram", telegram);
+    }
+    const companies2 = [];
+    for (const c of opts.company) {
+      companies2.push(await getOrCreateCompanyId(db, c));
+    }
+    const custom = parseKV(opts.set);
+    if (!runHook(config, "pre-contact-add", {
+      name: opts.name,
+      emails: opts.email,
+      phones,
+      companies: companies2,
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags: opts.tag,
+      custom_fields: custom
+    })) {
+      die("Error: pre-contact-add hook rejected creation");
+    }
+    await db.insert(contacts).values({
+      id: cid,
+      name: opts.name,
+      emails: JSON.stringify(opts.email),
+      phones: JSON.stringify(phones),
+      companies: JSON.stringify(companies2),
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags: JSON.stringify(opts.tag),
+      custom_fields: JSON.stringify(custom),
+      created_at: n,
+      updated_at: n
+    });
+    const results = await db.select().from(contacts).where(eq4(contacts.id, cid));
+    const row = results[0];
+    await upsertSearchIndex(db, "contact", cid, await buildContactSearch(db, row));
+    runHook(config, "post-contact-add", {
+      id: cid,
+      name: opts.name,
+      emails: opts.email,
+      phones,
+      companies: companies2,
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags: opts.tag,
+      custom_fields: custom
+    });
+    console.log(cid);
+  });
+  cmd.command("list").option("--tag <tag>").option("--company <company>").option("--sort <field>").option("--reverse", "Reverse sort order").option("--limit <n>").option("--offset <n>").option("--filter <expr>").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let rows = (await db.select().from(contacts)).map((c) => contactToRow(c));
+    if (opts.tag) {
+      rows = rows.filter((c) => c.tags?.includes(opts.tag));
+    }
+    if (opts.company) {
+      const co = await resolveCompany(db, opts.company, config);
+      if (co) {
+        rows = rows.filter((c) => c.companies?.includes(co.id));
+      } else {
+        rows = [];
+      }
+    }
+    if (opts.filter) {
+      const f = parseFilter(opts.filter);
+      rows = rows.filter((c) => applyFilter(c, f));
+    }
+    if (opts.sort) {
+      rows.sort((a, b) => String(a[opts.sort] ?? "").localeCompare(String(b[opts.sort] ?? "")));
+    }
+    if (opts.reverse) {
+      rows.reverse();
+    }
+    if (opts.offset) {
+      rows = rows.slice(Number(opts.offset));
+    }
+    if (opts.limit) {
+      rows = rows.slice(0, Number(opts.limit));
+    }
+    console.log(formatOutput(rows, fmt, config));
+  });
+  cmd.command("show").argument("<ref>").action(async (ref) => {
+    const { db, config, fmt } = await getCtx();
+    const c = await resolveContact(db, ref, config);
+    if (!c) {
+      die(`Error: contact not found: ${ref}`);
+    }
+    showEntity(await contactDetail(db, c, config), fmt);
+  });
+  cmd.command("edit").argument("<ref>").option("--name <name>").option("--add-email <e>", "", collect, []).option("--rm-email <e>", "", collect, []).option("--add-phone <p>", "", collect, []).option("--rm-phone <p>", "", collect, []).option("--add-company <c>", "", collect, []).option("--rm-company <c>", "", collect, []).option("--add-tag <t>", "", collect, []).option("--rm-tag <t>", "", collect, []).option("--linkedin <h>").option("--x <h>").option("--bluesky <h>").option("--telegram <h>").option("--set <kv>", "", collect, []).option("--unset <key>", "", collect, []).action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    if (opts.name) {
+      opts.name = opts.name.trim();
+    }
+    opts.addEmail = opts.addEmail.map((e) => e.trim());
+    opts.rmEmail = opts.rmEmail.map((e) => e.trim());
+    opts.addPhone = opts.addPhone.map((p) => p.trim());
+    opts.rmPhone = opts.rmPhone.map((p) => p.trim());
+    opts.addCompany = opts.addCompany.map((c2) => c2.trim());
+    opts.rmCompany = opts.rmCompany.map((c2) => c2.trim());
+    opts.addTag = opts.addTag.map((t) => t.trim());
+    opts.rmTag = opts.rmTag.map((t) => t.trim());
+    const c = await resolveContact(db, ref.trim(), config);
+    if (!c) {
+      die(`Error: contact not found: ${ref}`);
+    }
+    let emails = safeJSON(c.emails);
+    let phones = safeJSON(c.phones);
+    let companies2 = safeJSON(c.companies);
+    let tags = safeJSON(c.tags);
+    const custom = safeJSON(c.custom_fields);
+    let { name, linkedin, x, bluesky, telegram } = c;
+    if (opts.name) {
+      name = opts.name;
+    }
+    for (const e of opts.addEmail) {
+      validateEmail(e);
+      await checkDupeEmail(db, e, c.id);
+      if (!emails.includes(e)) {
+        emails.push(e);
+      }
+    }
+    for (const e of opts.rmEmail) {
+      emails = emails.filter((v) => v !== e);
+    }
+    for (const p of opts.addPhone) {
+      const norm = normalizePhone(p, config.phone.default_country);
+      if (!phones.includes(norm)) {
+        await checkDupePhone(db, norm, "contacts", c.id);
+        phones.push(norm);
+      }
+    }
+    for (const p of opts.rmPhone) {
+      const norm = tryNormalizePhone(p, config.phone.default_country);
+      phones = norm ? phones.filter((v) => v !== norm) : phones.filter((v) => v !== p);
+    }
+    for (const co of opts.addCompany) {
+      const coId = await getOrCreateCompanyId(db, co);
+      if (!companies2.includes(coId)) {
+        companies2.push(coId);
+      }
+    }
+    for (const co of opts.rmCompany) {
+      const resolved = await resolveCompany(db, co, config);
+      if (resolved) {
+        companies2 = companies2.filter((v) => v !== resolved.id);
+      }
+    }
+    for (const t of opts.addTag) {
+      if (!tags.includes(t)) {
+        tags.push(t);
+      }
+    }
+    for (const t of opts.rmTag) {
+      tags = tags.filter((v) => v !== t);
+    }
+    if (opts.linkedin) {
+      linkedin = normalizeSocialHandle("linkedin", opts.linkedin.trim());
+      await checkDupeSocial(db, "linkedin", linkedin, c.id);
+    }
+    if (opts.x) {
+      x = normalizeSocialHandle("x", opts.x.trim());
+      await checkDupeSocial(db, "x", x, c.id);
+    }
+    if (opts.bluesky) {
+      bluesky = normalizeSocialHandle("bluesky", opts.bluesky.trim());
+      await checkDupeSocial(db, "bluesky", bluesky, c.id);
+    }
+    if (opts.telegram) {
+      telegram = normalizeSocialHandle("telegram", opts.telegram.trim());
+      await checkDupeSocial(db, "telegram", telegram, c.id);
+    }
+    const kvs = parseKV(opts.set);
+    for (const [k, v] of Object.entries(kvs)) {
+      custom[k] = v;
+    }
+    for (const k of opts.unset) {
+      delete custom[k];
+      if (k === "linkedin") {
+        linkedin = null;
+      }
+      if (k === "x") {
+        x = null;
+      }
+      if (k === "bluesky") {
+        bluesky = null;
+      }
+      if (k === "telegram") {
+        telegram = null;
+      }
+    }
+    if (!runHook(config, "pre-contact-edit", {
+      id: c.id,
+      name,
+      emails,
+      phones,
+      companies: companies2,
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags,
+      custom_fields: custom
+    })) {
+      die("Error: pre-contact-edit hook rejected edit");
+    }
+    await db.update(contacts).set({
+      name,
+      emails: JSON.stringify(emails),
+      phones: JSON.stringify(phones),
+      companies: JSON.stringify(companies2),
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags: JSON.stringify(tags),
+      custom_fields: JSON.stringify(custom),
+      updated_at: now()
+    }).where(eq4(contacts.id, c.id));
+    const results = await db.select().from(contacts).where(eq4(contacts.id, c.id));
+    const row = results[0];
+    await upsertSearchIndex(db, "contact", c.id, await buildContactSearch(db, row));
+    console.log(c.id);
+    runHook(config, "post-contact-edit", {
+      id: c.id,
+      name,
+      emails,
+      phones,
+      companies: companies2,
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      tags,
+      custom_fields: custom
+    });
+  });
+  cmd.command("rm").argument("<ref>").option("--force", "Skip confirmation").action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    const c = await resolveContact(db, ref, config);
+    if (!c) {
+      die(`Error: contact not found: ${ref}`);
+    }
+    confirmOrForce(opts.force, `contact "${c.name}" (${c.id})`);
+    if (!runHook(config, "pre-contact-rm", { id: c.id, name: c.name })) {
+      die("Error: pre-contact-rm hook rejected deletion");
+    }
+    const allDeals = await db.select().from(deals);
+    for (const d of allDeals) {
+      const contacts2 = safeJSON(d.contacts);
+      if (contacts2.includes(c.id)) {
+        await db.update(deals).set({
+          contacts: JSON.stringify(contacts2.filter((id) => id !== c.id))
+        }).where(eq4(deals.id, d.id));
+      }
+    }
+    await db.delete(contacts).where(eq4(contacts.id, c.id));
+    await removeSearchIndex(db, c.id);
+    runHook(config, "post-contact-rm", { id: c.id, name: c.name });
+  });
+  cmd.command("merge").argument("<id1>").argument("<id2>").action(async (id1, id2) => {
+    const { db, config } = await getCtx();
+    const c1 = await resolveContact(db, id1, config), c2 = await resolveContact(db, id2, config);
+    if (!(c1 && c2)) {
+      die("Error: one or both contacts not found");
+    }
+    const mergedEmails = [
+      ...new Set([...safeJSON(c1.emails), ...safeJSON(c2.emails)])
+    ];
+    const mergedPhones = [
+      ...new Set([...safeJSON(c1.phones), ...safeJSON(c2.phones)])
+    ];
+    const mergedCompanies = [
+      ...new Set([...safeJSON(c1.companies), ...safeJSON(c2.companies)])
+    ];
+    const mergedTags = [
+      ...new Set([...safeJSON(c1.tags), ...safeJSON(c2.tags)])
+    ];
+    const mergedCustom = {
+      ...safeJSON(c2.custom_fields),
+      ...safeJSON(c1.custom_fields)
+    };
+    const linkedin = c1.linkedin || c2.linkedin;
+    const x = c1.x || c2.x;
+    const bluesky = c1.bluesky || c2.bluesky;
+    const telegram = c1.telegram || c2.telegram;
+    await db.update(contacts).set({ linkedin: null, x: null, bluesky: null, telegram: null }).where(eq4(contacts.id, c2.id));
+    await db.update(contacts).set({
+      emails: JSON.stringify(mergedEmails),
+      phones: JSON.stringify(mergedPhones),
+      companies: JSON.stringify(mergedCompanies),
+      tags: JSON.stringify(mergedTags),
+      custom_fields: JSON.stringify(mergedCustom),
+      linkedin,
+      x,
+      bluesky,
+      telegram,
+      updated_at: now()
+    }).where(eq4(contacts.id, c1.id));
+    const allDeals = await db.select().from(deals);
+    for (const d of allDeals) {
+      const contacts2 = safeJSON(d.contacts);
+      if (contacts2.includes(c2.id)) {
+        const updated = [
+          ...new Set(contacts2.map((id) => id === c2.id ? c1.id : id))
+        ];
+        await db.update(deals).set({ contacts: JSON.stringify(updated) }).where(eq4(deals.id, d.id));
+      }
+    }
+    const allActivities = await db.select().from(activities);
+    for (const a of allActivities) {
+      const contacts2 = safeJSON(a.contacts);
+      if (contacts2.includes(c2.id)) {
+        const updated = [
+          ...new Set(contacts2.map((id) => id === c2.id ? c1.id : id))
+        ];
+        await db.update(activities).set({ contacts: JSON.stringify(updated) }).where(eq4(activities.id, a.id));
+      }
+    }
+    await db.delete(contacts).where(eq4(contacts.id, c2.id));
+    await removeSearchIndex(db, c2.id);
+    const results = await db.select().from(contacts).where(eq4(contacts.id, c1.id));
+    const row = results[0];
+    await upsertSearchIndex(db, "contact", c1.id, await buildContactSearch(db, row));
+    console.log(c1.id);
+  });
+}
+
+// src/commands/deal.ts
+import { eq as eq5 } from "drizzle-orm";
+function registerDealCommands(program) {
+  const cmd = program.command("deal").description("Manage deals");
+  cmd.command("add").requiredOption("--title <title>", "Deal title").option("--value <n>", "Deal value").option("--stage <stage>", "Pipeline stage").option("--contact <ref>", "Contact", collect, []).option("--company <ref>", "Company").option("--expected-close <date>", "Expected close date").option("--probability <n>", "Win probability 0-100").option("--tag <tag>", "Tag", collect, []).option("--set <kv>", "Custom field", collect, []).action(async (opts) => {
+    const { db, config } = await getCtx();
+    opts.title = opts.title.trim();
+    opts.contact = opts.contact.map((c) => c.trim());
+    opts.tag = opts.tag.map((t) => t.trim());
+    if (opts.company) {
+      opts.company = opts.company.trim();
+    }
+    if (opts.stage) {
+      opts.stage = opts.stage.trim();
+    }
+    const id = makeId("dl");
+    const n = now();
+    if (opts.value !== undefined && Number(opts.value) < 0) {
+      die("Error: value must be non-negative");
+    }
+    if (opts.probability !== undefined) {
+      const prob = Number(opts.probability);
+      if (prob < 0 || prob > 100) {
+        die("Error: probability must be between 0 and 100");
+      }
+    }
+    if (opts.expectedClose) {
+      opts.expectedClose = opts.expectedClose.trim();
+      const d = new Date(opts.expectedClose);
+      if (Number.isNaN(d.getTime())) {
+        die("Error: invalid expected-close date");
+      }
+    }
+    const stage = opts.stage || config.pipeline.stages[0];
+    if (!config.pipeline.stages.includes(stage)) {
+      die(`Error: invalid stage "${stage}"`);
+    }
+    const contactIds = [];
+    for (const ref of opts.contact) {
+      const ctId = await getOrCreateContactId(db, ref, config);
+      if (!contactIds.includes(ctId)) {
+        contactIds.push(ctId);
+      }
+    }
+    let companyId = null;
+    if (opts.company) {
+      const co = await resolveCompanyForLink(db, opts.company);
+      if (co) {
+        companyId = co.id;
+      } else {
+        if (opts.company.includes(".")) {
+          die(`Error: company not found: ${opts.company}`);
+        }
+        companyId = await getOrCreateCompanyId(db, opts.company);
+      }
+    }
+    const custom = parseKV(opts.set);
+    const value = opts.value === undefined ? null : Number(opts.value);
+    const probability = opts.probability === undefined ? null : Number(opts.probability);
+    if (!runHook(config, "pre-deal-add", {
+      title: opts.title,
+      value,
+      stage,
+      contacts: contactIds,
+      company: companyId,
+      expected_close: opts.expectedClose || null,
+      probability,
+      tags: opts.tag,
+      custom_fields: custom
+    })) {
+      die("Error: pre-deal-add hook rejected creation");
+    }
+    await db.insert(deals).values({
+      id,
+      title: opts.title,
+      value,
+      stage,
+      contacts: JSON.stringify(contactIds),
+      company: companyId,
+      expected_close: opts.expectedClose || null,
+      probability,
+      tags: JSON.stringify(opts.tag),
+      custom_fields: JSON.stringify(custom),
+      created_at: n,
+      updated_at: n
+    });
+    const results = await db.select().from(deals).where(eq5(deals.id, id));
+    const row = results[0];
+    await upsertSearchIndex(db, "deal", id, buildDealSearch(row));
+    runHook(config, "post-deal-add", {
+      id,
+      title: opts.title,
+      value,
+      stage,
+      contacts: contactIds,
+      company: companyId,
+      expected_close: opts.expectedClose || null,
+      probability,
+      tags: opts.tag,
+      custom_fields: custom
+    });
+    console.log(id);
+  });
+  cmd.command("list").option("--stage <stage>").option("--min-value <n>").option("--max-value <n>").option("--contact <ref>").option("--company <ref>").option("--tag <tag>").option("--filter <expr>").option("--sort <field>").option("--reverse", "Reverse sort order").option("--limit <n>").option("--offset <n>").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let rows = (await db.select().from(deals)).map((d) => dealToRow(d));
+    if (opts.stage) {
+      rows = rows.filter((d) => d.stage === opts.stage);
+    }
+    if (opts.minValue) {
+      rows = rows.filter((d) => (d.value ?? 0) >= Number(opts.minValue));
+    }
+    if (opts.maxValue) {
+      rows = rows.filter((d) => (d.value ?? 0) <= Number(opts.maxValue));
+    }
+    if (opts.contact) {
+      const ct = await resolveContact(db, opts.contact, config);
+      if (ct) {
+        rows = rows.filter((d) => d.contacts?.includes(ct.id));
+      } else {
+        rows = [];
+      }
+    }
+    if (opts.company) {
+      const co = await resolveCompany(db, opts.company, config);
+      if (co) {
+        rows = rows.filter((d) => d.company === co.id);
+      } else {
+        rows = [];
+      }
+    }
+    if (opts.tag) {
+      rows = rows.filter((d) => d.tags?.includes(opts.tag));
+    }
+    if (opts.filter) {
+      const f = parseFilter(opts.filter);
+      rows = rows.filter((d) => applyFilter(d, f));
+    }
+    if (opts.sort) {
+      rows.sort((a, b) => {
+        const av = a[opts.sort], bv = b[opts.sort];
+        if (typeof av === "number" && typeof bv === "number") {
+          return av - bv;
+        }
+        return String(av ?? "").localeCompare(String(bv ?? ""));
+      });
+    }
+    if (opts.reverse) {
+      rows.reverse();
+    }
+    if (opts.offset) {
+      rows = rows.slice(Number(opts.offset));
+    }
+    if (opts.limit) {
+      rows = rows.slice(0, Number(opts.limit));
+    }
+    console.log(formatOutput(rows, fmt, config));
+  });
+  cmd.command("show").argument("<ref>").action(async (ref) => {
+    const { db, fmt } = await getCtx();
+    const d = await resolveDeal(db, ref);
+    if (!d) {
+      die(`Error: deal not found: ${ref}`);
+    }
+    showEntity(await dealDetail(db, d), fmt);
+  });
+  cmd.command("edit").argument("<ref>").option("--title <title>").option("--value <n>").option("--company <ref>", "Change linked company").option("--expected-close <date>", "Expected close date (YYYY-MM-DD)").option("--probability <n>", "Win probability 0-100").option("--add-contact <ref>", "", collect, []).option("--rm-contact <ref>", "", collect, []).option("--add-tag <t>", "", collect, []).option("--rm-tag <t>", "", collect, []).option("--set <kv>", "", collect, []).option("--unset <key>", "", collect, []).action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    if (opts.title) {
+      opts.title = opts.title.trim();
+    }
+    if (opts.company) {
+      opts.company = opts.company.trim();
+    }
+    opts.addContact = opts.addContact.map((c) => c.trim());
+    opts.rmContact = opts.rmContact.map((c) => c.trim());
+    opts.addTag = opts.addTag.map((t) => t.trim());
+    opts.rmTag = opts.rmTag.map((t) => t.trim());
+    const d = await resolveDeal(db, ref.trim());
+    if (!d) {
+      die(`Error: deal not found: ${ref}`);
+    }
+    const title = opts.title ?? d.title;
+    const value = opts.value === undefined ? d.value : Number(opts.value);
+    const expectedClose = opts.expectedClose ? opts.expectedClose.trim() : d.expected_close;
+    const probability = opts.probability === undefined ? d.probability : Number(opts.probability);
+    let companyId = d.company;
+    if (opts.company) {
+      companyId = await getOrCreateCompanyId(db, opts.company);
+    }
+    let contacts2 = safeJSON(d.contacts);
+    let tags = safeJSON(d.tags);
+    const custom = safeJSON(d.custom_fields);
+    for (const r of opts.addContact) {
+      const ctId = await getOrCreateContactId(db, r, config);
+      if (!contacts2.includes(ctId)) {
+        contacts2.push(ctId);
+      }
+    }
+    for (const r of opts.rmContact) {
+      const ct = await resolveContact(db, r, config);
+      if (ct) {
+        contacts2 = contacts2.filter((id) => id !== ct.id);
+      }
+    }
+    for (const t of opts.addTag) {
+      if (!tags.includes(t)) {
+        tags.push(t);
+      }
+    }
+    for (const t of opts.rmTag) {
+      tags = tags.filter((v) => v !== t);
+    }
+    const kvs = parseKV(opts.set);
+    for (const [k, v] of Object.entries(kvs)) {
+      custom[k] = v;
+    }
+    for (const k of opts.unset) {
+      delete custom[k];
+    }
+    if (!runHook(config, "pre-deal-edit", {
+      id: d.id,
+      title,
+      value,
+      contacts: contacts2,
+      tags,
+      custom_fields: custom
+    })) {
+      die("Error: pre-deal-edit hook rejected edit");
+    }
+    await db.update(deals).set({
+      title,
+      value,
+      company: companyId,
+      expected_close: expectedClose,
+      probability,
+      contacts: JSON.stringify(contacts2),
+      tags: JSON.stringify(tags),
+      custom_fields: JSON.stringify(custom),
+      updated_at: now()
+    }).where(eq5(deals.id, d.id));
+    const results = await db.select().from(deals).where(eq5(deals.id, d.id));
+    const row = results[0];
+    await upsertSearchIndex(db, "deal", d.id, buildDealSearch(row));
+    console.log(d.id);
+    runHook(config, "post-deal-edit", {
+      id: d.id,
+      title,
+      value,
+      contacts: contacts2,
+      tags,
+      custom_fields: custom
+    });
+  });
+  cmd.command("move").argument("<ref>").requiredOption("--stage <stage>", "Target stage").option("--note <text>", "Note").action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    opts.stage = opts.stage.trim();
+    if (opts.note) {
+      opts.note = opts.note.trim();
+    }
+    const d = await resolveDeal(db, ref);
+    if (!d) {
+      die(`Error: deal not found: ${ref}`);
+    }
+    if (!config.pipeline.stages.includes(opts.stage)) {
+      die(`Error: invalid stage "${opts.stage}"`);
+    }
+    if (d.stage === opts.stage) {
+      die(`Error: deal is already in stage "${opts.stage}"`);
+    }
+    const oldStage = d.stage;
+    if (!runHook(config, "pre-deal-stage-change", {
+      deal: d.id,
+      from: oldStage,
+      to: opts.stage,
+      note: opts.note
+    })) {
+      die("Error: pre-deal-stage-change hook rejected stage move");
+    }
+    const n = now();
+    await db.update(deals).set({ stage: opts.stage, updated_at: n }).where(eq5(deals.id, d.id));
+    let body = `from ${oldStage} to ${opts.stage}`;
+    if (opts.note) {
+      body += ` | ${opts.note}`;
+    }
+    const aid = makeId("ac");
+    await db.insert(activities).values({
+      id: aid,
+      type: "stage-change",
+      body,
+      deal: d.id,
+      created_at: n
+    });
+    await upsertSearchIndex(db, "activity", aid, `stage-change ${body}`);
+    console.log(d.id);
+    runHook(config, "post-deal-stage-change", {
+      deal: d.id,
+      from: oldStage,
+      to: opts.stage,
+      note: opts.note
+    });
+  });
+  cmd.command("rm").argument("<ref>").option("--force", "Skip confirmation").action(async (ref, opts) => {
+    const { db, config } = await getCtx();
+    const d = await resolveDeal(db, ref);
+    if (!d) {
+      die(`Error: deal not found: ${ref}`);
+    }
+    confirmOrForce(opts.force, `deal "${d.title}" (${d.id})`);
+    if (!runHook(config, "pre-deal-rm", {
+      id: d.id,
+      title: d.title
+    })) {
+      die("Error: pre-deal-rm hook rejected deletion");
+    }
+    await db.delete(activities).where(eq5(activities.deal, d.id));
+    await db.delete(deals).where(eq5(deals.id, d.id));
+    await removeSearchIndex(db, d.id);
+    runHook(config, "post-deal-rm", {
+      id: d.id,
+      title: d.title
+    });
+  });
+}
+function registerPipelineCommand(program) {
+  program.command("pipeline").description("Pipeline summary").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const deals2 = await db.select().from(deals);
+    const summary = config.pipeline.stages.map((stage) => ({
+      stage,
+      count: deals2.filter((d) => d.stage === stage).length,
+      value: deals2.filter((d) => d.stage === stage).reduce((s, d) => s + (d.value || 0), 0)
+    }));
+    const total = {
+      stage: "Total",
+      count: deals2.length,
+      value: deals2.reduce((s, d) => s + (d.value || 0), 0)
+    };
+    const data = [...summary, total];
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+}
+
+// src/commands/dupes.ts
+function registerDupesCommand(program) {
+  program.command("dupes").description("Find likely duplicates").option("--type <type>", "Entity type (contact or company)").option("--threshold <n>", "Similarity threshold 0-1", "0.3").option("--limit <n>", "Max results").action(async (opts) => {
+    const { db, fmt } = await getCtx();
+    const threshold = Number(opts.threshold);
+    let results = [];
+    if (!opts.type || opts.type === "contact") {
+      const contacts2 = await db.select().from(contacts);
+      for (let i = 0;i < contacts2.length; i++) {
+        for (let j = i + 1;j < contacts2.length; j++) {
+          const reasons = contactDupeReasons(contacts2[i], contacts2[j]);
+          const score = dupeScore(reasons);
+          if (score >= threshold) {
+            results.push({
+              left: contactToRow(contacts2[i]),
+              right: contactToRow(contacts2[j]),
+              reasons,
+              score
+            });
+          }
+        }
+      }
+    }
+    if (!opts.type || opts.type === "company") {
+      const companies2 = await db.select().from(companies);
+      for (let i = 0;i < companies2.length; i++) {
+        for (let j = i + 1;j < companies2.length; j++) {
+          const reasons = companyDupeReasons(companies2[i], companies2[j]);
+          const score = dupeScore(reasons);
+          if (score >= threshold) {
+            results.push({
+              left: companyToRow(companies2[i]),
+              right: companyToRow(companies2[j]),
+              reasons,
+              score
+            });
+          }
+        }
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    if (opts.limit) {
+      results = results.slice(0, Number(opts.limit));
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(results.map((r) => ({
+        left: r.left,
+        right: r.right,
+        reasons: r.reasons
+      })), null, 2));
+    } else {
+      if (results.length === 0) {
+        console.log("");
+        return;
+      }
+      const lines = results.map((r) => {
+        const lName = r.left.name || r.left.title || r.left.id;
+        const rName = r.right.name || r.right.title || r.right.id;
+        return `${lName} <-> ${rName}: ${r.reasons.join(", ")}`;
+      });
+      console.log(lines.join(`
+`));
+    }
+  });
+}
+function contactDupeReasons(a, b) {
+  const reasons = [];
+  const aName = (a.name || "").toLowerCase();
+  const bName = (b.name || "").toLowerCase();
+  const nameDistance = levenshtein(aName, bName);
+  const maxLen = Math.max(aName.length, bName.length);
+  const nameSimilarity = maxLen > 0 ? 1 - nameDistance / maxLen : 0;
+  if (nameSimilarity >= 0.5) {
+    reasons.push("similar name");
+  }
+  const aEmails = safeJSON(a.emails);
+  const bEmails = safeJSON(b.emails);
+  for (const ae of aEmails) {
+    for (const be of bEmails) {
+      if (ae.toLowerCase() === be.toLowerCase()) {
+        reasons.push("same email");
+      }
+    }
+  }
+  const aPhones = safeJSON(a.phones);
+  const bPhones = safeJSON(b.phones);
+  for (const ap of aPhones) {
+    for (const bp of bPhones) {
+      if (ap === bp) {
+        reasons.push("same phone");
+      }
+    }
+  }
+  const aCompanies = safeJSON(a.companies);
+  const bCompanies = safeJSON(b.companies);
+  for (const ac of aCompanies) {
+    for (const bc of bCompanies) {
+      if (ac.toLowerCase() === bc.toLowerCase()) {
+        reasons.push("same company");
+        break;
+      }
+    }
+  }
+  const socialFields = ["linkedin", "x", "bluesky", "telegram"];
+  for (const field of socialFields) {
+    if (a[field] && b[field]) {
+      const aVal = a[field];
+      const bVal = b[field];
+      const dist = levenshtein(aVal.toLowerCase(), bVal.toLowerCase());
+      const ml = Math.max(aVal.length, bVal.length);
+      if (ml > 0 && 1 - dist / ml >= 0.6) {
+        reasons.push(`similar ${field}`);
+      }
+    }
+  }
+  if (nameSimilarity >= 0.3) {
+    let found = false;
+    for (const ae of aEmails) {
+      if (found) {
+        break;
+      }
+      for (const be of bEmails) {
+        const aDomain = ae.split("@")[1]?.toLowerCase();
+        const bDomain = be.split("@")[1]?.toLowerCase();
+        if (aDomain && bDomain && aDomain === bDomain && !["gmail.com", "yahoo.com", "hotmail.com", "outlook.com"].includes(aDomain)) {
+          reasons.push("shared email domain");
+          found = true;
+          break;
+        }
+      }
+    }
+  }
+  return reasons;
+}
+function companyDupeReasons(a, b) {
+  const reasons = [];
+  const aName = (a.name || "").toLowerCase();
+  const bName = (b.name || "").toLowerCase();
+  const nameDistance = levenshtein(aName, bName);
+  const maxLen = Math.max(aName.length, bName.length);
+  const nameSimilarity = maxLen > 0 ? 1 - nameDistance / maxLen : 0;
+  if (nameSimilarity >= 0.5) {
+    reasons.push("similar name");
+  }
+  const aWebsites = safeJSON(a.websites);
+  const bWebsites = safeJSON(b.websites);
+  for (const aw of aWebsites) {
+    for (const bw of bWebsites) {
+      const aDomain = aw.split("/")[0];
+      const bDomain = bw.split("/")[0];
+      if (aDomain === bDomain) {
+        reasons.push("same domain");
+      }
+    }
+  }
+  return reasons;
+}
+function dupeScore(reasons) {
+  if (reasons.length === 0) {
+    return 0;
+  }
+  let score = 0;
+  for (const r of reasons) {
+    if (r === "same email" || r === "same phone") {
+      score += 0.5;
+    } else if (r === "similar name") {
+      score += 0.4;
+    } else if (r === "same company") {
+      score += 0.15;
+    } else if (r.startsWith("similar ")) {
+      score += 0.2;
+    } else if (r === "same domain") {
+      score += 0.2;
+    } else if (r === "shared email domain") {
+      score += 0.15;
+    } else {
+      score += 0.1;
+    }
+  }
+  return Math.min(score, 1);
+}
+
+// src/commands/fuse.ts
+import { spawn, spawnSync as spawnSync2 } from "node:child_process";
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir2, tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+
+// src/export-fs.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { eq as eq8 } from "drizzle-orm";
+
+// src/fuse-json.ts
+import { eq as eq6 } from "drizzle-orm";
+var LLM_TXT = `# CRM Filesystem
+
+This directory is a live view of a CRM database, powered by crm.cli.
+All data is JSON. Changes made here are written back to the database.
+
+## Structure
+
+contacts/                    → One JSON file per contact
+  _by-email/                 → Lookup by email address
+  _by-phone/                 → Lookup by E.164 phone (+12125551234.json)
+  _by-linkedin/              → Lookup by LinkedIn handle
+  _by-x/                     → Lookup by X/Twitter handle
+  _by-bluesky/               → Lookup by Bluesky handle
+  _by-telegram/              → Lookup by Telegram handle
+  _by-company/               → Contacts grouped by company name
+  _by-tag/                   → Contacts grouped by tag
+
+companies/                   → One JSON file per company
+  _by-website/               → Lookup by website domain
+  _by-phone/                 → Lookup by E.164 phone
+  _by-tag/                   → Companies grouped by tag
+
+deals/                       → One JSON file per deal
+  _by-stage/                 → Deals grouped by pipeline stage
+  _by-company/               → Deals grouped by company name
+  _by-tag/                   → Deals grouped by tag
+
+activities/                  → One JSON file per activity (note, email, call, meeting)
+  _by-contact/               → Activities grouped by contact
+  _by-company/               → Activities grouped by company
+  _by-deal/                  → Activities grouped by deal
+  _by-type/                  → Activities grouped by type
+
+reports/                     → Pre-computed analytics (pipeline, forecast, velocity, stale, won, lost, conversion)
+search/                      → Read search/<query>.json to search (filename is the query)
+pipeline.json                → Pipeline stage counts and values
+tags.json                    → All tags with usage counts
+
+## Reading data
+
+Each entity file (e.g. contacts/ct_01J8Z...jane-doe.json) is self-contained JSON
+with all fields, linked entities, and recent activity. The _by-* directories contain
+copies of the same files, organized for lookup. Use ls + cat to explore.
+
+## Writing data
+
+Write a JSON file to a top-level directory to create or update an entity:
+
+  echo '{"name":"Jane Doe","emails":["jane@acme.com"]}' > contacts/new.json
+
+The filename doesn't matter for writes — the CRM assigns an ID and renames the file.
+To update, write to the existing filename. Fields you omit are left unchanged.
+
+## Search
+
+Read a file in search/ where the filename is your query:
+
+  cat search/jane.json           → contacts/companies/deals matching "jane"
+  cat search/fintech-cto.json    → results matching "fintech-cto"
+
+## Phones
+
+Phones are stored in E.164 format (+12125551234). The _by-phone directories use E.164
+filenames. When writing, any common format is accepted and normalized automatically.
+
+## Tips for agents
+
+- Start with \`ls\` at the root to see what's available
+- Use _by-email, _by-phone, _by-linkedin for fast lookups instead of scanning all files
+- Read pipeline.json for a quick overview of deal flow
+- Read reports/ for pre-computed analytics — no need to calculate from raw data
+- All JSON files are self-contained — no need to join across files
+- The search/ directory accepts natural language queries
+`;
+function slugify(name) {
+  return (name || "unknown").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function contactFilename(c) {
+  return `${c.id}...${slugify(c.name || "")}.json`;
+}
+function companyFilename(co) {
+  return `${co.id}...${slugify(co.name || "")}.json`;
+}
+function dealFilename(d) {
+  return `${d.id}...${slugify(d.title || "")}.json`;
+}
+function activityFilename(a) {
+  const dateStr = (a.created_at || "").slice(0, 10);
+  return `${a.id}...${a.type || "unknown"}-${dateStr}.json`;
+}
+async function buildContactJSON(db, c, config) {
+  const emails = safeJSON(c.emails);
+  const phones = safeJSON(c.phones);
+  const companyIds = safeJSON(c.companies);
+  const tags = safeJSON(c.tags);
+  const customFields = safeJSON(c.custom_fields) || {};
+  const allCompanies = await db.select().from(companies);
+  const linkedCompanies = companyIds.map((id) => {
+    const co = allCompanies.find((x) => x.id === id);
+    return co ? { id: co.id, name: co.name } : { id };
+  }).filter(Boolean);
+  const allDeals = await db.select().from(deals);
+  const linkedDeals = allDeals.filter((d) => {
+    const contacts2 = safeJSON(d.contacts);
+    return contacts2.includes(c.id);
+  }).map((d) => ({ id: d.id, title: d.title, stage: d.stage, value: d.value }));
+  const activities2 = await db.select().from(activities);
+  const contactActivities = activities2.filter((a) => {
+    const contacts2 = safeJSON(a.contacts);
+    return contacts2.includes(c.id);
+  }).sort((a, b) => (b.created_at || "").localeCompare(a.created_at || "")).slice(0, config.mount.max_recent_activity).map((a) => ({
+    id: a.id,
+    type: a.type,
+    note: a.body,
+    created_at: a.created_at
+  }));
+  return {
+    id: c.id,
+    name: c.name,
+    emails,
+    phones,
+    companies: linkedCompanies,
+    linkedin: c.linkedin,
+    x: c.x,
+    bluesky: c.bluesky,
+    telegram: c.telegram,
+    tags,
+    custom_fields: Object.keys(customFields).length > 0 ? customFields : undefined,
+    deals: linkedDeals,
+    recent_activity: contactActivities,
+    created_at: c.created_at,
+    updated_at: c.updated_at
+  };
+}
+async function buildCompanyJSON(db, co) {
+  const websites = safeJSON(co.websites);
+  const phones = safeJSON(co.phones);
+  const tags = safeJSON(co.tags);
+  const customFields = safeJSON(co.custom_fields) || {};
+  const allContacts = await db.select().from(contacts);
+  const linkedContacts = allContacts.filter((c) => {
+    const companies2 = safeJSON(c.companies);
+    return companies2.includes(co.id);
+  }).map((c) => ({ id: c.id, name: c.name }));
+  const allDeals = await db.select().from(deals);
+  const linkedDeals = allDeals.filter((d) => d.company === co.id).map((d) => ({ id: d.id, title: d.title, stage: d.stage, value: d.value }));
+  return {
+    id: co.id,
+    name: co.name,
+    websites,
+    phones,
+    tags,
+    custom_fields: Object.keys(customFields).length > 0 ? customFields : undefined,
+    contacts: linkedContacts,
+    deals: linkedDeals,
+    created_at: co.created_at,
+    updated_at: co.updated_at
+  };
+}
+async function buildDealJSON(db, d) {
+  const contactIds = safeJSON(d.contacts);
+  const tags = safeJSON(d.tags);
+  const customFields = safeJSON(d.custom_fields) || {};
+  const allContacts = await db.select().from(contacts);
+  const linkedContacts = contactIds.map((id) => {
+    const c = allContacts.find((x) => x.id === id);
+    return c ? { id: c.id, name: c.name } : { id };
+  }).filter(Boolean);
+  let companyObj;
+  if (d.company) {
+    const results = await db.select().from(companies).where(eq6(companies.id, d.company));
+    if (results[0]) {
+      companyObj = { id: results[0].id, name: results[0].name };
+    }
+  }
+  const activities2 = await db.select().from(activities);
+  const stageChanges = activities2.filter((a) => a.deal === d.id && a.type === "stage-change").sort((a, b) => (a.created_at || "").localeCompare(b.created_at || "")).map((a) => ({ body: a.body, created_at: a.created_at }));
+  const firstChange = stageChanges[0];
+  let initialStage = d.stage;
+  if (firstChange?.body) {
+    const match = firstChange.body.match(/from (\S+) to/);
+    if (match) {
+      initialStage = match[1];
+    }
+  }
+  const stageHistory = [
+    { stage: initialStage, at: d.created_at },
+    ...stageChanges.map((sc) => {
+      const match = sc.body?.match(/to (\S+)/);
+      return { stage: match ? match[1] : "", at: sc.created_at };
+    })
+  ];
+  return {
+    id: d.id,
+    title: d.title,
+    value: d.value,
+    stage: d.stage,
+    contacts: linkedContacts,
+    company: companyObj,
+    expected_close: d.expected_close,
+    probability: d.probability,
+    tags,
+    custom_fields: Object.keys(customFields).length > 0 ? customFields : undefined,
+    stage_history: stageHistory,
+    created_at: d.created_at,
+    updated_at: d.updated_at
+  };
+}
+function buildActivityJSON(a) {
+  const customFields = safeJSON(a.custom_fields) || {};
+  return {
+    id: a.id,
+    type: a.type,
+    body: a.body,
+    contacts: safeJSON(a.contacts),
+    company: a.company,
+    deal: a.deal,
+    custom_fields: Object.keys(customFields).length > 0 ? customFields : undefined,
+    created_at: a.created_at
+  };
+}
+
+// src/reports.ts
+import { eq as eq7, sql as sql3 } from "drizzle-orm";
+function computePipeline(deals2, stages) {
+  return stages.map((stage) => ({
+    stage,
+    count: deals2.filter((d) => d.stage === stage).length,
+    value: deals2.filter((d) => d.stage === stage).reduce((s, d) => s + (d.value || 0), 0)
+  }));
+}
+async function computeStale(db, config, days = 30) {
+  const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+  const terminal = new Set([
+    config.pipeline.won_stage,
+    config.pipeline.lost_stage
+  ]);
+  const results = [];
+  const contacts2 = await db.select().from(contacts);
+  const allActivities = await db.select().from(activities);
+  for (const c of contacts2) {
+    const contactActivities = allActivities.filter((a) => {
+      const linked = JSON.parse(a.contacts || "[]");
+      return linked.includes(c.id);
+    });
+    const last = contactActivities.reduce((max, a) => max && max > a.created_at ? max : a.created_at, null);
+    if (!last || last < cutoff) {
+      results.push({
+        type: "contact",
+        id: c.id,
+        name: c.name,
+        last_activity: last
+      });
+    }
+  }
+  const deals2 = await db.select().from(deals);
+  for (const d of deals2) {
+    if (terminal.has(d.stage)) {
+      continue;
+    }
+    const dealActivities = allActivities.filter((a) => a.deal === d.id);
+    const last = dealActivities.reduce((max, a) => max && max > a.created_at ? max : a.created_at, null);
+    const lastTouch = last || d.created_at;
+    if (lastTouch < cutoff) {
+      results.push({
+        type: "deal",
+        id: d.id,
+        title: d.title,
+        last_activity: last
+      });
+    }
+  }
+  return results;
+}
+async function computeConversion(db, stages, since) {
+  let activities2 = await db.select().from(activities).where(eq7(activities.type, "stage-change"));
+  if (since) {
+    activities2 = activities2.filter((a) => a.created_at >= since);
+  }
+  const stageEntries = {};
+  const stageExits = {};
+  for (const s of stages) {
+    stageEntries[s] = new Set;
+    stageExits[s] = new Set;
+  }
+  const deals2 = await db.select().from(deals);
+  for (const d of deals2) {
+    const dealActivities = activities2.filter((a) => a.deal === d.id);
+    if (dealActivities.length === 0) {
+      stageEntries[d.stage]?.add(d.id);
+    } else {
+      const first = dealActivities[0];
+      const m = first.body.match(/from (\S+) to/);
+      const initialStage = m ? m[1] : d.stage;
+      if (stageEntries[initialStage]) {
+        stageEntries[initialStage].add(d.id);
+      }
+      for (const a of dealActivities) {
+        const from = a.body.match(/from (\S+) to/)?.[1];
+        const to = a.body.match(/to (\S+)/)?.[1];
+        if (from && stageExits[from]) {
+          stageExits[from].add(d.id);
+        }
+        if (to && stageEntries[to]) {
+          stageEntries[to].add(d.id);
+        }
+      }
+    }
+  }
+  return stages.map((stage) => ({
+    stage,
+    entered: stageEntries[stage].size,
+    advanced: stageExits[stage].size,
+    rate: stageEntries[stage].size > 0 ? `${Math.round(stageExits[stage].size / stageEntries[stage].size * 100)}%` : "0%"
+  }));
+}
+function formatDuration(ms) {
+  if (ms === 0) {
+    return "0s";
+  }
+  const secs = Math.floor(ms / 1000);
+  const mins = Math.floor(secs / 60);
+  const hours = Math.floor(mins / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days}d ${hours % 24}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${mins % 60}m`;
+  }
+  if (mins > 0) {
+    return `${mins}m ${secs % 60}s`;
+  }
+  return `${secs}s`;
+}
+async function computeVelocity(db, stages, wonStage) {
+  const activities2 = await db.select().from(activities).where(eq7(activities.type, "stage-change")).orderBy(activities.created_at);
+  const stageTimes = {};
+  for (const s of stages) {
+    stageTimes[s] = [];
+  }
+  const dealIds = [...new Set(activities2.map((a) => a.deal).filter(Boolean))];
+  for (const did of dealIds) {
+    if (!did) {
+      continue;
+    }
+    const dealActs = activities2.filter((a) => a.deal === did);
+    const dealResults = await db.select().from(deals).where(eq7(deals.id, did));
+    const deal = dealResults[0];
+    if (!deal) {
+      continue;
+    }
+    if (wonStage && deal.stage !== wonStage) {
+      continue;
+    }
+    let prevTime = new Date(deal.created_at).getTime();
+    const first = dealActs[0];
+    const initialStage = first.body.match(/from (\S+) to/)?.[1];
+    if (initialStage && stageTimes[initialStage]) {
+      const duration = new Date(first.created_at).getTime() - prevTime;
+      stageTimes[initialStage].push(duration);
+      prevTime = new Date(first.created_at).getTime();
+    }
+    for (let i = 1;i < dealActs.length; i++) {
+      const from = dealActs[i].body.match(/from (\S+) to/)?.[1];
+      if (from && stageTimes[from]) {
+        const duration = new Date(dealActs[i].created_at).getTime() - new Date(dealActs[i - 1].created_at).getTime();
+        stageTimes[from].push(duration);
+      }
+    }
+  }
+  return stages.map((stage) => {
+    const times = stageTimes[stage];
+    const avg = times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : 0;
+    return {
+      stage,
+      avg_ms: Math.round(avg),
+      deals: times.length,
+      avg_display: formatDuration(avg)
+    };
+  });
+}
+async function computeForecast(db, config) {
+  const terminal = new Set([
+    config.pipeline.won_stage,
+    config.pipeline.lost_stage
+  ]);
+  const deals2 = await db.select().from(deals);
+  const open = deals2.filter((d) => !terminal.has(d.stage));
+  return open.map((d) => ({
+    id: d.id,
+    title: d.title,
+    value: d.value || 0,
+    probability: d.probability ?? 100,
+    weighted: Math.round((d.value || 0) * (d.probability ?? 100) / 100),
+    expected_close: d.expected_close,
+    stage: d.stage
+  }));
+}
+async function computeWon(db, config) {
+  const wonStage = config.pipeline.won_stage;
+  const deals2 = await db.select().from(deals).where(eq7(deals.stage, wonStage));
+  return Promise.all(deals2.map(async (d) => {
+    const row = dealToRow(d);
+    row.notes = await extractStageNotes(db, d.id, wonStage);
+    return row;
+  }));
+}
+async function computeLost(db, config) {
+  const lostStage = config.pipeline.lost_stage;
+  const deals2 = await db.select().from(deals).where(eq7(deals.stage, lostStage));
+  return Promise.all(deals2.map(async (d) => {
+    const row = dealToRow(d);
+    row.notes = await extractStageNotes(db, d.id, lostStage);
+    return row;
+  }));
+}
+async function extractStageNotes(db, dealId, stage) {
+  const actResults = await db.all(sql3`SELECT body FROM activities WHERE deal = ${dealId} AND type = 'stage-change' AND body LIKE ${`%${stage}%`}`);
+  const act = actResults[0];
+  return act?.body?.split("|").slice(1).map((s) => s.trim()).join(", ") || "";
+}
+
+// src/export-fs.ts
+function writeJSON(filePath, data) {
+  writeFileSync2(filePath, JSON.stringify(data, null, 2));
+}
+function ensureDir(dir) {
+  if (!existsSync2(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+}
+async function generateFS(db, config, outDir) {
+  ensureDir(outDir);
+  ensureDir(join2(outDir, "contacts"));
+  ensureDir(join2(outDir, "contacts", "_by-email"));
+  ensureDir(join2(outDir, "contacts", "_by-phone"));
+  ensureDir(join2(outDir, "contacts", "_by-linkedin"));
+  ensureDir(join2(outDir, "contacts", "_by-x"));
+  ensureDir(join2(outDir, "contacts", "_by-bluesky"));
+  ensureDir(join2(outDir, "contacts", "_by-telegram"));
+  ensureDir(join2(outDir, "contacts", "_by-company"));
+  ensureDir(join2(outDir, "contacts", "_by-tag"));
+  ensureDir(join2(outDir, "companies"));
+  ensureDir(join2(outDir, "companies", "_by-website"));
+  ensureDir(join2(outDir, "companies", "_by-phone"));
+  ensureDir(join2(outDir, "companies", "_by-tag"));
+  ensureDir(join2(outDir, "deals"));
+  ensureDir(join2(outDir, "deals", "_by-stage"));
+  for (const stage of config.pipeline.stages) {
+    ensureDir(join2(outDir, "deals", "_by-stage", stage));
+  }
+  ensureDir(join2(outDir, "deals", "_by-company"));
+  ensureDir(join2(outDir, "deals", "_by-tag"));
+  ensureDir(join2(outDir, "activities"));
+  ensureDir(join2(outDir, "activities", "_by-contact"));
+  ensureDir(join2(outDir, "activities", "_by-company"));
+  ensureDir(join2(outDir, "activities", "_by-deal"));
+  ensureDir(join2(outDir, "activities", "_by-type"));
+  ensureDir(join2(outDir, "reports"));
+  ensureDir(join2(outDir, "search"));
+  writeFileSync2(join2(outDir, "llm.txt"), LLM_TXT);
+  const companies2 = await db.select().from(companies);
+  const contacts2 = await db.select().from(contacts);
+  for (const c of contacts2) {
+    const data = await buildContactJSON(db, c, config);
+    const filename = contactFilename(c);
+    const filePath = join2(outDir, "contacts", filename);
+    writeJSON(filePath, data);
+    const emails = safeJSON(c.emails);
+    for (const email of emails) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-email", `${email}.json`));
+    }
+    const phones = safeJSON(c.phones);
+    for (const phone of phones) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-phone", `${phone}.json`));
+    }
+    if (c.linkedin) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-linkedin", `${c.linkedin}.json`));
+    }
+    if (c.x) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-x", `${c.x}.json`));
+    }
+    if (c.bluesky) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-bluesky", `${c.bluesky}.json`));
+    }
+    if (c.telegram) {
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-telegram", `${c.telegram}.json`));
+    }
+    const companyIds = safeJSON(c.companies);
+    for (const compId of companyIds) {
+      const compRecord = companies2.find((co) => co.id === compId);
+      const compSlug = slugify(compRecord?.name || compId);
+      ensureDir(join2(outDir, "contacts", "_by-company", compSlug));
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-company", compSlug, filename));
+    }
+    const tags = safeJSON(c.tags);
+    for (const tag of tags) {
+      ensureDir(join2(outDir, "contacts", "_by-tag", tag));
+      copyFileSync(filePath, join2(outDir, "contacts", "_by-tag", tag, filename));
+    }
+  }
+  for (const co of companies2) {
+    const data = await buildCompanyJSON(db, co);
+    const filename = companyFilename(co);
+    const filePath = join2(outDir, "companies", filename);
+    writeJSON(filePath, data);
+    const websites = safeJSON(co.websites);
+    for (const website of websites) {
+      copyFileSync(filePath, join2(outDir, "companies", "_by-website", `${website}.json`));
+    }
+    const phones = safeJSON(co.phones);
+    for (const phone of phones) {
+      copyFileSync(filePath, join2(outDir, "companies", "_by-phone", `${phone}.json`));
+    }
+    const tags = safeJSON(co.tags);
+    for (const tag of tags) {
+      ensureDir(join2(outDir, "companies", "_by-tag", tag));
+      copyFileSync(filePath, join2(outDir, "companies", "_by-tag", tag, filename));
+    }
+  }
+  const deals2 = await db.select().from(deals);
+  for (const d of deals2) {
+    const data = await buildDealJSON(db, d);
+    const filename = dealFilename(d);
+    const filePath = join2(outDir, "deals", filename);
+    writeJSON(filePath, data);
+    if (d.stage) {
+      const stageDir = join2(outDir, "deals", "_by-stage", d.stage);
+      ensureDir(stageDir);
+      copyFileSync(filePath, join2(stageDir, filename));
+    }
+    if (d.company) {
+      const companyResults = await db.select().from(companies).where(eq8(companies.id, d.company));
+      if (companyResults[0]) {
+        const compSlug = slugify(companyResults[0].name || "");
+        ensureDir(join2(outDir, "deals", "_by-company", compSlug));
+        copyFileSync(filePath, join2(outDir, "deals", "_by-company", compSlug, filename));
+      }
+    }
+    const tags = safeJSON(d.tags);
+    for (const tag of tags) {
+      ensureDir(join2(outDir, "deals", "_by-tag", tag));
+      copyFileSync(filePath, join2(outDir, "deals", "_by-tag", tag, filename));
+    }
+  }
+  const activities2 = await db.select().from(activities);
+  for (const a of activities2) {
+    const data = buildActivityJSON(a);
+    const filename = activityFilename(a);
+    const filePath = join2(outDir, "activities", filename);
+    writeJSON(filePath, data);
+    const actContacts = safeJSON(a.contacts);
+    for (const contactId of actContacts) {
+      const contactResults = await db.select().from(contacts).where(eq8(contacts.id, contactId));
+      if (contactResults[0]) {
+        const contactSlug = `${contactId}...${slugify(contactResults[0].name || "")}`;
+        ensureDir(join2(outDir, "activities", "_by-contact", contactSlug));
+        copyFileSync(filePath, join2(outDir, "activities", "_by-contact", contactSlug, filename));
+      }
+    }
+    if (a.company) {
+      const companyResults = await db.select().from(companies).where(eq8(companies.id, a.company));
+      if (companyResults[0]) {
+        const compSlug = slugify(companyResults[0].name || "");
+        ensureDir(join2(outDir, "activities", "_by-company", compSlug));
+        copyFileSync(filePath, join2(outDir, "activities", "_by-company", compSlug, filename));
+      }
+    }
+    if (a.deal) {
+      ensureDir(join2(outDir, "activities", "_by-deal", a.deal));
+      copyFileSync(filePath, join2(outDir, "activities", "_by-deal", a.deal, filename));
+    }
+    if (a.type) {
+      ensureDir(join2(outDir, "activities", "_by-type", a.type));
+      copyFileSync(filePath, join2(outDir, "activities", "_by-type", a.type, filename));
+    }
+  }
+  const pipelineData = config.pipeline.stages.map((stage) => ({
+    stage,
+    count: deals2.filter((d) => d.stage === stage).length,
+    value: deals2.filter((d) => d.stage === stage).reduce((s, d) => s + (d.value || 0), 0)
+  }));
+  writeJSON(join2(outDir, "pipeline.json"), pipelineData);
+  const tagCounts = {};
+  for (const c of contacts2) {
+    for (const t of safeJSON(c.tags)) {
+      tagCounts[t] = (tagCounts[t] || 0) + 1;
+    }
+  }
+  for (const co of companies2) {
+    for (const t of safeJSON(co.tags)) {
+      tagCounts[t] = (tagCounts[t] || 0) + 1;
+    }
+  }
+  for (const d of deals2) {
+    for (const t of safeJSON(d.tags)) {
+      tagCounts[t] = (tagCounts[t] || 0) + 1;
+    }
+  }
+  const tagsData = Object.entries(tagCounts).map(([tag, count]) => ({
+    tag,
+    count
+  }));
+  writeJSON(join2(outDir, "tags.json"), tagsData);
+  writeJSON(join2(outDir, "reports", "pipeline.json"), pipelineData);
+  writeJSON(join2(outDir, "reports", "stale.json"), await computeStale(db, config));
+  writeJSON(join2(outDir, "reports", "forecast.json"), await computeForecast(db, config));
+  writeJSON(join2(outDir, "reports", "conversion.json"), await computeConversion(db, config.pipeline.stages));
+  writeJSON(join2(outDir, "reports", "velocity.json"), await computeVelocity(db, config.pipeline.stages));
+  writeJSON(join2(outDir, "reports", "won.json"), await computeWon(db, config));
+  writeJSON(join2(outDir, "reports", "lost.json"), await computeLost(db, config));
+}
+
+// src/commands/fuse.ts
+function ensureDir2(dir) {
+  if (!existsSync3(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+}
+async function mountDarwin(mp, config, _opts) {
+  const nfsHelperPath = join3(homedir2(), ".crm", "bin", "crm-nfs");
+  if (!existsSync3(nfsHelperPath)) {
+    const nfsSrcDir = join3(import.meta.dir, "..", "nfs-server");
+    if (!existsSync3(join3(nfsSrcDir, "Cargo.toml"))) {
+      die(`Error: NFS server source not found at ${nfsSrcDir}`);
+    }
+    ensureDir2(join3(homedir2(), ".crm", "bin"));
+    const cargoPath = spawnSync2("which", ["cargo"], { stdio: ["pipe", "pipe", "pipe"] }).stdout?.toString().trim() || join3(homedir2(), ".cargo", "bin", "cargo");
+    if (!existsSync3(cargoPath)) {
+      die("Error: Rust not found. Install with: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh");
+    }
+    console.log("Compiling NFS server (first time only)...");
+    const compile = spawnSync2(cargoPath, ["build", "--release", "--manifest-path", join3(nfsSrcDir, "Cargo.toml")], { stdio: ["pipe", "pipe", "pipe"] });
+    if (compile.status !== 0) {
+      die(`Error: Failed to compile NFS server.
+${compile.stderr?.toString() || ""}`);
+    }
+    const built = join3(nfsSrcDir, "target", "release", "crm-nfs");
+    spawnSync2("sh", [
+      "-c",
+      `cat "${built}" > "${nfsHelperPath}" && chmod +x "${nfsHelperPath}"`
+    ]);
+  }
+  const socketPath = join3(tmpdir(), `crm-fuse-${slugify(mp)}.sock`);
+  const daemonPath = join3(import.meta.dir, "..", "fuse-daemon.ts");
+  const daemonProc = spawn("bun", [
+    "run",
+    daemonPath,
+    socketPath,
+    config.database.path,
+    ...config.pipeline.stages
+  ], { stdio: "ignore", detached: true });
+  daemonProc.unref();
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (existsSync3(socketPath)) {
+      break;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+  if (!existsSync3(socketPath)) {
+    daemonProc.kill();
+    die("Error: FUSE daemon failed to start.");
+  }
+  const nfsProc = spawn(nfsHelperPath, [socketPath, "0"], {
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: true
+  });
+  const port = await new Promise((resolve2, reject) => {
+    let buf = "";
+    const timeout = setTimeout(() => reject(new Error("NFS server did not report port")), 5000);
+    nfsProc.stdout?.on("data", (chunk) => {
+      buf += chunk.toString();
+      const nl = buf.indexOf(`
+`);
+      if (nl !== -1) {
+        clearTimeout(timeout);
+        resolve2(Number(buf.slice(0, nl).trim()));
+      }
+    });
+    nfsProc.on("exit", (code) => {
+      clearTimeout(timeout);
+      reject(new Error(`NFS server exited with code ${code}`));
+    });
+  }).catch((err) => {
+    daemonProc.kill();
+    try {
+      nfsProc.kill();
+    } catch {}
+    die(`Error: ${err.message}`);
+    return 0;
+  });
+  nfsProc.stdout?.destroy();
+  nfsProc.stderr?.destroy();
+  nfsProc.stdin?.destroy();
+  nfsProc.unref();
+  const connDeadline = Date.now() + 3000;
+  while (Date.now() < connDeadline) {
+    try {
+      const net = await import("node:net");
+      const ok = await new Promise((resolve2) => {
+        const sock = net.createConnection({ host: "127.0.0.1", port }, () => {
+          sock.destroy();
+          resolve2(true);
+        });
+        sock.on("error", () => resolve2(false));
+      });
+      if (ok) {
+        break;
+      }
+    } catch {}
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  const mountResult = spawnSync2("/sbin/mount_nfs", [
+    "-o",
+    `locallocks,vers=3,tcp,port=${port},mountport=${port},soft,intr,timeo=10,retrans=3,noac`,
+    "127.0.0.1:/",
+    mp
+  ], { stdio: ["pipe", "pipe", "pipe"] });
+  if (mountResult.status !== 0) {
+    daemonProc.kill();
+    try {
+      nfsProc.kill();
+    } catch {}
+    die(`Error: NFS mount failed: ${mountResult.stderr?.toString() || "unknown error"}`);
+  }
+  const pidFile = join3(tmpdir(), `crm-mount-${slugify(mp)}.pid`);
+  writeFileSync3(pidFile, `${nfsProc.pid}
+${daemonProc.pid}`);
+  console.log(`Mounted at ${mp} (NFS port ${port}, PID ${nfsProc.pid})`);
+}
+async function mountLinux(mp, config, opts) {
+  const helperPath = join3(homedir2(), ".crm", "bin", "crm-fuse");
+  if (!existsSync3(helperPath)) {
+    const srcPath = join3(import.meta.dir, "..", "fuse-helper.c");
+    if (!existsSync3(srcPath)) {
+      die("Error: FUSE helper not found. Install FUSE dependencies and rebuild, or use `crm export-fs` instead.");
+    }
+    ensureDir2(join3(homedir2(), ".crm", "bin"));
+    const fuseFlags = (() => {
+      const pc3 = spawnSync2("pkg-config", ["--cflags", "--libs", "fuse3"]);
+      if (pc3.status === 0 && pc3.stdout) {
+        return pc3.stdout.toString().trim().split(/\s+/);
+      }
+      return ["-lfuse3", "-lpthread"];
+    })();
+    const compile = spawnSync2("gcc", ["-o", helperPath, srcPath, ...fuseFlags], { stdio: ["pipe", "pipe", "pipe"] });
+    if (compile.status !== 0) {
+      die(`Error: Failed to compile FUSE helper. Install libfuse3-dev (apt) or fuse3-devel (yum).
+${compile.stderr?.toString() || ""}`);
+    }
+  }
+  const socketPath = join3(tmpdir(), `crm-fuse-${slugify(mp)}.sock`);
+  const daemonPath = join3(import.meta.dir, "..", "fuse-daemon.ts");
+  const daemonProc = spawn("bun", [
+    "run",
+    daemonPath,
+    socketPath,
+    config.database.path,
+    ...config.pipeline.stages
+  ], { stdio: "ignore", detached: true });
+  daemonProc.unref();
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (existsSync3(socketPath)) {
+      break;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+  if (!existsSync3(socketPath)) {
+    daemonProc.kill();
+    die("Error: FUSE daemon failed to start.");
+  }
+  const fuseArgs = ["-f", mp, "--", socketPath];
+  if (opts.readonly || config.mount.readonly) {
+    fuseArgs.unshift("-o", "ro");
+  }
+  const fuseProc = spawn(helperPath, fuseArgs, {
+    stdio: "ignore",
+    detached: true
+  });
+  await new Promise((resolve2) => setTimeout(resolve2, 500));
+  if (fuseProc.exitCode !== null) {
+    daemonProc.kill();
+    die("Error: FUSE mount failed. Is FUSE available?");
+  }
+  fuseProc.unref();
+  const pidFile = join3(tmpdir(), `crm-mount-${slugify(mp)}.pid`);
+  writeFileSync3(pidFile, `${fuseProc.pid}
+${daemonProc.pid}`);
+  console.log(`Mounted at ${mp} (PID ${fuseProc.pid})`);
+}
+async function unmountDarwin(mp) {
+  const pidFile = join3(tmpdir(), `crm-mount-${slugify(mp)}.pid`);
+  if (existsSync3(pidFile)) {
+    const lines = readFileSync2(pidFile, "utf-8").trim().split(`
+`);
+    const serverPid = Number(lines[0]);
+    const daemonPid = lines[1] ? Number(lines[1]) : null;
+    try {
+      process.kill(serverPid, "SIGTERM");
+    } catch {}
+    const deadline = Date.now() + 2000;
+    while (Date.now() < deadline) {
+      try {
+        process.kill(serverPid, 0);
+        await new Promise((r) => setTimeout(r, 20));
+      } catch {
+        break;
+      }
+    }
+    try {
+      process.kill(serverPid, "SIGKILL");
+    } catch {}
+    await new Promise((r) => setTimeout(r, 50));
+    if (daemonPid) {
+      try {
+        process.kill(daemonPid);
+      } catch {}
+    }
+    unlinkSync(pidFile);
+  }
+  spawnSync2("umount", [mp], { stdio: ["pipe", "pipe", "pipe"] });
+}
+function unmountLinux(mp) {
+  const result = spawnSync2("fusermount", ["-u", mp], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  if (result.status !== 0) {
+    spawnSync2("umount", [mp], { stdio: ["pipe", "pipe", "pipe"] });
+  }
+  const pidFile = join3(tmpdir(), `crm-mount-${slugify(mp)}.pid`);
+  if (existsSync3(pidFile)) {
+    const pids = readFileSync2(pidFile, "utf-8").trim().split(`
+`);
+    for (const pid of pids) {
+      try {
+        process.kill(Number(pid));
+      } catch {}
+    }
+    unlinkSync(pidFile);
+  }
+  const socketPath = join3(tmpdir(), `crm-fuse-${slugify(mp)}.sock`);
+  try {
+    unlinkSync(socketPath);
+  } catch {}
+}
+function registerFuseCommands(program) {
+  program.command("mount").description("Mount CRM as virtual filesystem").argument("[mountpoint]", "Mount point directory").option("--readonly", "Mount read-only").action(async (mountpoint, opts) => {
+    const { config } = await getCtx();
+    const mp = mountpoint || config.mount.default_path;
+    if (!existsSync3(mp)) {
+      mkdirSync4(mp, { recursive: true });
+    }
+    if (process.platform === "darwin") {
+      await mountDarwin(mp, config, opts);
+    } else {
+      await mountLinux(mp, config, opts);
+    }
+  });
+  program.command("unmount").description("Unmount CRM filesystem").argument("[mountpoint]", "Mount point").action(async (mountpoint) => {
+    const { config } = await getCtx();
+    const mp = mountpoint || config.mount.default_path;
+    if (process.platform === "darwin") {
+      await unmountDarwin(mp);
+    } else {
+      await unmountLinux(mp);
+    }
+    console.log(`Unmounted ${mp}`);
+  });
+  program.command("export-fs").description("Export CRM data as static filesystem tree").argument("<dir>", "Output directory").action(async (dir) => {
+    const { db, config } = await getCtx();
+    await generateFS(db, config, dir);
+    console.log(`Exported to ${dir}`);
+  });
+}
+
+// src/commands/importexport.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { eq as eq9 } from "drizzle-orm";
+var CONTACT_FIELDS = new Set([
+  "name",
+  "email",
+  "emails",
+  "phone",
+  "phones",
+  "company",
+  "companies",
+  "tags",
+  "linkedin",
+  "x",
+  "bluesky",
+  "telegram"
+]);
+var COMPANY_FIELDS = new Set([
+  "name",
+  "website",
+  "websites",
+  "phone",
+  "phones",
+  "tags"
+]);
+var DEAL_FIELDS = new Set([
+  "title",
+  "value",
+  "stage",
+  "contacts",
+  "company",
+  "expected_close",
+  "probability",
+  "tags"
+]);
+function registerImportExportCommands(program) {
+  const imp = program.command("import").description("Import data");
+  imp.command("contacts").argument("<file>").option("--dry-run").option("--skip-errors").option("--update").action(async (file, opts) => {
+    const { db, config } = await getCtx();
+    const records = readRecords(file);
+    let imported = 0, skipped = 0, errors = 0;
+    for (const rec of records) {
+      try {
+        if (!rec.name) {
+          if (opts.skipErrors) {
+            errors++;
+            continue;
+          }
+          die("Error: row missing name");
+        }
+        const name = (rec.name || "").trim();
+        const emails = splitField(rec.email || rec.emails).map((e) => e.trim()).filter((e) => e.includes("@") && !e.startsWith("@") && !e.endsWith("@"));
+        const phones = splitField(rec.phone || rec.phones).map((p) => {
+          const n2 = tryNormalizePhone(p, config.phone.default_country);
+          return n2 || p;
+        }).filter((p) => /^\+\d+$/.test(p));
+        const companies2 = splitField(rec.company || rec.companies).map((c) => c.trim());
+        const tags = splitField(rec.tags).map((t) => t.trim());
+        let existing = null;
+        for (const e of emails) {
+          existing = await findContactByEmail(db, e);
+          if (existing) {
+            break;
+          }
+        }
+        if (existing && !opts.update) {
+          skipped++;
+          continue;
+        }
+        if (existing && opts.update) {
+          const custom2 = safeJSON(existing.custom_fields);
+          for (const [k, v] of Object.entries(rec)) {
+            if (!CONTACT_FIELDS.has(k) && v) {
+              custom2[k] = v;
+            }
+          }
+          await db.update(contacts).set({
+            name: name || existing.name,
+            custom_fields: JSON.stringify(custom2),
+            updated_at: now()
+          }).where(eq9(contacts.id, existing.id));
+          const results2 = await db.select().from(contacts).where(eq9(contacts.id, existing.id));
+          const row2 = results2[0];
+          await upsertSearchIndex(db, "contact", existing.id, await buildContactSearch(db, row2));
+          imported++;
+          continue;
+        }
+        if (opts.dryRun) {
+          console.log(`[dry-run] ${name} (${emails.join(", ")})`);
+          imported++;
+          continue;
+        }
+        const id = makeId("ct");
+        const n = now();
+        const custom = {};
+        for (const [k, v] of Object.entries(rec)) {
+          if (!CONTACT_FIELDS.has(k) && v) {
+            custom[k] = v;
+          }
+        }
+        const social = {
+          linkedin: rec.linkedin?.trim() || null,
+          x: rec.x?.trim() || null,
+          bluesky: rec.bluesky?.trim() || null,
+          telegram: rec.telegram?.trim() || null
+        };
+        await db.insert(contacts).values({
+          id,
+          name,
+          emails: JSON.stringify(emails),
+          phones: JSON.stringify(phones),
+          companies: JSON.stringify(companies2),
+          linkedin: social.linkedin,
+          x: social.x,
+          bluesky: social.bluesky,
+          telegram: social.telegram,
+          tags: JSON.stringify(tags),
+          custom_fields: JSON.stringify(custom),
+          created_at: n,
+          updated_at: n
+        });
+        const results = await db.select().from(contacts).where(eq9(contacts.id, id));
+        const row = results[0];
+        await upsertSearchIndex(db, "contact", id, await buildContactSearch(db, row));
+        imported++;
+      } catch (e) {
+        if (opts.skipErrors) {
+          errors++;
+          continue;
+        }
+        die(`Error importing row: ${e.message}`);
+      }
+    }
+    console.log(`Imported: ${imported}, skipped: ${skipped}, errors: ${errors}`);
+  });
+  imp.command("companies").argument("<file>").option("--dry-run").option("--skip-errors").action(async (file, opts) => {
+    const { db, config } = await getCtx();
+    const records = readRecords(file);
+    let imported = 0;
+    for (const rec of records) {
+      try {
+        if (!rec.name) {
+          if (opts.skipErrors) {
+            continue;
+          }
+          die("Error: company missing name");
+        }
+        rec.name = rec.name.trim();
+        const websites = splitField(rec.website || rec.websites).map((w) => {
+          try {
+            return normalizeWebsite(w);
+          } catch {
+            return w;
+          }
+        });
+        const phones = splitField(rec.phone || rec.phones).map((p) => {
+          const n2 = tryNormalizePhone(p, config.phone.default_country);
+          return n2 || p;
+        });
+        const tags = splitField(rec.tags);
+        const custom = {};
+        for (const [k, v] of Object.entries(rec)) {
+          if (!COMPANY_FIELDS.has(k) && v) {
+            custom[k] = v;
+          }
+        }
+        if (opts.dryRun) {
+          console.log(`[dry-run] ${rec.name}`);
+          imported++;
+          continue;
+        }
+        const id = makeId("co");
+        const n = now();
+        await db.insert(companies).values({
+          id,
+          name: rec.name,
+          websites: JSON.stringify(websites),
+          phones: JSON.stringify(phones),
+          tags: JSON.stringify(tags),
+          custom_fields: JSON.stringify(custom),
+          created_at: n,
+          updated_at: n
+        });
+        const results = await db.select().from(companies).where(eq9(companies.id, id));
+        const row = results[0];
+        await upsertSearchIndex(db, "company", id, buildCompanySearch(row));
+        imported++;
+      } catch (e) {
+        if (opts.skipErrors) {
+          continue;
+        }
+        die(`Error: ${e.message}`);
+      }
+    }
+    console.log(`Imported: ${imported}`);
+  });
+  imp.command("deals").argument("<file>").option("--dry-run").option("--skip-errors").action(async (file, opts) => {
+    const { db, config } = await getCtx();
+    const records = readRecords(file);
+    let imported = 0;
+    for (const rec of records) {
+      try {
+        if (!rec.title) {
+          if (opts.skipErrors) {
+            continue;
+          }
+          die("Error: deal missing title");
+        }
+        rec.title = rec.title.trim();
+        const stage = (rec.stage || config.pipeline.stages[0]).trim();
+        const value = rec.value ? Number(rec.value) : null;
+        const tags = splitField(rec.tags);
+        const custom = {};
+        for (const [k, v] of Object.entries(rec)) {
+          if (!DEAL_FIELDS.has(k) && v) {
+            custom[k] = v;
+          }
+        }
+        if (opts.dryRun) {
+          console.log(`[dry-run] ${rec.title}`);
+          imported++;
+          continue;
+        }
+        const id = makeId("dl");
+        const n = now();
+        await db.insert(deals).values({
+          id,
+          title: rec.title,
+          value,
+          stage,
+          contacts: "[]",
+          company: null,
+          expected_close: rec.expected_close || null,
+          probability: rec.probability ? Number(rec.probability) : null,
+          tags: JSON.stringify(tags),
+          custom_fields: JSON.stringify(custom),
+          created_at: n,
+          updated_at: n
+        });
+        const results = await db.select().from(deals).where(eq9(deals.id, id));
+        const row = results[0];
+        await upsertSearchIndex(db, "deal", id, buildDealSearch(row));
+        imported++;
+      } catch (e) {
+        if (opts.skipErrors) {
+          continue;
+        }
+        die(`Error: ${e.message}`);
+      }
+    }
+    console.log(`Imported: ${imported}`);
+  });
+  const exp = program.command("export").description("Export data");
+  exp.command("contacts").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const rows = (await db.select().from(contacts)).map((c) => contactToRow(c));
+    console.log(formatOutput(rows, fmt, config));
+  });
+  exp.command("companies").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const rows = (await db.select().from(companies)).map((c) => companyToRow(c));
+    console.log(formatOutput(rows, fmt, config));
+  });
+  exp.command("deals").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const rows = (await db.select().from(deals)).map((d) => dealToRow(d));
+    console.log(formatOutput(rows, fmt, config));
+  });
+  exp.command("all").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const data = {
+      contacts: (await db.select().from(contacts)).map((c) => contactToRow(c)),
+      companies: (await db.select().from(companies)).map((c) => companyToRow(c)),
+      deals: (await db.select().from(deals)).map((d) => dealToRow(d)),
+      activities: (await db.select().from(activities)).map((a) => activityToRow(a))
+    };
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(Object.entries(data).map(([k, v]) => ({ type: k, count: v.length })), fmt, config));
+    }
+  });
+}
+function readRecords(file) {
+  let raw;
+  if (file === "-") {
+    const chunks = [];
+    const fd = __require("node:fs").openSync("/dev/stdin", "r");
+    const buf = Buffer.alloc(65536);
+    let n = __require("node:fs").readSync(fd, buf);
+    while (n > 0) {
+      chunks.push(buf.subarray(0, n));
+      n = __require("node:fs").readSync(fd, buf);
+    }
+    __require("node:fs").closeSync(fd);
+    raw = Buffer.concat(chunks).toString("utf-8");
+  } else {
+    raw = readFileSync3(file, "utf-8");
+  }
+  raw = raw.trim();
+  if (!raw) {
+    return [];
+  }
+  if (raw.startsWith("[") || raw.startsWith("{")) {
+    return JSON.parse(raw);
+  }
+  return parseCSV(raw);
+}
+function splitField(val) {
+  if (!val) {
+    return [];
+  }
+  if (Array.isArray(val)) {
+    return val;
+  }
+  return val.split(",").map((s) => s.trim()).filter(Boolean);
+}
+async function findContactByEmail(db, email) {
+  const all = await db.select().from(contacts);
+  for (const c of all) {
+    const emails = safeJSON(c.emails);
+    if (emails.some((e) => e.toLowerCase() === email.toLowerCase())) {
+      return c;
+    }
+  }
+  return null;
+}
+
+// src/commands/report.ts
+import { eq as eq10 } from "drizzle-orm";
+function registerReportCommands(program) {
+  const cmd = program.command("report").description("Reports");
+  cmd.command("pipeline").action(async () => {
+    const { db, config, fmt } = await getCtx();
+    const deals2 = await db.select().from(deals);
+    const summary = computePipeline(deals2, config.pipeline.stages);
+    const total = {
+      stage: "Total",
+      count: deals2.length,
+      value: deals2.reduce((s, d) => s + (d.value || 0), 0)
+    };
+    const data = [...summary, total];
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+  cmd.command("activity").option("--by <field>", "Group by (type or contact)").option("--period <period>", "Time period (e.g. 7d, 30d)").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let activities2 = await db.select().from(activities);
+    if (opts.period) {
+      const cutoff = periodToDate(opts.period);
+      if (cutoff) {
+        activities2 = activities2.filter((a) => a.created_at >= cutoff);
+      }
+    }
+    const groupBy = opts.by || "type";
+    const groups = {};
+    for (const a of activities2) {
+      if (groupBy === "contact") {
+        const contacts2 = safeJSON(a.contacts);
+        if (contacts2.length === 0) {
+          groups.none = (groups.none || 0) + 1;
+        } else {
+          for (const cid of contacts2) {
+            groups[cid] = (groups[cid] || 0) + 1;
+          }
+        }
+      } else {
+        groups[a.type] = (groups[a.type] || 0) + 1;
+      }
+    }
+    let data;
+    if (groupBy === "contact") {
+      const dataPromises = Object.entries(groups).map(async ([contact, count]) => {
+        if (contact === "none") {
+          return { contact: "(none)", count };
+        }
+        const results = await db.select({ name: contacts.name }).from(contacts).where(eq10(contacts.id, contact));
+        const ct = results[0];
+        return { contact: ct?.name || contact, count };
+      });
+      data = await Promise.all(dataPromises);
+    } else {
+      data = Object.entries(groups).map(([type, count]) => ({ type, count }));
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+  cmd.command("stale").option("--days <n>", "Days threshold", "30").option("--type <type>", "Entity type (contact or deal)").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    const days = Number(opts.days);
+    let results = await computeStale(db, config, days);
+    if (opts.type) {
+      results = results.filter((r) => r.type === opts.type);
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      if (results.length === 0) {
+        console.log("No stale entities found.");
+        return;
+      }
+      const lines = results.map((r) => `[${r.type}] ${r.name || r.title} (${r.id}) — last: ${r.last_activity || "never"}`);
+      console.log(lines.join(`
+`));
+    }
+  });
+  cmd.command("conversion").option("--since <date>", "Only count transitions after date (YYYY-MM-DD)").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    const data = await computeConversion(db, config.pipeline.stages, opts.since);
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+  cmd.command("velocity").option("--won-only", "Only count deals that were won").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    const wonStage = opts.wonOnly ? config.pipeline.won_stage : undefined;
+    const data = await computeVelocity(db, config.pipeline.stages, wonStage);
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data.map((d) => ({
+        stage: d.stage,
+        avg_time: d.avg_display,
+        deals: d.deals
+      })), fmt, config));
+    }
+  });
+  cmd.command("forecast").option("--period <period>", "Filter by expected close month (YYYY-MM) or days (30d)").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let data = await computeForecast(db, config);
+    if (opts.period) {
+      if (opts.period.match(/^\d{4}-\d{2}$/)) {
+        data = data.filter((d) => d.expected_close?.startsWith(opts.period));
+      } else {
+        const cutoff = periodToDate(opts.period);
+        if (cutoff) {
+          data = data.filter((d) => d.expected_close && d.expected_close >= cutoff);
+        }
+      }
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+  cmd.command("won").option("--period <period>", "Time period (e.g. 30d)").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let data = await computeWon(db, config);
+    if (opts.period) {
+      const cutoff = periodToDate(opts.period);
+      if (cutoff) {
+        data = data.filter((d) => d.updated_at >= cutoff);
+      }
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+  cmd.command("lost").option("--period <period>", "Time period").action(async (opts) => {
+    const { db, config, fmt } = await getCtx();
+    let data = await computeLost(db, config);
+    if (opts.period) {
+      const cutoff = periodToDate(opts.period);
+      if (cutoff) {
+        data = data.filter((d) => d.updated_at >= cutoff);
+      }
+    }
+    if (fmt === "json") {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      console.log(formatOutput(data, fmt, config));
+    }
+  });
+}
+function periodToDate(period) {
+  const m = period.match(/^(\d+)d$/);
+  if (m) {
+    return new Date(Date.now() - Number(m[1]) * 86400000).toISOString();
+  }
+  return null;
+}
+
+// src/commands/search.ts
+import { eq as eq11, sql as sql4 } from "drizzle-orm";
+function registerSearchCommands(program) {
+  program.command("search").description("Full-text search").argument("<query>").option("--type <type>").action(async (rawQuery, opts) => {
+    const query = rawQuery.trim();
+    const { db, config, fmt } = await getCtx();
+    const results = [];
+    try {
+      const ftsRows = await db.all(sql4`SELECT * FROM search_index WHERE content MATCH ${query}`);
+      for (const fr of ftsRows) {
+        if (opts.type && fr.entity_type !== opts.type) {
+          continue;
+        }
+        const entity = await lookupEntity(db, fr.entity_type, fr.entity_id);
+        if (entity) {
+          results.push(entity);
+        }
+      }
+    } catch {
+      const likeRows = await db.all(sql4`SELECT * FROM search_index WHERE content LIKE ${`%${query}%`}`);
+      for (const fr of likeRows) {
+        if (opts.type && fr.entity_type !== opts.type) {
+          continue;
+        }
+        const entity = await lookupEntity(db, fr.entity_type, fr.entity_id);
+        if (entity) {
+          results.push(entity);
+        }
+      }
+    }
+    const capped = results.slice(0, config.mount.search_limit);
+    if (fmt === "json") {
+      console.log(JSON.stringify(capped, null, 2));
+    } else {
+      if (capped.length === 0) {
+        console.log("");
+        return;
+      }
+      const lines = capped.map((r) => {
+        if (r.type === "contact") {
+          return `[contact] ${r.name} (${r.id})`;
+        }
+        if (r.type === "company") {
+          return `[company] ${r.name} (${r.id})`;
+        }
+        if (r.type === "deal") {
+          return `[deal] ${r.title} (${r.id})`;
+        }
+        if (r.entity_type === "activity") {
+          return `[activity] ${r.body} (${r.id})`;
+        }
+        return `[${r.type}] ${r.id}`;
+      });
+      console.log(lines.join(`
+`));
+    }
+  });
+  program.command("find").description("Semantic search").argument("<query>").option("--type <type>").option("--limit <n>").option("--threshold <n>", "Minimum similarity score 0.0-1.0").action(async (rawQuery, opts) => {
+    const query = rawQuery.trim();
+    const { db, config, fmt } = await getCtx();
+    const queryWords = query.toLowerCase().split(/\s+/);
+    const allEntities = [];
+    const indexRows = await db.all(sql4`SELECT * FROM search_index`);
+    for (const row of indexRows) {
+      if (opts.type && row.entity_type !== opts.type) {
+        continue;
+      }
+      if (row.entity_type === "activity") {
+        continue;
+      }
+      const content = (row.content || "").toLowerCase();
+      let score = 0;
+      for (const w of queryWords) {
+        if (content.includes(w)) {
+          score += 1;
+        }
+      }
+      if (score > 0) {
+        const normalized = queryWords.length > 0 ? score / queryWords.length : 0;
+        allEntities.push({ ...row, score: normalized });
+      }
+    }
+    allEntities.sort((a, b) => b.score - a.score);
+    let limited = allEntities;
+    if (opts.threshold) {
+      const t = Number(opts.threshold);
+      limited = limited.filter((e) => e.score >= t);
+    }
+    const maxResults = opts.limit ? Number(opts.limit) : config.mount.search_limit;
+    limited = limited.slice(0, maxResults);
+    const resultPromises = limited.map((r) => lookupEntity(db, r.entity_type, r.entity_id));
+    const results = (await Promise.all(resultPromises)).filter(Boolean);
+    if (fmt === "json") {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      if (results.length === 0) {
+        console.log("");
+        return;
+      }
+      const lines = results.map((r) => `[${r.type}] ${r.name || r.title} (${r.id})`);
+      console.log(lines.join(`
+`));
+    }
+  });
+  const idx = program.command("index").description("Search index management");
+  idx.command("status").action(async () => {
+    const { db } = await getCtx();
+    const countRows = await db.all(sql4`SELECT entity_type, COUNT(*) as cnt FROM search_index GROUP BY entity_type`);
+    const counts = {};
+    for (const r of countRows) {
+      counts[r.entity_type] = r.cnt;
+    }
+    const contactCount = (await db.select({ cnt: sql4`COUNT(*)` }).from(contacts))[0];
+    const companyCount = (await db.select({ cnt: sql4`COUNT(*)` }).from(companies))[0];
+    const dealCount = (await db.select({ cnt: sql4`COUNT(*)` }).from(deals))[0];
+    console.log(`contacts: ${contactCount.cnt} (indexed: ${counts.contact || 0})`);
+    console.log(`companies: ${companyCount.cnt} (indexed: ${counts.company || 0})`);
+    console.log(`deals: ${dealCount.cnt} (indexed: ${counts.deal || 0})`);
+  });
+  idx.command("rebuild").action(async () => {
+    const { db } = await getCtx();
+    await rebuildSearchIndex(db);
+    console.log("Index rebuilt");
+  });
+}
+async function lookupEntity(db, entityType, id) {
+  if (entityType === "contact") {
+    const results = await db.select().from(contacts).where(eq11(contacts.id, id));
+    const c = results[0];
+    if (!c) {
+      return null;
+    }
+    return { type: "contact", ...contactToRow(c) };
+  }
+  if (entityType === "company") {
+    const results = await db.select().from(companies).where(eq11(companies.id, id));
+    const c = results[0];
+    if (!c) {
+      return null;
+    }
+    return { type: "company", ...companyToRow(c) };
+  }
+  if (entityType === "deal") {
+    const results = await db.select().from(deals).where(eq11(deals.id, id));
+    const d = results[0];
+    if (!d) {
+      return null;
+    }
+    return { type: "deal", ...dealToRow(d) };
+  }
+  if (entityType === "activity") {
+    const results = await db.select().from(activities).where(eq11(activities.id, id));
+    const a = results[0];
+    if (!a) {
+      return null;
+    }
+    const row = activityToRow(a);
+    return { entity_type: "activity", ...row };
+  }
+  return null;
+}
+
+// src/commands/tag.ts
+import { eq as eq12 } from "drizzle-orm";
+function registerTagCommands(program) {
+  program.command("tag").description("Tag an entity or list tags").argument("[args...]").option("--type <type>").action(async (args, opts) => {
+    if (args[0] === "list") {
+      return tagList(opts);
+    }
+    if (args.length < 2) {
+      die("Error: usage: tag <ref> <tags...>");
+    }
+    const ref = args[0].trim();
+    const tags = args.slice(1).map((t) => t.trim());
+    const { db, config } = await getCtx();
+    const resolved = await resolveEntity(db, ref, config);
+    if (!resolved) {
+      die(`Error: entity not found: ${ref}`);
+    }
+    const { type, entity } = resolved;
+    const existing = safeJSON(entity.tags);
+    for (const t of tags) {
+      if (!existing.includes(t)) {
+        existing.push(t);
+      }
+    }
+    if (type === "contact") {
+      await db.update(contacts).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(contacts.id, entity.id));
+    } else if (type === "company") {
+      await db.update(companies).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(companies.id, entity.id));
+    } else {
+      await db.update(deals).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(deals.id, entity.id));
+    }
+  });
+  program.command("untag").description("Remove tags from an entity").argument("<ref>").argument("<tags...>").action(async (rawRef, rawTags) => {
+    const ref = rawRef.trim();
+    const tags = rawTags.map((t) => t.trim());
+    const { db, config } = await getCtx();
+    const resolved = await resolveEntity(db, ref, config);
+    if (!resolved) {
+      die(`Error: entity not found: ${ref}`);
+    }
+    const { type, entity } = resolved;
+    let existing = safeJSON(entity.tags);
+    for (const t of tags) {
+      existing = existing.filter((v) => v !== t);
+    }
+    if (type === "contact") {
+      await db.update(contacts).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(contacts.id, entity.id));
+    } else if (type === "company") {
+      await db.update(companies).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(companies.id, entity.id));
+    } else {
+      await db.update(deals).set({ tags: JSON.stringify(existing), updated_at: now() }).where(eq12(deals.id, entity.id));
+    }
+  });
+}
+async function tagList(opts) {
+  const { db, config, fmt } = await getCtx();
+  const tagMap = {};
+  if (!opts.type || opts.type === "contact") {
+    const rows = await db.select({ tags: contacts.tags }).from(contacts);
+    for (const r of rows) {
+      const tags = safeJSON(r.tags);
+      for (const tag of tags) {
+        tagMap[tag] = (tagMap[tag] || 0) + 1;
+      }
+    }
+  }
+  if (!opts.type || opts.type === "company") {
+    const rows = await db.select({ tags: companies.tags }).from(companies);
+    for (const r of rows) {
+      const tags = safeJSON(r.tags);
+      for (const tag of tags) {
+        tagMap[tag] = (tagMap[tag] || 0) + 1;
+      }
+    }
+  }
+  if (!opts.type || opts.type === "deal") {
+    const rows = await db.select({ tags: deals.tags }).from(deals);
+    for (const r of rows) {
+      const tags = safeJSON(r.tags);
+      for (const tag of tags) {
+        tagMap[tag] = (tagMap[tag] || 0) + 1;
+      }
+    }
+  }
+  const data = Object.entries(tagMap).map(([tag, count]) => ({ tag, count }));
+  if (fmt === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(formatOutput(data, fmt, config));
+  }
+}
+
+// src/cli.ts
+var program = new Command;
+program.name("crm").description("Headless CLI-first CRM").version("0.1.0");
+program.exitOverride();
+registerContactCommands(program);
+registerCompanyCommands(program);
+registerDealCommands(program);
+registerPipelineCommand(program);
+registerLogCommand(program);
+registerActivityCommands(program);
+registerTagCommands(program);
+registerSearchCommands(program);
+registerReportCommands(program);
+registerImportExportCommands(program);
+registerDupesCommand(program);
+registerFuseCommands(program);
+try {
+  program.parse(["node", "crm", ...cleanArgv]);
+} catch (e) {
+  const err = e;
+  if (err.exitCode !== undefined && err.exitCode === 0) {
+    process.exit(0);
+  }
+  if (err.exitCode !== undefined) {
+    process.exit(err.exitCode);
+  }
+  console.error(err.message || e);
+  process.exit(1);
+}