@hasna/contacts 0.6.29 → 0.6.31

package/dist/cli/index.js

@@ -7456,6 +7456,30 @@ class ApiStore {
   constructor(client) {
     this.client = client;
   }
+  g(path, query) {
+    return this.client.transport.get(path, query ? { query } : undefined);
+  }
+  post(path, body) {
+    return this.client.transport.post(path, body);
+  }
+  patch(path, body) {
+    return this.client.transport.patch(path, body);
+  }
+  del(path, query) {
+    return this.client.transport.del(path, undefined, query ? { query } : undefined);
+  }
+  async gMaybe(path) {
+    try {
+      return await this.client.transport.get(path);
+    } catch (e) {
+      if (e && typeof e === "object" && e.status === 404)
+        return null;
+      throw e;
+    }
+  }
+  enc(id) {
+    return encodeURIComponent(String(id));
+  }
   async createContact(input) {
     const res = await this.client.create("contacts", stripUndefined(input));
     return pick(res, "contact") ?? res;
@@ -7586,74 +7610,74 @@ class ApiStore {
   async removeTagFromCompany() {
     return unavailable("removeTagFromCompany");
   }
-  async createGroup() {
-    return unavailable("createGroup");
+  async createGroup(input) {
+    return pick(await this.post("/groups", input), "group");
   }
-  async getGroup() {
-    return unavailable("getGroup");
+  async getGroup(id) {
+    return pick(await this.gMaybe(`/groups/${this.enc(id)}`), "group") ?? null;
   }
-  async listGroups() {
-    return unavailable("listGroups");
+  async listGroups(projectId) {
+    return pick(await this.g("/groups", projectId ? { project_id: projectId } : undefined), "groups") ?? [];
   }
-  async updateGroup() {
-    return unavailable("updateGroup");
+  async updateGroup(id, input) {
+    return pick(await this.patch(`/groups/${this.enc(id)}`, input), "group");
   }
-  async deleteGroup() {
-    return unavailable("deleteGroup");
+  async deleteGroup(id) {
+    await this.del(`/groups/${this.enc(id)}`);
   }
-  async addContactToGroup() {
-    return unavailable("addContactToGroup");
+  async addContactToGroup(contactId, groupId) {
+    return this.post(`/groups/${this.enc(groupId)}/contacts`, { contact_id: contactId });
   }
-  async removeContactFromGroup() {
-    return unavailable("removeContactFromGroup");
+  async removeContactFromGroup(contactId, groupId) {
+    await this.del(`/groups/${this.enc(groupId)}/contacts/${this.enc(contactId)}`);
   }
-  async listContactsInGroup() {
-    return unavailable("listContactsInGroup");
+  async listContactsInGroup(groupId) {
+    return pick(await this.g(`/groups/${this.enc(groupId)}/contacts`), "contact_ids") ?? [];
   }
-  async listGroupsForContact() {
-    return unavailable("listGroupsForContact");
+  async listGroupsForContact(contactId) {
+    return pick(await this.g(`/groups/for-contact/${this.enc(contactId)}`), "groups") ?? [];
   }
-  async addCompanyToGroup() {
-    return unavailable("addCompanyToGroup");
+  async addCompanyToGroup(companyId, groupId) {
+    return this.post(`/groups/${this.enc(groupId)}/companies`, { company_id: companyId });
   }
-  async removeCompanyFromGroup() {
-    return unavailable("removeCompanyFromGroup");
+  async removeCompanyFromGroup(companyId, groupId) {
+    await this.del(`/groups/${this.enc(groupId)}/companies/${this.enc(companyId)}`);
   }
-  async listCompaniesInGroup() {
-    return unavailable("listCompaniesInGroup");
+  async listCompaniesInGroup(groupId) {
+    return pick(await this.g(`/groups/${this.enc(groupId)}/companies`), "company_ids") ?? [];
   }
-  async listGroupsForCompany() {
-    return unavailable("listGroupsForCompany");
+  async listGroupsForCompany(companyId) {
+    return pick(await this.g(`/groups/for-company/${this.enc(companyId)}`), "groups") ?? [];
   }
-  async createRelationship() {
-    return unavailable("createRelationship");
+  async createRelationship(input) {
+    return pick(await this.post("/relationships", input), "relationship");
   }
-  async listRelationships() {
-    return unavailable("listRelationships");
+  async listRelationships(opts = {}) {
+    return pick(await this.g("/relationships", stripUndefined(opts)), "relationships") ?? [];
   }
-  async deleteRelationship() {
-    return unavailable("deleteRelationship");
+  async deleteRelationship(id) {
+    await this.del(`/relationships/${this.enc(id)}`);
   }
-  async createCompanyRelationship() {
-    return unavailable("createCompanyRelationship");
+  async createCompanyRelationship(input) {
+    return pick(await this.post("/company-relationships", input), "relationship");
   }
-  async listCompanyRelationships() {
-    return unavailable("listCompanyRelationships");
+  async listCompanyRelationships(opts = {}) {
+    return pick(await this.g("/company-relationships", stripUndefined(opts)), "relationships") ?? [];
   }
-  async deleteCompanyRelationship() {
-    return unavailable("deleteCompanyRelationship");
+  async deleteCompanyRelationship(id) {
+    await this.del(`/company-relationships/${this.enc(id)}`);
   }
-  async addNote() {
-    return unavailable("addNote");
+  async addNote(contactId, body, createdBy, companyId) {
+    return pick(await this.post("/notes", { contact_id: contactId, body, created_by: createdBy, company_id: companyId }), "note");
   }
-  async listNotes() {
-    return unavailable("listNotes");
+  async listNotes(contactId) {
+    return pick(await this.g("/notes", { contact_id: contactId }), "notes") ?? [];
   }
-  async listNotesForContactAtCompany() {
-    return unavailable("listNotesForContactAtCompany");
+  async listNotesForContactAtCompany(contactId, companyId) {
+    return pick(await this.g("/notes", { contact_id: contactId, company_id: companyId }), "notes") ?? [];
   }
-  async deleteNote() {
-    return unavailable("deleteNote");
+  async deleteNote(noteId) {
+    await this.del(`/notes/${this.enc(noteId)}`);
   }
   async listActivity() {
     return unavailable("listActivity");
@@ -7668,178 +7692,191 @@ class ApiStore {
     };
   }
   async findEmailDuplicates() {
-    return unavailable("findEmailDuplicates");
+    return pick(await this.g("/email-duplicates"), "duplicates") ?? [];
   }
   async findNameDuplicates() {
-    return unavailable("findNameDuplicates");
-  }
-  async flushForBackup() {
-    return unavailable("flushForBackup");
+    return pick(await this.g("/name-duplicates"), "duplicates") ?? [];
   }
-  async listColdContacts() {
-    return unavailable("listColdContacts");
+  async flushForBackup() {}
+  async listColdContacts(days) {
+    return pick(await this.g("/cold-contacts", { days }), "contacts") ?? [];
   }
-  async findOrCreateContact() {
-    return unavailable("findOrCreateContact");
+  async findOrCreateContact(input) {
+    const emails = (input.emails ?? []).map((e) => e.address).filter(Boolean);
+    for (const addr of emails) {
+      const c = await this.getContactByEmail(addr);
+      if (c)
+        return { contact: c, created: false };
+    }
+    const nameQuery = input.display_name ?? (input.first_name || input.last_name ? `${input.first_name ?? ""} ${input.last_name ?? ""}`.trim() : null);
+    if (nameQuery) {
+      const results = await this.searchContacts(nameQuery);
+      if (results[0])
+        return { contact: results[0], created: false };
+    }
+    return { contact: await this.createContact(input), created: true };
   }
-  async findContactsForContext() {
-    return unavailable("findContactsForContext");
+  async findContactsForContext(topic, limit) {
+    return pick(await this.g("/contacts-for-context", { topic, limit }), "contacts") ?? [];
   }
-  async listContactsNotContactedSince() {
-    return unavailable("listContactsNotContactedSince");
+  async listContactsNotContactedSince(days, limit) {
+    return pick(await this.g("/not-contacted", { days, limit }), "contacts") ?? [];
   }
-  async listFollowupDueContacts() {
-    return unavailable("listFollowupDueContacts");
+  async listFollowupDueContacts(onOrBefore) {
+    return pick(await this.g("/followup-due-contacts", { on_or_before: onOrBefore }), "contacts") ?? [];
   }
-  async logVendorCommunication() {
-    return unavailable("logVendorCommunication");
+  async logVendorCommunication(input) {
+    return pick(await this.post("/vendor-comms", input), "communication");
   }
-  async listVendorCommunications() {
-    return unavailable("listVendorCommunications");
+  async listVendorCommunications(companyId, opts = {}) {
+    return pick(await this.g("/vendor-comms", { company_id: companyId, ...stripUndefined(opts) }), "communications") ?? [];
   }
   async listMissingInvoices() {
-    return unavailable("listMissingInvoices");
+    return pick(await this.g("/vendor-comms/missing-invoices"), "communications") ?? [];
   }
   async listPendingFollowUps() {
-    return unavailable("listPendingFollowUps");
+    return pick(await this.g("/vendor-comms/pending-follow-ups"), "communications") ?? [];
   }
-  async markFollowUpDone() {
-    return unavailable("markFollowUpDone");
+  async markFollowUpDone(id) {
+    return pick(await this.post(`/vendor-comms/${this.enc(id)}/mark-done`), "communication");
   }
-  async createContactTask() {
-    return unavailable("createContactTask");
+  async createContactTask(input) {
+    return pick(await this.post("/tasks", input), "task");
   }
-  async listContactTasks() {
-    return unavailable("listContactTasks");
+  async listContactTasks(opts = {}) {
+    return pick(await this.g("/tasks", stripUndefined(opts)), "tasks") ?? [];
   }
-  async updateContactTask() {
-    return unavailable("updateContactTask");
+  async updateContactTask(id, input) {
+    return pick(await this.patch(`/tasks/${this.enc(id)}`, input), "task");
   }
-  async deleteContactTask() {
-    return unavailable("deleteContactTask");
+  async deleteContactTask(id) {
+    await this.del(`/tasks/${this.enc(id)}`);
   }
   async listOverdueTasks() {
-    return unavailable("listOverdueTasks");
+    return pick(await this.g("/tasks/overdue"), "tasks") ?? [];
   }
   async checkEscalations() {
-    return unavailable("checkEscalations");
+    return pick(await this.g("/tasks/escalations"), "escalations") ?? [];
   }
-  async createApplication() {
-    return unavailable("createApplication");
+  async createApplication(input) {
+    return pick(await this.post("/applications", input), "application");
   }
-  async listApplications() {
-    return unavailable("listApplications");
+  async listApplications(opts = {}) {
+    return pick(await this.g("/applications", stripUndefined(opts)), "applications") ?? [];
   }
-  async updateApplication() {
-    return unavailable("updateApplication");
+  async updateApplication(id, input) {
+    return pick(await this.patch(`/applications/${this.enc(id)}`, input), "application");
   }
   async listFollowUpDueApplications() {
-    return unavailable("listFollowUpDueApplications");
+    return pick(await this.g("/applications/follow-up-due"), "applications") ?? [];
   }
-  async addOrgMember() {
-    return unavailable("addOrgMember");
+  async addOrgMember(input) {
+    return pick(await this.post("/org-members", input), "org_member");
   }
-  async listOrgMembers() {
-    return unavailable("listOrgMembers");
+  async listOrgMembers(companyId) {
+    return pick(await this.g("/org-members", { company_id: companyId }), "org_members") ?? [];
   }
-  async updateOrgMember() {
-    return unavailable("updateOrgMember");
+  async updateOrgMember(id, input) {
+    return pick(await this.patch(`/org-members/${this.enc(id)}`, input), "org_member");
   }
-  async removeOrgMember() {
-    return unavailable("removeOrgMember");
+  async removeOrgMember(id) {
+    await this.del(`/org-members/${this.enc(id)}`);
   }
-  async listOrgMembersForContact() {
-    return unavailable("listOrgMembersForContact");
+  async listOrgMembersForContact(contactId) {
+    return pick(await this.g("/org-members", { contact_id: contactId }), "org_members") ?? [];
   }
-  async createDeal() {
-    return unavailable("createDeal");
+  async createDeal(input) {
+    return pick(await this.post("/deals", input), "deal");
   }
-  async getDeal() {
-    return unavailable("getDeal");
+  async getDeal(id) {
+    return pick(await this.gMaybe(`/deals/${this.enc(id)}`), "deal") ?? null;
   }
-  async listDeals() {
-    return unavailable("listDeals");
+  async listDeals(opts = {}) {
+    return pick(await this.g("/deals", stripUndefined(opts)), "deals") ?? [];
   }
-  async updateDeal() {
-    return unavailable("updateDeal");
+  async updateDeal(id, input) {
+    return pick(await this.patch(`/deals/${this.enc(id)}`, input), "deal") ?? null;
   }
-  async deleteDeal() {
-    return unavailable("deleteDeal");
+  async deleteDeal(id) {
+    await this.del(`/deals/${this.enc(id)}`);
   }
-  async logEvent() {
-    return unavailable("logEvent");
+  async logEvent(input) {
+    return pick(await this.post("/events", input), "event");
   }
-  async listEvents() {
-    return unavailable("listEvents");
+  async listEvents(opts = {}) {
+    return pick(await this.g("/events", stripUndefined(opts)), "events") ?? [];
   }
-  async deleteEvent() {
-    return unavailable("deleteEvent");
+  async deleteEvent(id) {
+    await this.del(`/events/${this.enc(id)}`);
   }
-  async getFieldHistory() {
-    return unavailable("getFieldHistory");
+  async getFieldHistory(contactId, fieldName) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/field-history`, fieldName ? { field_name: fieldName } : undefined), "history") ?? [];
   }
-  async getContactAt() {
-    return unavailable("getContactAt");
+  async getContactAt(contactId, timestamp) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/field-at`, { timestamp }), "fields") ?? {};
   }
-  async addJobEntry() {
-    return unavailable("addJobEntry");
+  async addJobEntry(contactId, input) {
+    return pick(await this.post(`/contacts/${this.enc(contactId)}/job-history`, input), "job");
   }
-  async getJobHistory() {
-    return unavailable("getJobHistory");
+  async getJobHistory(contactId) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/job-history`), "job_history") ?? [];
   }
-  async saveLearning() {
-    return unavailable("saveLearning");
+  async saveLearning(contactId, input) {
+    return pick(await this.post(`/contacts/${this.enc(contactId)}/learnings`, input), "learning");
   }
-  async getLearnings() {
-    return unavailable("getLearnings");
+  async getLearnings(contactId, opts = {}) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/learnings`, stripUndefined(opts)), "learnings") ?? [];
   }
-  async searchLearnings() {
-    return unavailable("searchLearnings");
+  async searchLearnings(query, opts = {}) {
+    return pick(await this.g("/learnings/search", { q: query, ...stripUndefined(opts) }), "learnings") ?? [];
   }
-  async confirmLearning() {
-    return unavailable("confirmLearning");
+  async confirmLearning(learningId) {
+    await this.post(`/learnings/${this.enc(learningId)}/confirm`);
   }
-  async getStaleLearnings() {
-    return unavailable("getStaleLearnings");
+  async getStaleLearnings(daysOld, minConfidence) {
+    return pick(await this.g("/learnings/stale", { days_old: daysOld, min_confidence: minConfidence }), "learnings") ?? [];
   }
   async runLearningMaintenance() {
-    return unavailable("runLearningMaintenance");
+    const r = await this.post("/learnings/maintenance");
+    return { decayed_count: Number(r?.decayed_count ?? 0), potential_contradictions: r?.potential_contradictions ?? [] };
   }
-  async acquireContactLock() {
-    return unavailable("acquireContactLock");
+  async acquireContactLock(contactId, agentName, ttlSeconds, reason, sessionId) {
+    return this.post("/locks", { contact_id: contactId, agent_name: agentName, ttl_seconds: ttlSeconds, reason, session_id: sessionId });
   }
-  async releaseContactLock() {
-    return unavailable("releaseContactLock");
+  async releaseContactLock(contactId, agentName) {
+    const r = await this.del(`/locks/${this.enc(contactId)}`, { agent_name: agentName });
+    return Boolean(r?.released);
   }
-  async checkContactLock() {
-    return unavailable("checkContactLock");
+  async checkContactLock(contactId) {
+    return pick(await this.g(`/locks/${this.enc(contactId)}`), "lock") ?? null;
   }
-  async logAgentActivity() {
-    return unavailable("logAgentActivity");
+  async logAgentActivity(contactId, agentName, action, details, sessionId) {
+    await this.post("/activity", { contact_id: contactId, agent_name: agentName, action, details, session_id: sessionId });
   }
-  async getAgentActivity() {
-    return unavailable("getAgentActivity");
+  async getAgentActivity(contactId, limit) {
+    return pick(await this.g("/activity", { contact_id: contactId, limit }), "activity") ?? [];
   }
-  async computeRelationshipStrength() {
-    return unavailable("computeRelationshipStrength");
+  async computeRelationshipStrength(contactId) {
+    const r = await this.g(`/graph/strength/${this.enc(contactId)}`);
+    return Number(r?.strength ?? 0);
   }
-  async findWarmPath() {
-    return unavailable("findWarmPath");
+  async findWarmPath(fromContactId, toContactId) {
+    return pick(await this.g("/graph/warm-path", { from: fromContactId, to: toContactId }), "path") ?? [];
   }
-  async findConnectionsAtCompany() {
-    return unavailable("findConnectionsAtCompany");
+  async findConnectionsAtCompany(companyId) {
+    return pick(await this.g(`/graph/company/${this.enc(companyId)}`), "connections") ?? [];
   }
   async detectCoolingRelationships() {
-    return unavailable("detectCoolingRelationships");
+    return pick(await this.g("/graph/cooling"), "cooling") ?? [];
   }
-  async resolveContactIdentity() {
-    return unavailable("resolveContactIdentity");
+  async resolveContactIdentity(partial) {
+    return pick(await this.post("/identity/resolve", partial), "matches") ?? [];
   }
-  async addContactIdentity() {
-    return unavailable("addContactIdentity");
+  async addContactIdentity(contactId, system, externalId, externalUrl, confidence = "inferred") {
+    return pick(await this.post("/identity", { contact_id: contactId, system, external_id: externalId, external_url: externalUrl, confidence }), "identity");
   }
-  async getContactIdentities() {
-    return unavailable("getContactIdentities");
+  async getContactIdentities(contactId) {
+    return pick(await this.g("/identity", { contact_id: contactId }), "identities") ?? [];
   }
   async semanticSearch() {
     return unavailable("semanticSearch");
@@ -7850,44 +7887,45 @@ class ApiStore {
   async embedAllContacts() {
     return unavailable("embedAllContacts");
   }
-  async getRelationshipSignals() {
-    return unavailable("getRelationshipSignals");
+  async getRelationshipSignals(contactId) {
+    return pick(await this.g("/signals", { contact_id: contactId }), "signals") ?? [];
   }
   async getGhostContacts() {
-    return unavailable("getGhostContacts");
+    return pick(await this.g("/signals/ghost"), "signals") ?? [];
   }
   async getWarmingContacts() {
-    return unavailable("getWarmingContacts");
+    return pick(await this.g("/signals/warming"), "signals") ?? [];
   }
   async recomputeSignals() {
-    return unavailable("recomputeSignals");
+    const r = await this.post("/signals/recompute");
+    return { updated: Number(r?.updated ?? 0) };
   }
-  async getFreshnessScore() {
-    return unavailable("getFreshnessScore");
+  async getFreshnessScore(contactId) {
+    return pick(await this.g(`/freshness/${this.enc(contactId)}`), "freshness");
   }
-  async getStaleContacts() {
-    return unavailable("getStaleContacts");
+  async getStaleContacts(threshold) {
+    return pick(await this.g("/freshness/stale", { threshold }), "contacts") ?? [];
   }
-  async markFieldVerified() {
-    return unavailable("markFieldVerified");
+  async markFieldVerified(contactId, fieldName, source) {
+    await this.post("/freshness/verify", { contact_id: contactId, field_name: fieldName, source });
   }
-  async addOrgChartEdge() {
-    return unavailable("addOrgChartEdge");
+  async addOrgChartEdge(companyId, contactAId, contactBId, edgeType, inferred = false) {
+    return pick(await this.post("/org-chart", { company_id: companyId, contact_a_id: contactAId, contact_b_id: contactBId, edge_type: edgeType, inferred }), "edge");
   }
-  async listOrgChart() {
-    return unavailable("listOrgChart");
+  async listOrgChart(companyId) {
+    return pick(await this.g("/org-chart", { company_id: companyId }), "edges") ?? [];
   }
-  async setDealContactRole() {
-    return unavailable("setDealContactRole");
+  async setDealContactRole(dealId, contactId, accountRole) {
+    return pick(await this.post(`/deals/${this.enc(dealId)}/roles`, { contact_id: contactId, account_role: accountRole }), "role");
   }
-  async getDealTeam() {
-    return unavailable("getDealTeam");
+  async getDealTeam(dealId) {
+    return pick(await this.g(`/deals/${this.enc(dealId)}/team`), "team") ?? [];
   }
-  async getCoverageGaps() {
-    return unavailable("getCoverageGaps");
+  async getCoverageGaps(companyId) {
+    return pick(await this.g(`/org-chart/coverage/${this.enc(companyId)}`), "coverage");
   }
-  async getRecentContactEvents() {
-    return unavailable("getRecentContactEvents");
+  async getRecentContactEvents(since, eventTypes) {
+    return pick(await this.g("/recent-events", { since, types: eventTypes?.length ? eventTypes.join(",") : undefined }), "events") ?? [];
   }
   async addDocument() {
     return unavailable("addDocument");
@@ -7913,65 +7951,66 @@ class ApiStore {
   async deleteHealthData() {
     return unavailable("deleteHealthData");
   }
-  async createAudience() {
-    return unavailable("createAudience");
+  async createAudience(input) {
+    return pick(await this.post("/audiences", input), "audience");
   }
-  async getAudience() {
-    return unavailable("getAudience");
+  async getAudience(idOrSlug) {
+    return pick(await this.g(`/audiences/${this.enc(idOrSlug)}`), "audience");
   }
   async listAudiences() {
-    return unavailable("listAudiences");
+    return pick(await this.g("/audiences"), "audiences") ?? [];
   }
-  async updateAudience() {
-    return unavailable("updateAudience");
+  async updateAudience(idOrSlug, input) {
+    return pick(await this.patch(`/audiences/${this.enc(idOrSlug)}`, input), "audience");
   }
-  async deleteAudience() {
-    return unavailable("deleteAudience");
+  async deleteAudience(idOrSlug) {
+    await this.del(`/audiences/${this.enc(idOrSlug)}`);
   }
-  async resolveAudience() {
-    return unavailable("resolveAudience");
+  async resolveAudience(idOrSlug, channel) {
+    return pick(await this.g(`/audiences/${this.enc(idOrSlug)}/resolve`, { channel }), "resolution");
   }
-  async setContactConsent() {
-    return unavailable("setContactConsent");
+  async setContactConsent(contactId, channel, status, source) {
+    return pick(await this.post("/consent", { contact_id: contactId, channel, status, source }), "consent");
   }
-  async listContactConsent() {
-    return unavailable("listContactConsent");
+  async listContactConsent(contactId) {
+    return pick(await this.g("/consent", { contact_id: contactId }), "consent") ?? [];
   }
-  async suppressAddress() {
-    return unavailable("suppressAddress");
+  async suppressAddress(input) {
+    return pick(await this.post("/suppressions", input), "suppression");
   }
-  async unsuppressAddress() {
-    return unavailable("unsuppressAddress");
+  async unsuppressAddress(channel, address) {
+    await this.del("/suppressions", { channel, address });
   }
-  async listSuppressions() {
-    return unavailable("listSuppressions");
+  async listSuppressions(opts = {}) {
+    return pick(await this.g("/suppressions", stripUndefined(opts)), "suppressions") ?? [];
   }
   async syncSuppressions() {
     return unavailable("syncSuppressions");
   }
-  async generateBrief() {
-    return unavailable("generateBrief");
+  async generateBrief(contactId) {
+    const r = await this.g(`/contacts/${this.enc(contactId)}/brief-text`);
+    return String(r?.text ?? "");
   }
-  async getContactCard() {
-    return unavailable("getContactCard");
+  async getContactCard(contactId) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/card`), "card");
   }
-  async getContactBrief() {
-    return unavailable("getContactBrief");
+  async getContactBrief(contactId, taskContext) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/brief`, taskContext ? { context: taskContext } : undefined), "brief");
   }
-  async assembleContext() {
-    return unavailable("assembleContext");
+  async assembleContext(contactIds, format) {
+    return pick(await this.post("/assemble-context", { contact_ids: contactIds, format }), "context");
   }
-  async getUpcomingItems() {
-    return unavailable("getUpcomingItems");
+  async getUpcomingItems(days) {
+    return pick(await this.g("/upcoming", { days }), "items") ?? [];
   }
   async getNetworkStats() {
-    return unavailable("getNetworkStats");
+    return pick(await this.g("/network-stats"), "stats");
   }
   async listContactAudit() {
-    return unavailable("listContactAudit");
+    return pick(await this.g("/contact-audit"), "audit") ?? [];
   }
-  async getContactTimeline() {
-    return unavailable("getContactTimeline");
+  async getContactTimeline(contactId, limit) {
+    return pick(await this.g(`/contacts/${this.enc(contactId)}/timeline`, { limit }), "timeline") ?? [];
   }
   async ingestMeetingParticipants() {
     return unavailable("ingestMeetingParticipants");
@@ -8001,13 +8040,13 @@ class ApiStore {
     return unavailable("lockVault");
   }
   async isVaultInitialized() {
-    return unavailable("isVaultInitialized");
+    return false;
   }
   async isVaultUnlocked() {
-    return unavailable("isVaultUnlocked");
+    return false;
   }
   async vaultStatus() {
-    return unavailable("vaultStatus");
+    return pick(await this.g("/vault-status"), "vault") ?? { initialized: false, unlocked: false, document_count: 0 };
   }
   async saveFeedback() {
     return unavailable("saveFeedback");
@@ -8016,7 +8055,7 @@ class ApiStore {
     return null;
   }
   async listActiveWebhooks() {
-    return unavailable("listActiveWebhooks");
+    return [];
   }
 }
 function getStore(env = process.env) {
@@ -17305,6 +17344,32 @@ function iso(value) {
     return value.toISOString();
   return typeof value === "string" ? value : String(value ?? "");
 }
+function isoOrNull(value) {
+  if (value === null || value === undefined)
+    return null;
+  return iso(value);
+}
+function pj(value, fallback) {
+  if (value === null || value === undefined)
+    return fallback;
+  if (typeof value === "string") {
+    if (value === "")
+      return fallback;
+    try {
+      const parsed = JSON.parse(value);
+      return parsed ?? fallback;
+    } catch {
+      return fallback;
+    }
+  }
+  return value;
+}
+function newUuid() {
+  return crypto.randomUUID();
+}
+function nowIso() {
+  return new Date().toISOString();
+}
 function parseJson(value) {
   if (!value)
     return {};
@@ -17602,115 +17667,1484 @@ class ContactsPgStore {
       tags: Number(row?.tags ?? 0)
     };
   }
-}
-function getContactsPgStore(client) {
-  if (!cachedStore2)
-    cachedStore2 = new ContactsPgStore(client);
-  return cachedStore2;
-}
-var cachedStore2 = null;
-
-// src/server/v1.ts
-function json5(body, status = 200) {
-  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
-}
-function error(status, message, extra) {
-  return json5({ error: message, ...extra ?? {} }, status);
-}
-async function readJson(req) {
-  try {
-    const text = await req.text();
-    if (!text)
-      return {};
-    return JSON.parse(text);
-  } catch {
-    return null;
+  async loadDetails(contact) {
+    const [emails, phones, tags, company] = await Promise.all([
+      this.client.many(`SELECT * FROM emails WHERE contact_id = $1`, [contact.id]),
+      this.client.many(`SELECT * FROM phones WHERE contact_id = $1`, [contact.id]),
+      this.client.many(`SELECT t.* FROM tags t JOIN contact_tags ct ON ct.tag_id = t.id WHERE ct.contact_id = $1`, [contact.id]),
+      contact.company_id ? this.client.get(`SELECT * FROM companies WHERE id = $1`, [contact.company_id]) : Promise.resolve(null)
+    ]);
+    return {
+      ...contact,
+      emails: emails.map((e) => ({ ...e, is_primary: Boolean(e.is_primary), created_at: isoOrNull(e.created_at) })),
+      phones: phones.map((p) => ({ ...p, is_primary: Boolean(p.is_primary), created_at: isoOrNull(p.created_at) })),
+      addresses: [],
+      social_profiles: [],
+      tags: tags.map((t) => mapTag(t)),
+      company: company ? mapCompany(company) : null
+    };
   }
-}
-async function handleV1Request(req, url) {
-  const path = url.pathname;
-  if (path !== "/v1" && !path.startsWith("/v1/"))
-    return null;
-  const method = req.method.toUpperCase();
-  const isWrite = method !== "GET" && method !== "HEAD";
-  const requiredScopes = [isWrite ? `${CONTACTS_APP_SLUG}:write` : `${CONTACTS_APP_SLUG}:read`];
-  let verifier;
-  try {
-    verifier = getCloudVerifier();
-  } catch (e) {
-    return error(503, e.message);
+  async searchContacts(q) {
+    const rows = await this.client.many(`SELECT * FROM contacts WHERE search_vector @@ plainto_tsquery('simple', $1) OR display_name ILIKE $2 ORDER BY display_name ASC LIMIT 50`, [q, `%${q}%`]);
+    return Promise.all(rows.map((r) => this.loadDetails(mapContact(r))));
   }
-  const decision = await verifier.authenticate(req.headers, { method, path, requiredScopes });
-  if (!decision.ok) {
-    return error(decision.status, decision.message, { reason: decision.reason });
+  async listColdContacts(days) {
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    const rows = await this.client.many(`SELECT * FROM contacts
+        WHERE archived = false AND do_not_contact = false
+          AND (last_contacted_at IS NULL OR last_contacted_at < $1)
+        ORDER BY last_contacted_at ASC NULLS FIRST LIMIT 100`, [cutoff]);
+    return Promise.all(rows.map((r) => this.loadDetails(mapContact(r))));
   }
-  await ensureCloudSchemaBestEffort();
-  const store = getContactsPgStore(getCloudClient());
-  const segments = path.split("/").filter(Boolean);
-  const resource = segments[1];
-  const id = segments[2];
-  try {
-    if (resource === "contacts") {
-      if (!id) {
-        if (method === "GET") {
-          const result = await store.listContacts({
-            ...url.searchParams.get("company_id") ? { company_id: url.searchParams.get("company_id") } : {},
-            ...url.searchParams.get("status") ? { status: url.searchParams.get("status") } : {},
-            ...url.searchParams.get("q") ? { q: url.searchParams.get("q") } : {},
-            ...url.searchParams.get("limit") ? { limit: Number(url.searchParams.get("limit")) } : {},
-            ...url.searchParams.get("offset") ? { offset: Number(url.searchParams.get("offset")) } : {}
-          });
-          return json5(result);
-        }
-        if (method === "POST") {
-          const body = await readJson(req);
-          if (!body)
-            return error(400, "invalid JSON body");
-          const contact = await store.createContact(body);
-          return json5({ contact }, 201);
-        }
-        return error(405, `method ${method} not allowed on /v1/contacts`);
-      }
-      if (method === "GET") {
-        const contact = await store.getContact(id);
-        return contact ? json5({ contact }) : error(404, "contact not found");
-      }
-      if (method === "PATCH" || method === "PUT") {
-        const body = await readJson(req);
-        if (!body)
-          return error(400, "invalid JSON body");
-        const contact = await store.updateContact(id, body);
-        return contact ? json5({ contact }) : error(404, "contact not found");
-      }
-      if (method === "DELETE") {
-        const deleted = await store.deleteContact(id);
-        return deleted ? json5({ deleted: true, id }) : error(404, "contact not found");
+  async listContactsNotContactedSince(days, limit) {
+    const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+    return this.client.many(`SELECT id, display_name, last_contacted_at FROM contacts
+        WHERE (last_contacted_at IS NULL OR last_contacted_at < $1) AND archived = false LIMIT $2`, [cutoff, Math.max(1, limit)]);
+  }
+  async listFollowupDueContacts(onOrBefore) {
+    return this.client.many(`SELECT id, display_name, follow_up_at FROM contacts
+        WHERE follow_up_at IS NOT NULL AND follow_up_at <= $1 AND archived = false`, [onOrBefore]);
+  }
+  async findContactsForContext(topic, limit) {
+    const like = `%${topic}%`;
+    const [byTitle, byNotes, byCompany, bySpec] = await Promise.all([
+      this.client.many(`SELECT c.id, c.display_name, c.job_title, 'job_title' AS reason FROM contacts c WHERE c.job_title ILIKE $1 AND c.archived = false LIMIT 20`, [like]),
+      this.client.many(`SELECT c.id, c.display_name, c.job_title, 'notes' AS reason FROM contacts c WHERE c.notes ILIKE $1 AND c.archived = false LIMIT 10`, [like]),
+      this.client.many(`SELECT c.id, c.display_name, c.job_title, 'company' AS reason FROM contacts c JOIN companies co ON c.company_id = co.id WHERE (co.name ILIKE $1 OR co.industry ILIKE $1) AND c.archived = false LIMIT 10`, [like]),
+      this.client.many(`SELECT c.id, c.display_name, c.job_title, om.specialization AS reason FROM contacts c JOIN org_members om ON c.id = om.contact_id WHERE om.specialization ILIKE $1 LIMIT 10`, [like])
+    ]);
+    const seen = new Set;
+    return [...byTitle, ...bySpec, ...byCompany, ...byNotes].filter((r) => {
+      if (seen.has(r.id))
+        return false;
+      seen.add(r.id);
+      return true;
+    }).slice(0, limit);
+  }
+  async findEmailDuplicates() {
+    const rows = await this.client.many(`SELECT MIN(e.address) AS email, string_agg(e.contact_id, ',') AS ids
+        FROM emails e WHERE e.contact_id IS NOT NULL
+        GROUP BY LOWER(e.address) HAVING COUNT(*) > 1`);
+    return rows.map((r) => ({ email: r.email, contact_ids: (r.ids ?? "").split(",").filter(Boolean) }));
+  }
+  async findNameDuplicates() {
+    const contacts = await this.client.many(`SELECT id, display_name FROM contacts`);
+    const lev = (a, b) => {
+      const m = a.length, n = b.length;
+      const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0));
+      for (let i = 1;i <= m; i++)
+        for (let j = 1;j <= n; j++)
+          dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+      return dp[m][n];
+    };
+    const pairs = [];
+    for (let i = 0;i < contacts.length; i++) {
+      for (let j = i + 1;j < contacts.length; j++) {
+        const dist = lev(contacts[i].display_name.toLowerCase(), contacts[j].display_name.toLowerCase());
+        if (dist <= 2 && dist > 0)
+          pairs.push({ contact_ids: [contacts[i].id, contacts[j].id], similarity: dist });
       }
-      return error(405, `method ${method} not allowed on /v1/contacts/:id`);
     }
-    if (resource === "companies") {
-      if (!id) {
-        if (method === "GET") {
-          const result = await store.listCompanies({
-            ...url.searchParams.get("industry") ? { industry: url.searchParams.get("industry") } : {},
-            ...url.searchParams.get("limit") ? { limit: Number(url.searchParams.get("limit")) } : {},
-            ...url.searchParams.get("offset") ? { offset: Number(url.searchParams.get("offset")) } : {}
-          });
-          return json5(result);
-        }
-        if (method === "POST") {
-          const body = await readJson(req);
-          if (!body || typeof body.name !== "string" || !body.name.trim()) {
-            return error(400, "name is required");
-          }
-          const company = await store.createCompany(body);
-          return json5({ company }, 201);
-        }
-        return error(405, `method ${method} not allowed on /v1/companies`);
-      }
-      if (method === "GET") {
-        const company = await store.getCompany(id);
-        return company ? json5({ company }) : error(404, "company not found");
+    return pairs;
+  }
+  async getRecentContactEvents(since, eventTypes) {
+    const params = [];
+    let sql = `SELECT * FROM activity_log WHERE 1=1`;
+    if (since) {
+      params.push(since);
+      sql += ` AND created_at >= $${params.length}`;
+    }
+    if (eventTypes?.length) {
+      const placeholders = eventTypes.map((_, i) => `$${params.length + i + 1}`);
+      params.push(...eventTypes);
+      sql += ` AND action IN (${placeholders.join(",")})`;
+    }
+    sql += ` ORDER BY created_at DESC LIMIT 100`;
+    const rows = await this.client.many(sql, params);
+    return rows.map((r) => ({ ...r, created_at: isoOrNull(r.created_at) }));
+  }
+  mapDeal(r) {
+    return { id: r.id, title: r.title, contact_id: r.contact_id, company_id: r.company_id, stage: r.stage, value_usd: r.value_usd, currency: r.currency, close_date: r.close_date, notes: r.notes, created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
+  }
+  async createDeal(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO deals (id, title, contact_id, company_id, stage, value_usd, currency, close_date, notes)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) RETURNING *`, [id, input.title, input.contact_id ?? null, input.company_id ?? null, input.stage ?? "lead", input.value_usd ?? null, input.currency ?? "USD", input.close_date ?? null, input.notes ?? null]);
+    return this.mapDeal(row);
+  }
+  async getDeal(id) {
+    const row = await this.client.get(`SELECT * FROM deals WHERE id = $1`, [id]);
+    return row ? this.mapDeal(row) : null;
+  }
+  async listDeals(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.stage) {
+      params.push(opts.stage);
+      where.push(`stage = $${params.length}`);
+    }
+    if (opts.contact_id) {
+      params.push(opts.contact_id);
+      where.push(`contact_id = $${params.length}`);
+    }
+    if (opts.company_id) {
+      params.push(opts.company_id);
+      where.push(`company_id = $${params.length}`);
+    }
+    const sql = `SELECT * FROM deals ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at DESC`;
+    return (await this.client.many(sql, params)).map((r) => this.mapDeal(r));
+  }
+  async updateDeal(id, input) {
+    const existing = await this.getDeal(id);
+    if (!existing)
+      return null;
+    const cols = ["title", "contact_id", "company_id", "stage", "value_usd", "currency", "close_date", "notes"];
+    const sets = [];
+    const params = [id];
+    for (const c of cols)
+      if (c in input) {
+        params.push(input[c] ?? null);
+        sets.push(`${c} = $${params.length}`);
+      }
+    sets.push(`updated_at = NOW()`);
+    const row = await this.client.get(`UPDATE deals SET ${sets.join(", ")} WHERE id = $1 RETURNING *`, params);
+    return row ? this.mapDeal(row) : null;
+  }
+  async deleteDeal(id) {
+    return (await this.client.query(`DELETE FROM deals WHERE id = $1`, [id])).rowCount > 0;
+  }
+  mapEvent(r) {
+    return { id: r.id, title: r.title, type: r.type, event_date: r.event_date, duration_min: r.duration_min, contact_ids: pj(r.contact_ids, []), company_id: r.company_id, notes: r.notes, outcome: r.outcome, deal_id: r.deal_id, created_at: iso(r.created_at) };
+  }
+  async logEvent(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO events (id, title, type, event_date, duration_min, contact_ids, company_id, notes, outcome, deal_id)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) RETURNING *`, [id, input.title, input.type ?? "meeting", input.event_date, input.duration_min ?? null, JSON.stringify(input.contact_ids ?? []), input.company_id ?? null, input.notes ?? null, input.outcome ?? null, input.deal_id ?? null]);
+    return this.mapEvent(row);
+  }
+  async listEvents(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.contact_id) {
+      params.push(`%${opts.contact_id}%`);
+      where.push(`contact_ids LIKE $${params.length}`);
+    }
+    if (opts.company_id) {
+      params.push(opts.company_id);
+      where.push(`company_id = $${params.length}`);
+    }
+    if (opts.type) {
+      params.push(opts.type);
+      where.push(`type = $${params.length}`);
+    }
+    if (opts.date_from) {
+      params.push(opts.date_from);
+      where.push(`event_date >= $${params.length}`);
+    }
+    if (opts.date_to) {
+      params.push(opts.date_to);
+      where.push(`event_date <= $${params.length}`);
+    }
+    const sql = `SELECT * FROM events ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY event_date DESC`;
+    return (await this.client.many(sql, params)).map((r) => this.mapEvent(r));
+  }
+  async deleteEvent(id) {
+    return (await this.client.query(`DELETE FROM events WHERE id = $1`, [id])).rowCount > 0;
+  }
+  mapTask(r) {
+    return { id: r.id, title: r.title, description: r.description, contact_id: r.contact_id, assigned_by: r.assigned_by, deadline: r.deadline, status: r.status, priority: r.priority, entity_id: r.entity_id, linked_todos_task_id: r.linked_todos_task_id, escalation_rules: pj(r.escalation_rules, []), created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
+  }
+  async createContactTask(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_tasks (id, title, description, contact_id, assigned_by, deadline, status, priority, entity_id, linked_todos_task_id, escalation_rules)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11) RETURNING *`, [id, input.title, input.description ?? null, input.contact_id, input.assigned_by ?? null, input.deadline ?? null, input.status ?? "pending", input.priority ?? "medium", input.entity_id ?? null, input.linked_todos_task_id ?? null, JSON.stringify(input.escalation_rules ?? [])]);
+    return this.mapTask(row);
+  }
+  async listContactTasks(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.contact_id) {
+      params.push(opts.contact_id);
+      where.push(`contact_id = $${params.length}`);
+    }
+    if (opts.entity_id) {
+      params.push(opts.entity_id);
+      where.push(`entity_id = $${params.length}`);
+    }
+    if (opts.status) {
+      params.push(opts.status);
+      where.push(`status = $${params.length}`);
+    }
+    if (opts.priority) {
+      params.push(opts.priority);
+      where.push(`priority = $${params.length}`);
+    }
+    const sql = `SELECT * FROM contact_tasks ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY deadline ASC NULLS LAST, priority DESC, created_at ASC`;
+    return (await this.client.many(sql, params)).map((r) => this.mapTask(r));
+  }
+  async updateContactTask(id, input) {
+    const cols = ["title", "description", "assigned_by", "deadline", "status", "priority", "entity_id", "linked_todos_task_id"];
+    const sets = [];
+    const params = [id];
+    for (const c of cols)
+      if (c in input) {
+        params.push(input[c] ?? null);
+        sets.push(`${c} = $${params.length}`);
+      }
+    if ("escalation_rules" in input) {
+      params.push(JSON.stringify(input.escalation_rules));
+      sets.push(`escalation_rules = $${params.length}`);
+    }
+    sets.push(`updated_at = NOW()`);
+    const row = await this.client.get(`UPDATE contact_tasks SET ${sets.join(", ")} WHERE id = $1 RETURNING *`, params);
+    return row ? this.mapTask(row) : null;
+  }
+  async deleteContactTask(id) {
+    return (await this.client.query(`DELETE FROM contact_tasks WHERE id = $1`, [id])).rowCount > 0;
+  }
+  async listOverdueTasks() {
+    const rows = await this.client.many(`SELECT * FROM contact_tasks WHERE deadline < $1 AND status NOT IN ('completed','cancelled') ORDER BY deadline ASC`, [nowIso()]);
+    return rows.map((r) => this.mapTask(r));
+  }
+  async checkEscalations() {
+    const overdue = await this.listOverdueTasks();
+    const nowMs = Date.now();
+    const results = [];
+    for (const task of overdue) {
+      const rules = task.escalation_rules ?? [];
+      if (!task.deadline || rules.length === 0)
+        continue;
+      const days = (nowMs - new Date(task.deadline).getTime()) / 86400000;
+      const triggered = rules.filter((r) => days >= r.after_days);
+      if (triggered.length)
+        results.push({ task, rules_triggered: triggered });
+    }
+    return results;
+  }
+  mapApplication(r) {
+    return { id: r.id, program_name: r.program_name, provider_company_id: r.provider_company_id, type: r.type, value_usd: r.value_usd, applicant_contact_id: r.applicant_contact_id, primary_contact_id: r.primary_contact_id, status: r.status, submitted_date: r.submitted_date, decision_date: r.decision_date, follow_up_date: r.follow_up_date, notes: r.notes, method: r.method ?? null, form_url: r.form_url, metadata: pj(r.metadata, {}), created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
+  }
+  async createApplication(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO applications (id, program_name, provider_company_id, type, value_usd, applicant_contact_id, primary_contact_id, status, submitted_date, decision_date, follow_up_date, notes, method, form_url, metadata)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15) RETURNING *`, [id, input.program_name, input.provider_company_id ?? null, input.type ?? "other", input.value_usd ?? null, input.applicant_contact_id ?? null, input.primary_contact_id ?? null, input.status ?? "draft", input.submitted_date ?? null, input.decision_date ?? null, input.follow_up_date ?? null, input.notes ?? null, input.method ?? null, input.form_url ?? null, JSON.stringify(input.metadata ?? {})]);
+    return this.mapApplication(row);
+  }
+  async listApplications(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.type) {
+      params.push(opts.type);
+      where.push(`type = $${params.length}`);
+    }
+    if (opts.status) {
+      params.push(opts.status);
+      where.push(`status = $${params.length}`);
+    }
+    if (opts.provider_company_id) {
+      params.push(opts.provider_company_id);
+      where.push(`provider_company_id = $${params.length}`);
+    }
+    if (opts.applicant_contact_id) {
+      params.push(opts.applicant_contact_id);
+      where.push(`applicant_contact_id = $${params.length}`);
+    }
+    const sql = `SELECT * FROM applications ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at DESC`;
+    return (await this.client.many(sql, params)).map((r) => this.mapApplication(r));
+  }
+  async updateApplication(id, input) {
+    const cols = ["program_name", "provider_company_id", "type", "value_usd", "applicant_contact_id", "primary_contact_id", "status", "submitted_date", "decision_date", "follow_up_date", "notes", "method", "form_url"];
+    const sets = [];
+    const params = [id];
+    for (const c of cols)
+      if (c in input) {
+        params.push(input[c] ?? null);
+        sets.push(`${c} = $${params.length}`);
+      }
+    if ("metadata" in input) {
+      params.push(JSON.stringify(input.metadata));
+      sets.push(`metadata = $${params.length}`);
+    }
+    sets.push(`updated_at = NOW()`);
+    const row = await this.client.get(`UPDATE applications SET ${sets.join(", ")} WHERE id = $1 RETURNING *`, params);
+    return row ? this.mapApplication(row) : null;
+  }
+  async listFollowUpDueApplications() {
+    const today = new Date().toISOString().slice(0, 10);
+    const rows = await this.client.many(`SELECT * FROM applications WHERE follow_up_date <= $1 AND status = 'follow_up_needed' ORDER BY follow_up_date ASC`, [today]);
+    return rows.map((r) => this.mapApplication(r));
+  }
+  mapGroup(r) {
+    return { ...r, created_at: isoOrNull(r.created_at), updated_at: isoOrNull(r.updated_at), member_count: r.member_count != null ? Number(r.member_count) : undefined, company_count: r.company_count != null ? Number(r.company_count) : undefined };
+  }
+  async createGroup(input) {
+    const id = newUuid();
+    await this.client.execute(`INSERT INTO groups (id, name, description, project_id) VALUES ($1,$2,$3,$4)`, [id, input.name, input.description ?? null, input.project_id ?? null]);
+    return this.getGroup(id);
+  }
+  async getGroup(id) {
+    const row = await this.client.get(`SELECT * FROM groups WHERE id = $1`, [id]);
+    return row ? this.mapGroup(row) : null;
+  }
+  async listGroups(projectId) {
+    const params = [];
+    let where = "";
+    if (projectId) {
+      params.push(projectId);
+      where = `WHERE g.project_id = $1`;
+    }
+    const rows = await this.client.many(`SELECT g.*, (SELECT COUNT(*) FROM contact_groups cg WHERE cg.group_id = g.id) AS member_count,
+              (SELECT COUNT(*) FROM company_groups cog WHERE cog.group_id = g.id) AS company_count
+       FROM groups g ${where} ORDER BY g.name`, params);
+    return rows.map((r) => this.mapGroup(r));
+  }
+  async updateGroup(id, input) {
+    const sets = [];
+    const params = [id];
+    for (const c of ["name", "description", "project_id"])
+      if (c in input) {
+        params.push(input[c] ?? null);
+        sets.push(`${c} = $${params.length}`);
+      }
+    sets.push(`updated_at = NOW()`);
+    await this.client.execute(`UPDATE groups SET ${sets.join(", ")} WHERE id = $1`, params);
+    return this.getGroup(id);
+  }
+  async deleteGroup(id) {
+    return (await this.client.query(`DELETE FROM groups WHERE id = $1`, [id])).rowCount > 0;
+  }
+  async addContactToGroup(contactId, groupId) {
+    const existing = await this.client.get(`SELECT 1 FROM contact_groups WHERE contact_id = $1 AND group_id = $2`, [contactId, groupId]);
+    if (existing)
+      return { added: false, already_member: true };
+    await this.client.execute(`INSERT INTO contact_groups (contact_id, group_id) VALUES ($1,$2)`, [contactId, groupId]);
+    return { added: true, already_member: false };
+  }
+  async removeContactFromGroup(contactId, groupId) {
+    await this.client.execute(`DELETE FROM contact_groups WHERE contact_id = $1 AND group_id = $2`, [contactId, groupId]);
+  }
+  async listContactsInGroup(groupId) {
+    return (await this.client.many(`SELECT contact_id FROM contact_groups WHERE group_id = $1`, [groupId])).map((r) => r.contact_id);
+  }
+  async listGroupsForContact(contactId) {
+    const rows = await this.client.many(`SELECT g.* FROM groups g JOIN contact_groups cg ON g.id = cg.group_id WHERE cg.contact_id = $1 ORDER BY g.name`, [contactId]);
+    return rows.map((r) => this.mapGroup(r));
+  }
+  async addCompanyToGroup(companyId, groupId) {
+    const existing = await this.client.get(`SELECT 1 FROM company_groups WHERE company_id = $1 AND group_id = $2`, [companyId, groupId]);
+    if (existing)
+      return { added: false, already_member: true };
+    await this.client.execute(`INSERT INTO company_groups (company_id, group_id) VALUES ($1,$2)`, [companyId, groupId]);
+    return { added: true, already_member: false };
+  }
+  async removeCompanyFromGroup(companyId, groupId) {
+    await this.client.execute(`DELETE FROM company_groups WHERE company_id = $1 AND group_id = $2`, [companyId, groupId]);
+  }
+  async listCompaniesInGroup(groupId) {
+    return (await this.client.many(`SELECT company_id FROM company_groups WHERE group_id = $1`, [groupId])).map((r) => r.company_id);
+  }
+  async listGroupsForCompany(companyId) {
+    const rows = await this.client.many(`SELECT g.* FROM groups g JOIN company_groups cog ON g.id = cog.group_id WHERE cog.company_id = $1 ORDER BY g.name`, [companyId]);
+    return rows.map((r) => this.mapGroup(r));
+  }
+  mapVendorComm(r) {
+    return { id: r.id, company_id: r.company_id, contact_id: r.contact_id, comm_date: r.comm_date, type: r.type, direction: r.direction, subject: r.subject, body: r.body, status: r.status, invoice_amount: r.invoice_amount, invoice_currency: r.invoice_currency, invoice_ref: r.invoice_ref, follow_up_date: r.follow_up_date, follow_up_done: Boolean(r.follow_up_done), created_at: iso(r.created_at) };
+  }
+  async logVendorCommunication(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO vendor_communications (id, company_id, contact_id, comm_date, type, direction, subject, body, status, invoice_amount, invoice_currency, invoice_ref, follow_up_date, follow_up_done)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) RETURNING *`, [id, input.company_id, input.contact_id ?? null, input.comm_date, input.type ?? "email", input.direction ?? "outbound", input.subject ?? null, input.body ?? null, input.status ?? "sent", input.invoice_amount ?? null, input.invoice_currency ?? null, input.invoice_ref ?? null, input.follow_up_date ?? null, Boolean(input.follow_up_done)]);
+    return this.mapVendorComm(row);
+  }
+  async listVendorCommunications(companyId, opts = {}) {
+    const where = ["company_id = $1"];
+    const params = [companyId];
+    if (opts.type) {
+      params.push(opts.type);
+      where.push(`type = $${params.length}`);
+    }
+    if (opts.status) {
+      params.push(opts.status);
+      where.push(`status = $${params.length}`);
+    }
+    if (opts.direction) {
+      params.push(opts.direction);
+      where.push(`direction = $${params.length}`);
+    }
+    const rows = await this.client.many(`SELECT * FROM vendor_communications WHERE ${where.join(" AND ")} ORDER BY comm_date DESC`, params);
+    return rows.map((r) => this.mapVendorComm(r));
+  }
+  async listMissingInvoices() {
+    const rows = await this.client.many(`SELECT * FROM vendor_communications WHERE type = 'invoice_request' AND status IN ('awaiting_response','no_response') ORDER BY comm_date ASC`);
+    return rows.map((r) => this.mapVendorComm(r));
+  }
+  async listPendingFollowUps() {
+    const today = new Date().toISOString().slice(0, 10);
+    const rows = await this.client.many(`SELECT * FROM vendor_communications WHERE follow_up_date <= $1 AND follow_up_done = false ORDER BY follow_up_date ASC`, [today]);
+    return rows.map((r) => this.mapVendorComm(r));
+  }
+  async markFollowUpDone(id) {
+    const row = await this.client.get(`UPDATE vendor_communications SET follow_up_done = true WHERE id = $1 RETURNING *`, [id]);
+    return row ? this.mapVendorComm(row) : null;
+  }
+  mapOrgMember(r) {
+    return { id: r.id, company_id: r.company_id, contact_id: r.contact_id, title: r.title, specialization: r.specialization, office_phone: r.office_phone, response_sla_hours: r.response_sla_hours, notes: r.notes, created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
+  }
+  async addOrgMember(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO org_members (id, company_id, contact_id, title, specialization, office_phone, response_sla_hours, notes)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8) RETURNING *`, [id, input.company_id, input.contact_id, input.title ?? null, input.specialization ?? null, input.office_phone ?? null, input.response_sla_hours ?? null, input.notes ?? null]);
+    return this.mapOrgMember(row);
+  }
+  async listOrgMembers(companyId) {
+    return (await this.client.many(`SELECT * FROM org_members WHERE company_id = $1 ORDER BY created_at ASC`, [companyId])).map((r) => this.mapOrgMember(r));
+  }
+  async updateOrgMember(id, input) {
+    const sets = [];
+    const params = [id];
+    for (const c of ["title", "specialization", "office_phone", "response_sla_hours", "notes"])
+      if (c in input) {
+        params.push(input[c] ?? null);
+        sets.push(`${c} = $${params.length}`);
+      }
+    sets.push(`updated_at = NOW()`);
+    const row = await this.client.get(`UPDATE org_members SET ${sets.join(", ")} WHERE id = $1 RETURNING *`, params);
+    return row ? this.mapOrgMember(row) : null;
+  }
+  async removeOrgMember(id) {
+    return (await this.client.query(`DELETE FROM org_members WHERE id = $1`, [id])).rowCount > 0;
+  }
+  async listOrgMembersForContact(contactId) {
+    return (await this.client.many(`SELECT * FROM org_members WHERE contact_id = $1 ORDER BY created_at ASC`, [contactId])).map((r) => this.mapOrgMember(r));
+  }
+  mapNote(r) {
+    return { ...r, created_at: isoOrNull(r.created_at) };
+  }
+  async addNote(contactId, body, createdBy, companyId) {
+    const contact = await this.client.get(`SELECT id FROM contacts WHERE id = $1`, [contactId]);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_notes (id, contact_id, body, created_by, company_id) VALUES ($1,$2,$3,$4,$5) RETURNING *`, [id, contactId, body, createdBy ?? null, companyId ?? null]);
+    return this.mapNote(row);
+  }
+  async listNotes(contactId) {
+    return (await this.client.many(`SELECT * FROM contact_notes WHERE contact_id = $1 ORDER BY created_at ASC`, [contactId])).map((r) => this.mapNote(r));
+  }
+  async listNotesForContactAtCompany(contactId, companyId) {
+    return (await this.client.many(`SELECT * FROM contact_notes WHERE contact_id = $1 AND company_id = $2 ORDER BY created_at ASC`, [contactId, companyId])).map((r) => this.mapNote(r));
+  }
+  async deleteNote(noteId) {
+    await this.client.execute(`DELETE FROM contact_notes WHERE id = $1`, [noteId]);
+  }
+  async createRelationship(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_relationships (id, contact_a_id, contact_b_id, relationship_type, notes)
+       VALUES ($1,$2,$3,$4,$5) RETURNING *`, [id, input.contact_a_id, input.contact_b_id, input.relationship_type ?? "knows", input.notes ?? null]);
+    return { ...row, created_at: isoOrNull(row?.created_at) };
+  }
+  async listRelationships(opts = {}) {
+    if (opts.contact_id) {
+      return this.client.many(`SELECT * FROM contact_relationships WHERE contact_a_id = $1 OR contact_b_id = $1`, [opts.contact_id]);
+    }
+    return this.client.many(`SELECT * FROM contact_relationships`);
+  }
+  async deleteRelationship(id) {
+    await this.client.execute(`DELETE FROM contact_relationships WHERE id = $1`, [id]);
+  }
+  async createCompanyRelationship(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO company_relationships (id, contact_id, company_id, relationship_type, notes, start_date, end_date, is_primary, status)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) RETURNING *`, [id, input.contact_id, input.company_id, input.relationship_type, input.notes ?? null, input.start_date ?? null, input.end_date ?? null, Boolean(input.is_primary), input.status ?? "active"]);
+    return { ...row, created_at: isoOrNull(row?.created_at), is_primary: Boolean(row?.is_primary) };
+  }
+  async listCompanyRelationships(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.contact_id) {
+      params.push(opts.contact_id);
+      where.push(`contact_id = $${params.length}`);
+    }
+    if (opts.company_id) {
+      params.push(opts.company_id);
+      where.push(`company_id = $${params.length}`);
+    }
+    const sql = `SELECT * FROM company_relationships ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at DESC`;
+    return (await this.client.many(sql, params)).map((r) => ({ ...r, created_at: isoOrNull(r.created_at), is_primary: Boolean(r.is_primary) }));
+  }
+  async deleteCompanyRelationship(id) {
+    await this.client.execute(`DELETE FROM company_relationships WHERE id = $1`, [id]);
+  }
+  async getFieldHistory(contactId, fieldName) {
+    const rows = fieldName ? await this.client.many(`SELECT * FROM contact_field_history WHERE contact_id = $1 AND field_name = $2 ORDER BY valid_from DESC`, [contactId, fieldName]) : await this.client.many(`SELECT * FROM contact_field_history WHERE contact_id = $1 ORDER BY valid_from DESC`, [contactId]);
+    return rows.map((r) => ({ ...r, valid_from: isoOrNull(r.valid_from), created_at: isoOrNull(r.created_at) }));
+  }
+  async getContactAt(contactId, timestamp) {
+    const rows = await this.client.many(`SELECT field_name, new_value FROM contact_field_history WHERE contact_id = $1 AND valid_from <= $2 ORDER BY valid_from ASC`, [contactId, timestamp]);
+    const result = {};
+    for (const r of rows)
+      if (r.new_value != null)
+        result[r.field_name] = r.new_value;
+    return result;
+  }
+  mapJob(r) {
+    return { ...r, is_current: Boolean(r.is_current), inferred: Boolean(r.inferred), created_at: isoOrNull(r.created_at) };
+  }
+  async addJobEntry(contactId, input) {
+    if (input.is_current) {
+      await this.client.execute(`UPDATE job_history SET is_current = false, end_date = COALESCE(end_date, $1) WHERE contact_id = $2 AND is_current = true`, [new Date().toISOString().slice(0, 10), contactId]);
+    }
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO job_history (id, contact_id, company_id, company_name, title, start_date, end_date, is_current, inferred, source)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) RETURNING *`, [id, contactId, input.company_id ?? null, input.company_name, input.title ?? null, input.start_date ?? null, input.end_date ?? null, Boolean(input.is_current), Boolean(input.inferred), input.source ?? null]);
+    return this.mapJob(row);
+  }
+  async getJobHistory(contactId) {
+    return (await this.client.many(`SELECT * FROM job_history WHERE contact_id = $1 ORDER BY is_current DESC, start_date DESC`, [contactId])).map((r) => this.mapJob(r));
+  }
+  mapLearning(r) {
+    return { ...r, tags: pj(r.tags, []), created_at: isoOrNull(r.created_at), updated_at: isoOrNull(r.updated_at) };
+  }
+  async saveLearning(contactId, input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_learnings (id, contact_id, content, type, confidence, importance, learned_by, session_id, visibility, tags)
+       VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10) RETURNING *`, [id, contactId, input.content, input.type ?? "fact", input.confidence ?? 70, input.importance ?? 5, input.learned_by ?? null, input.session_id ?? null, input.visibility ?? "shared", JSON.stringify(input.tags ?? [])]);
+    return this.mapLearning(row);
+  }
+  async getLearnings(contactId, opts = {}) {
+    let sql = `SELECT * FROM contact_learnings WHERE contact_id = $1`;
+    const params = [contactId];
+    if (opts.type) {
+      params.push(opts.type);
+      sql += ` AND type = $${params.length}`;
+    }
+    if (opts.min_importance) {
+      params.push(opts.min_importance);
+      sql += ` AND importance >= $${params.length}`;
+    }
+    if (opts.visibility) {
+      params.push(opts.visibility);
+      sql += ` AND visibility = $${params.length}`;
+    }
+    sql += ` ORDER BY importance DESC, confidence DESC`;
+    return (await this.client.many(sql, params)).map((r) => this.mapLearning(r));
+  }
+  async searchLearnings(query, opts = {}) {
+    let sql = `SELECT * FROM contact_learnings WHERE content ILIKE $1`;
+    const params = [`%${query}%`];
+    if (opts.type) {
+      params.push(opts.type);
+      sql += ` AND type = $${params.length}`;
+    }
+    if (opts.contact_id) {
+      params.push(opts.contact_id);
+      sql += ` AND contact_id = $${params.length}`;
+    }
+    sql += ` ORDER BY importance DESC, confidence DESC LIMIT 50`;
+    return (await this.client.many(sql, params)).map((r) => this.mapLearning(r));
+  }
+  async confirmLearning(learningId) {
+    await this.client.execute(`UPDATE contact_learnings SET confirmed_count = confirmed_count + 1, confidence = LEAST(100, confidence + 10), updated_at = NOW() WHERE id = $1`, [learningId]);
+  }
+  async getStaleLearnings(daysOld, minConfidence) {
+    const cutoff = new Date(Date.now() - daysOld * 86400000).toISOString();
+    return (await this.client.many(`SELECT * FROM contact_learnings WHERE confirmed_count = 0 AND created_at < $1 AND confidence >= $2 ORDER BY confidence ASC LIMIT 50`, [cutoff, minConfidence])).map((r) => this.mapLearning(r));
+  }
+  async runLearningMaintenance() {
+    const cutoff = new Date(Date.now() - 30 * 86400000).toISOString();
+    const res = await this.client.query(`UPDATE contact_learnings SET confidence = GREATEST(10, confidence - 5), updated_at = NOW() WHERE confirmed_count = 0 AND created_at < $1 AND confidence > 10`, [cutoff]);
+    const dups = await this.client.many(`SELECT contact_id, COUNT(*) AS cnt FROM contact_learnings GROUP BY contact_id, LOWER(SUBSTR(content,1,30)) HAVING COUNT(*) > 1`);
+    return { decayed_count: res.rowCount, potential_contradictions: dups };
+  }
+  mapLock(r) {
+    return { ...r, acquired_at: isoOrNull(r.acquired_at), expires_at: isoOrNull(r.expires_at) };
+  }
+  async acquireContactLock(contactId, agentName, ttlSeconds = 300, reason, sessionId) {
+    await this.client.execute(`DELETE FROM contact_locks WHERE expires_at < NOW()`);
+    const existing = await this.client.get(`SELECT * FROM contact_locks WHERE contact_id = $1`, [contactId]);
+    if (existing)
+      return { acquired: false, held_by: existing.agent_name, lock: this.mapLock(existing) };
+    const id = newUuid();
+    const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+    const row = await this.client.get(`INSERT INTO contact_locks (id, contact_id, agent_name, reason, expires_at, session_id) VALUES ($1,$2,$3,$4,$5,$6) RETURNING *`, [id, contactId, agentName, reason ?? null, expiresAt, sessionId ?? null]);
+    return { acquired: true, lock: this.mapLock(row) };
+  }
+  async releaseContactLock(contactId, agentName) {
+    return (await this.client.query(`DELETE FROM contact_locks WHERE contact_id = $1 AND agent_name = $2`, [contactId, agentName])).rowCount > 0;
+  }
+  async checkContactLock(contactId) {
+    await this.client.execute(`DELETE FROM contact_locks WHERE expires_at < NOW()`);
+    const row = await this.client.get(`SELECT * FROM contact_locks WHERE contact_id = $1`, [contactId]);
+    return row ? this.mapLock(row) : null;
+  }
+  async logAgentActivity(contactId, agentName, action, details, sessionId) {
+    await this.client.execute(`INSERT INTO contact_agent_activity (id, contact_id, agent_name, action, details, session_id) VALUES ($1,$2,$3,$4,$5,$6)`, [newUuid(), contactId, agentName, action, details ?? null, sessionId ?? null]);
+  }
+  async getAgentActivity(contactId, limit = 20) {
+    return (await this.client.many(`SELECT * FROM contact_agent_activity WHERE contact_id = $1 ORDER BY created_at DESC LIMIT $2`, [contactId, limit])).map((r) => ({ ...r, created_at: isoOrNull(r.created_at) }));
+  }
+  async resolveContactIdentity(partial) {
+    const matches = new Map;
+    const add = (id, name, title, score, reason) => {
+      const ex = matches.get(id);
+      if (ex) {
+        ex.confidence_score = Math.min(100, ex.confidence_score + score);
+        ex.match_reasons.push(reason);
+      } else
+        matches.set(id, { contact: { id, display_name: name, job_title: title }, confidence_score: score, match_reasons: [reason] });
+    };
+    if (partial.email) {
+      const rows = await this.client.many(`SELECT c.id, c.display_name, c.job_title FROM contacts c JOIN emails e ON c.id = e.contact_id WHERE LOWER(e.address) = LOWER($1)`, [partial.email]);
+      rows.forEach((r) => add(r.id, r.display_name, r.job_title, 90, `email match: ${partial.email}`));
+    }
+    if (partial.linkedin_url) {
+      const tail = partial.linkedin_url.split("/").pop();
+      const rows = await this.client.many(`SELECT c.id, c.display_name, c.job_title FROM contacts c JOIN social_profiles sp ON c.id = sp.contact_id WHERE sp.platform = 'linkedin' AND sp.url LIKE $1`, [`%${tail}%`]);
+      rows.forEach((r) => add(r.id, r.display_name, r.job_title, 85, `linkedin match`));
+    }
+    if (partial.name) {
+      const rows = await this.client.many(`SELECT id, display_name, job_title FROM contacts WHERE display_name ILIKE $1 AND archived = false LIMIT 10`, [`%${partial.name}%`]);
+      rows.forEach((r) => add(r.id, r.display_name, r.job_title, 40, `name match: ${partial.name}`));
+    }
+    return Array.from(matches.values()).sort((a, b) => b.confidence_score - a.confidence_score);
+  }
+  async addContactIdentity(contactId, system, externalId, externalUrl, confidence = "inferred") {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_identities (id, contact_id, system, external_id, external_url, confidence) VALUES ($1,$2,$3,$4,$5,$6)
+       ON CONFLICT (system, external_id) DO UPDATE SET contact_id = excluded.contact_id, external_url = excluded.external_url, confidence = excluded.confidence RETURNING *`, [id, contactId, system, externalId, externalUrl ?? null, confidence]);
+    return { ...row, created_at: isoOrNull(row?.created_at) };
+  }
+  async getContactIdentities(contactId) {
+    return (await this.client.many(`SELECT * FROM contact_identities WHERE contact_id = $1 ORDER BY created_at DESC`, [contactId])).map((r) => ({ ...r, created_at: isoOrNull(r.created_at) }));
+  }
+  signalRow(r) {
+    const last = r.last_contacted_at;
+    return {
+      contact_id: r.contact_id,
+      display_name: r.display_name,
+      last_contacted_at: last,
+      interaction_count_30d: Number(r.interaction_count_30d ?? 0),
+      engagement_status: r.engagement_status ?? null,
+      relationship_health: r.relationship_health ?? null,
+      days_since_contact: last ? Math.floor((Date.now() - new Date(last).getTime()) / 86400000) : null
+    };
+  }
+  async getRelationshipSignals(contactId) {
+    const row = await this.client.get(`SELECT id AS contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE id = $1`, [contactId]);
+    if (!row)
+      return [];
+    const base = this.signalRow(row);
+    const cnt = base.interaction_count_30d;
+    const health = base.relationship_health ?? 50;
+    const daysSince = base.days_since_contact;
+    let signal_type = "healthy";
+    let reason = `Last contact ${daysSince}d ago, ${cnt} interactions in 30d`;
+    if (daysSince === null || daysSince > 180) {
+      signal_type = "ghost";
+      reason = "No contact in 180+ days or never contacted";
+    } else if (daysSince > 60 && cnt === 0) {
+      signal_type = "cooling";
+      reason = `No contact in ${daysSince} days, no recent interactions`;
+    } else if (cnt > 3 && health > 70) {
+      signal_type = "warming";
+      reason = `${cnt} interactions in last 30 days, health score ${health}`;
+    }
+    return [{ ...base, signal_type, reason }];
+  }
+  async getGhostContacts() {
+    const cutoff = new Date(Date.now() - 180 * 86400000).toISOString();
+    const rows = await this.client.many(`SELECT id AS contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE (last_contacted_at IS NULL OR last_contacted_at < $1) AND archived = false ORDER BY last_contacted_at ASC NULLS FIRST LIMIT 50`, [cutoff]);
+    return rows.map((r) => ({ ...this.signalRow(r), signal_type: "ghost", reason: "No contact in 180+ days or never contacted" }));
+  }
+  async getWarmingContacts() {
+    const rows = await this.client.many(`SELECT id AS contact_id, display_name, last_contacted_at, interaction_count_30d, engagement_status, relationship_health FROM contacts WHERE interaction_count_30d > 2 AND relationship_health > 60 AND archived = false ORDER BY relationship_health DESC LIMIT 50`);
+    return rows.map((r) => ({ ...this.signalRow(r), signal_type: "warming", reason: `${Number(r.interaction_count_30d ?? 0)} interactions in last 30 days` }));
+  }
+  async recomputeSignals() {
+    const res = await this.client.query(`UPDATE contacts SET engagement_status = CASE
+          WHEN interaction_count_30d > 3 THEN 'warming'
+          WHEN last_contacted_at IS NULL OR EXTRACT(EPOCH FROM (NOW() - last_contacted_at::timestamptz)) / 86400 > 180 THEN 'ghost'
+          WHEN EXTRACT(EPOCH FROM (NOW() - last_contacted_at::timestamptz)) / 86400 > 60 THEN 'cooling'
+          ELSE 'stable' END,
+        updated_at = NOW() WHERE archived = false`);
+    return { updated: res.rowCount };
+  }
+  async getFreshnessScore(contactId) {
+    const contact = await this.client.get(`SELECT * FROM contacts WHERE id = $1`, [contactId]);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const historyRows = await this.client.many(`SELECT field_name, new_value, source, created_at FROM contact_field_history WHERE contact_id = $1 ORDER BY created_at DESC`, [contactId]);
+    const verifiedRows = await this.client.many(`SELECT field_name, last_verified_at, source FROM contact_field_confidence WHERE contact_id = $1 AND confidence = 'verified'`, [contactId]).catch(() => []);
+    const scored = ["display_name", "job_title", "company_id", "emails", "phones", "last_contacted_at"];
+    const verifiedMap = new Map(verifiedRows.map((r) => [r.field_name, r]));
+    const historyMap = new Map;
+    for (const r of historyRows)
+      if (!historyMap.has(r.field_name))
+        historyMap.set(r.field_name, r);
+    const fields = [];
+    for (const field of scored) {
+      let value = null;
+      if (field === "emails") {
+        const e = await this.client.get(`SELECT address FROM emails WHERE contact_id = $1 LIMIT 1`, [contactId]);
+        value = e?.address ?? null;
+      } else if (field === "phones") {
+        const p = await this.client.get(`SELECT number FROM phones WHERE contact_id = $1 LIMIT 1`, [contactId]);
+        value = p?.number ?? null;
+      } else
+        value = contact[field] != null ? String(contact[field]) : null;
+      const verified = verifiedMap.get(field);
+      const history = historyMap.get(field);
+      let confidence = "unknown";
+      let days_old = null;
+      let last_verified_at = null;
+      let source = null;
+      if (verified) {
+        confidence = "verified";
+        last_verified_at = isoOrNull(verified.last_verified_at);
+        source = verified.source;
+        days_old = last_verified_at ? Math.floor((Date.now() - new Date(last_verified_at).getTime()) / 86400000) : null;
+      } else if (history) {
+        confidence = history.source === "import" ? "imported" : "inferred";
+        last_verified_at = isoOrNull(history.created_at);
+        source = history.source;
+        days_old = last_verified_at ? Math.floor((Date.now() - new Date(last_verified_at).getTime()) / 86400000) : null;
+        if (days_old != null && days_old > 365)
+          confidence = "stale";
+      } else if (value)
+        confidence = "inferred";
+      fields.push({ field_name: field, value, last_verified_at, source, confidence, days_old });
+    }
+    const fieldScore = fields.reduce((acc, f) => {
+      if (!f.value)
+        return acc;
+      if (f.confidence === "verified")
+        return acc + 20;
+      if (f.confidence === "imported" || f.confidence === "inferred")
+        return acc + 10;
+      return acc + 5;
+    }, 0);
+    return { contact_id: contactId, overall_score: Math.min(100, fieldScore), fields, stale_fields: fields.filter((f) => f.confidence === "stale" || !f.value && f.field_name !== "phones").map((f) => f.field_name), verified_fields: fields.filter((f) => f.confidence === "verified").map((f) => f.field_name) };
+  }
+  async getStaleContacts(threshold = 40) {
+    return this.client.many(`SELECT * FROM (
+        SELECT c.id AS contact_id, c.display_name,
+          ((CASE WHEN c.job_title IS NOT NULL THEN 15 ELSE 0 END) +
+           (CASE WHEN c.company_id IS NOT NULL THEN 15 ELSE 0 END) +
+           (CASE WHEN c.last_contacted_at IS NOT NULL THEN 20 ELSE 0 END) +
+           (CASE WHEN EXISTS(SELECT 1 FROM emails WHERE contact_id = c.id) THEN 20 ELSE 0 END) +
+           (CASE WHEN EXISTS(SELECT 1 FROM phones WHERE contact_id = c.id) THEN 15 ELSE 0 END) +
+           (CASE WHEN c.notes IS NOT NULL THEN 10 ELSE 0 END) +
+           (CASE WHEN EXISTS(SELECT 1 FROM contact_tags WHERE contact_id = c.id) THEN 5 ELSE 0 END)) AS score
+        FROM contacts c WHERE c.archived = false
+      ) sub WHERE score < $1 ORDER BY score ASC LIMIT 100`, [threshold]);
+  }
+  async markFieldVerified(contactId, fieldName, source) {
+    await this.client.execute(`INSERT INTO contact_field_confidence (id, contact_id, field_name, confidence, source, last_verified_at) VALUES ($1,$2,$3,'verified',$4,NOW())
+       ON CONFLICT (contact_id, field_name) DO UPDATE SET confidence = 'verified', source = excluded.source, last_verified_at = NOW()`, [newUuid(), contactId, fieldName, source ?? null]);
+  }
+  async computeRelationshipStrength(contactId) {
+    const c = await this.client.get(`SELECT last_contacted_at, interaction_count_30d FROM contacts WHERE id = $1`, [contactId]);
+    if (!c)
+      return 0;
+    let score = 50;
+    if (c.last_contacted_at) {
+      const days = Math.floor((Date.now() - new Date(c.last_contacted_at).getTime()) / 86400000);
+      score += days < 7 ? 30 : days < 30 ? 20 : days < 90 ? 5 : -20;
+    } else
+      score -= 20;
+    score += Math.min(20, (c.interaction_count_30d || 0) * 4);
+    return Math.max(0, Math.min(100, score));
+  }
+  async findWarmPath(fromContactId, toContactId) {
+    const visited = new Set([fromContactId]);
+    const queue = [{ id: fromContactId, path: [] }];
+    while (queue.length) {
+      const { id, path } = queue.shift();
+      if (id === toContactId)
+        return path;
+      if (path.length >= 4)
+        continue;
+      const neighbors = await this.client.many(`SELECT cr.contact_a_id, cr.contact_b_id, cr.strength_score, c.display_name FROM contact_relationships cr JOIN contacts c ON (CASE WHEN cr.contact_a_id = $1 THEN cr.contact_b_id ELSE cr.contact_a_id END) = c.id WHERE cr.contact_a_id = $1 OR cr.contact_b_id = $1 LIMIT 20`, [id]);
+      for (const n of neighbors) {
+        const nextId = n.contact_a_id === id ? n.contact_b_id : n.contact_a_id;
+        if (visited.has(nextId))
+          continue;
+        visited.add(nextId);
+        queue.push({ id: nextId, path: [...path, { contact_id: nextId, display_name: n.display_name, strength: n.strength_score || 50 }] });
+      }
+    }
+    return [];
+  }
+  async findConnectionsAtCompany(companyId) {
+    return this.client.many(`SELECT c.id AS contact_id, c.display_name, c.job_title, c.relationship_health AS strength FROM contacts c WHERE c.company_id = $1 AND c.archived = false ORDER BY c.relationship_health DESC`, [companyId]);
+  }
+  async detectCoolingRelationships() {
+    const cutoff = new Date(Date.now() - 45 * 86400000).toISOString();
+    const rows = await this.client.many(`SELECT id AS contact_id, display_name, last_contacted_at FROM contacts WHERE last_contacted_at IS NOT NULL AND last_contacted_at < $1 AND engagement_status != 'ghost' AND archived = false ORDER BY last_contacted_at ASC LIMIT 50`, [cutoff]);
+    return rows.map((r) => ({ contact_id: r.contact_id, display_name: r.display_name, days_since: Math.floor((Date.now() - new Date(r.last_contacted_at).getTime()) / 86400000) }));
+  }
+  async addOrgChartEdge(companyId, contactAId, contactBId, edgeType, inferred = false) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO org_chart_edges (id, company_id, contact_a_id, contact_b_id, edge_type, inferred) VALUES ($1,$2,$3,$4,$5,$6)
+       ON CONFLICT (company_id, contact_a_id, contact_b_id, edge_type) DO UPDATE SET inferred = excluded.inferred RETURNING *`, [id, companyId, contactAId, contactBId, edgeType, inferred]);
+    return { ...row, inferred: Boolean(row?.inferred), created_at: isoOrNull(row?.created_at) };
+  }
+  async listOrgChart(companyId) {
+    return this.client.many(`SELECT ca.display_name AS contact_a_name, cb.display_name AS contact_b_name, e.edge_type
+       FROM org_chart_edges e JOIN contacts ca ON e.contact_a_id = ca.id JOIN contacts cb ON e.contact_b_id = cb.id WHERE e.company_id = $1`, [companyId]);
+  }
+  async setDealContactRole(dealId, contactId, accountRole) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO deal_contact_roles (id, deal_id, contact_id, account_role) VALUES ($1,$2,$3,$4)
+       ON CONFLICT (deal_id, contact_id) DO UPDATE SET account_role = excluded.account_role RETURNING *`, [id, dealId, contactId, accountRole]);
+    return { ...row, created_at: isoOrNull(row?.created_at) };
+  }
+  async getDealTeam(dealId) {
+    return this.client.many(`SELECT c.display_name, r.account_role, c.job_title FROM deal_contact_roles r JOIN contacts c ON r.contact_id = c.id WHERE r.deal_id = $1`, [dealId]);
+  }
+  async getCoverageGaps(companyId) {
+    const team = await this.client.many(`SELECT DISTINCT r.account_role FROM deal_contact_roles r JOIN deals d ON r.deal_id = d.id WHERE d.company_id = $1`, [companyId]);
+    const covered = new Set(team.map((t) => t.account_role));
+    const key = ["economic_buyer", "technical_evaluator", "champion"];
+    return { covered: Array.from(covered), missing_key_roles: key.filter((k) => !covered.has(k)) };
+  }
+  mapAudience(r) {
+    return { id: r.id, audience_id: r.audience_id, name: r.name, match: r.match, predicates: pj(r.predicates, []), consent_policy: r.consent_policy, suppression_synced_at: isoOrNull(r.suppression_synced_at), created_at: isoOrNull(r.created_at), updated_at: isoOrNull(r.updated_at) };
+  }
+  async createAudience(input) {
+    const audienceId = String(input.audience_id ?? "");
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(audienceId))
+      throw new Error(`audience_id must be a lowercase dashed slug: ${audienceId}`);
+    const predicates = input.predicates ?? [];
+    if (!Array.isArray(predicates) || predicates.length === 0)
+      throw new Error("at least one predicate is required");
+    const dupe = await this.client.get(`SELECT id FROM audiences WHERE audience_id = $1`, [audienceId]);
+    if (dupe)
+      throw new Error(`duplicate audience_id: ${audienceId}`);
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO audiences (id, audience_id, name, match, predicates, consent_policy) VALUES ($1,$2,$3,$4,$5,$6) RETURNING *`, [id, audienceId, input.name, input.match ?? "all", JSON.stringify(predicates), input.consent_policy ?? "opt_in"]);
+    const mapped = this.mapAudience(row);
+    return { ...mapped, id: mapped.id, audience_id: mapped.audience_id };
+  }
+  async getAudience(idOrSlug) {
+    const row = await this.client.get(`SELECT * FROM audiences WHERE id = $1 OR audience_id = $1`, [idOrSlug]);
+    if (!row)
+      throw new Error(`audience not found: ${idOrSlug}`);
+    return this.mapAudience(row);
+  }
+  async listAudiences() {
+    return (await this.client.many(`SELECT * FROM audiences ORDER BY audience_id ASC`)).map((r) => this.mapAudience(r));
+  }
+  async updateAudience(idOrSlug, input) {
+    const audience = await this.getAudience(idOrSlug);
+    const sets = [];
+    const params = [audience.id];
+    if ("name" in input) {
+      params.push(input.name);
+      sets.push(`name = $${params.length}`);
+    }
+    if ("match" in input) {
+      params.push(input.match);
+      sets.push(`match = $${params.length}`);
+    }
+    if ("predicates" in input) {
+      params.push(JSON.stringify(input.predicates));
+      sets.push(`predicates = $${params.length}`);
+    }
+    if ("consent_policy" in input) {
+      params.push(input.consent_policy);
+      sets.push(`consent_policy = $${params.length}`);
+    }
+    if (sets.length) {
+      sets.push(`updated_at = NOW()`);
+      await this.client.execute(`UPDATE audiences SET ${sets.join(", ")} WHERE id = $1`, params);
+    }
+    return this.getAudience(String(audience.id));
+  }
+  async deleteAudience(idOrSlug) {
+    const audience = await this.getAudience(idOrSlug);
+    await this.client.execute(`DELETE FROM audiences WHERE id = $1`, [String(audience.id)]);
+  }
+  async setContactConsent(contactId, channel, status, source) {
+    const contact = await this.client.get(`SELECT id FROM contacts WHERE id = $1`, [contactId]);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const row = await this.client.get(`INSERT INTO contact_consent (contact_id, channel, status, source, updated_at) VALUES ($1,$2,$3,$4,NOW())
+       ON CONFLICT (contact_id, channel) DO UPDATE SET status = excluded.status, source = excluded.source, updated_at = excluded.updated_at RETURNING *`, [contactId, channel, status, source ?? null]);
+    return { ...row, updated_at: isoOrNull(row?.updated_at) };
+  }
+  async listContactConsent(contactId) {
+    return (await this.client.many(`SELECT * FROM contact_consent WHERE contact_id = $1 ORDER BY channel ASC`, [contactId])).map((r) => ({ ...r, updated_at: isoOrNull(r.updated_at) }));
+  }
+  async suppressAddress(input) {
+    const id = newUuid();
+    const row = await this.client.get(`INSERT INTO contact_suppressions (id, contact_id, channel, address, reason) VALUES ($1,$2,$3,$4,$5)
+       ON CONFLICT (channel, address) DO UPDATE SET reason = excluded.reason, contact_id = COALESCE(excluded.contact_id, contact_suppressions.contact_id), synced_at = NULL RETURNING *`, [id, input.contact_id ?? null, input.channel, input.address, input.reason ?? null]);
+    if (input.contact_id) {
+      const c = await this.client.get(`SELECT id FROM contacts WHERE id = $1`, [input.contact_id]);
+      if (c)
+        await this.setContactConsent(input.contact_id, input.channel, "opt_out", input.reason ?? "suppressed");
+    }
+    return { ...row, created_at: isoOrNull(row?.created_at), synced_at: isoOrNull(row?.synced_at) };
+  }
+  async unsuppressAddress(channel, address) {
+    await this.client.execute(`DELETE FROM contact_suppressions WHERE channel = $1 AND address = $2`, [channel, address]);
+  }
+  async listSuppressions(opts = {}) {
+    const where = [];
+    const params = [];
+    if (opts.channel) {
+      params.push(opts.channel);
+      where.push(`channel = $${params.length}`);
+    }
+    if (opts.unsyncedOnly)
+      where.push(`synced_at IS NULL`);
+    const sql = `SELECT * FROM contact_suppressions ${where.length ? `WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at ASC`;
+    return (await this.client.many(sql, params)).map((r) => ({ ...r, created_at: isoOrNull(r.created_at), synced_at: isoOrNull(r.synced_at) }));
+  }
+  async resolveAudience(idOrSlug, channel) {
+    const audience = await this.getAudience(idOrSlug);
+    const candidates = await this.client.many(`SELECT * FROM contacts WHERE archived = false`);
+    const predicates = audience.predicates;
+    const norm = (v) => v === null || v === undefined ? null : typeof v === "boolean" ? v ? "true" : "false" : String(v);
+    const compare2 = (actual, p) => {
+      const op = p.op ?? "eq";
+      const a = norm(actual);
+      switch (op) {
+        case "exists":
+          return a !== null && a !== "";
+        case "not_exists":
+          return a === null || a === "";
+        case "eq":
+          return a !== null && a === norm(p.value);
+        case "neq":
+          return a === null || a !== norm(p.value);
+        case "in":
+          return a !== null && (p.values ?? []).some((v) => norm(v) === a);
+        case "not_in":
+          return a === null || !(p.values ?? []).some((v) => norm(v) === a);
+        default:
+          return false;
+      }
+    };
+    const membership = (names, p) => {
+      const op = p.op ?? "eq";
+      const set = new Set(names.map((n) => n.toLowerCase()));
+      const has = (v) => {
+        const n = norm(v);
+        return n !== null && set.has(n.toLowerCase());
+      };
+      switch (op) {
+        case "exists":
+          return set.size > 0;
+        case "not_exists":
+          return set.size === 0;
+        case "eq":
+          return has(p.value);
+        case "neq":
+          return !has(p.value);
+        case "in":
+          return (p.values ?? []).some(has);
+        case "not_in":
+          return !(p.values ?? []).some(has);
+        default:
+          return false;
+      }
+    };
+    const matched = [];
+    for (const row of candidates) {
+      const results = [];
+      for (const p of predicates) {
+        if (p.kind === "tag") {
+          const names = (await this.client.many(`SELECT t.name FROM tags t JOIN contact_tags ct ON ct.tag_id = t.id WHERE ct.contact_id = $1`, [row.id])).map((r) => r.name);
+          results.push(membership(names, p));
+        } else if (p.kind === "group") {
+          const rows = await this.client.many(`SELECT g.name, g.id FROM groups g JOIN contact_groups cg ON cg.group_id = g.id WHERE cg.contact_id = $1`, [row.id]);
+          results.push(membership(rows.flatMap((r) => [r.name, r.id]), p));
+        } else if (p.kind === "attribute") {
+          const key = p.key ?? "";
+          const val = key in row && key !== "custom_fields" ? row[key] : pj(row.custom_fields, {})[key];
+          results.push(compare2(val, p));
+        } else
+          results.push(false);
+      }
+      if (audience.match === "any" ? results.some(Boolean) : results.every(Boolean))
+        matched.push(row);
+    }
+    const suppressed = new Set((await this.client.many(`SELECT address FROM contact_suppressions WHERE channel = $1`, [channel])).map((r) => r.address.toLowerCase()));
+    const recipients = [];
+    const excluded = [];
+    const consentAllows2 = (policy, status) => policy === "opt_in" ? status === "opt_in" : policy === "none" ? true : status !== "opt_out";
+    for (const row of matched) {
+      const cid = row.id;
+      if (row.do_not_contact) {
+        excluded.push({ contact_id: cid, reason: "do_not_contact" });
+        continue;
+      }
+      let address = null;
+      if (channel === "email") {
+        const e = await this.client.get(`SELECT address FROM emails WHERE contact_id = $1 ORDER BY is_primary DESC, created_at ASC LIMIT 1`, [cid]);
+        address = e?.address ?? null;
+      } else if (channel === "sms") {
+        const p = await this.client.get(`SELECT number FROM phones WHERE contact_id = $1 ORDER BY is_primary DESC, created_at ASC LIMIT 1`, [cid]);
+        address = p?.number ?? null;
+      } else {
+        const s = await this.client.get(`SELECT handle, url FROM social_profiles WHERE contact_id = $1 AND platform = 'telegram' ORDER BY is_primary DESC, created_at ASC LIMIT 1`, [cid]);
+        address = s?.handle ?? s?.url ?? null;
+      }
+      if (!address) {
+        excluded.push({ contact_id: cid, reason: "no_address" });
+        continue;
+      }
+      if (suppressed.has(address.toLowerCase())) {
+        excluded.push({ contact_id: cid, reason: "suppressed" });
+        continue;
+      }
+      const consent = await this.client.get(`SELECT status FROM contact_consent WHERE contact_id = $1 AND channel = $2`, [cid, channel]);
+      const status = consent?.status ?? "unknown";
+      if (!consentAllows2(String(audience.consent_policy), status)) {
+        excluded.push({ contact_id: cid, reason: "consent" });
+        continue;
+      }
+      recipients.push({ contact_id: cid, display_name: row.display_name, address, consent_status: status });
+    }
+    return { audience_id: audience.audience_id, channel, consent_policy: audience.consent_policy, matched: matched.length, recipients, excluded };
+  }
+  async getUpcomingItems(days = 7) {
+    const now4 = new Date;
+    const future = new Date(now4.getTime() + days * 86400000);
+    const todayStr = now4.toISOString().slice(0, 10);
+    const futureStr = future.toISOString().slice(0, 10);
+    const urgency = (d) => d < todayStr ? "overdue" : d === todayStr ? "today" : "upcoming";
+    const items = [];
+    for (const r of await this.client.many(`SELECT id, display_name, follow_up_at FROM contacts WHERE follow_up_at IS NOT NULL AND follow_up_at <= $1 AND do_not_contact = false`, [futureStr]))
+      items.push({ date: r.follow_up_at, type: "follow_up", contact_id: r.id, contact_name: r.display_name, title: `Follow up with ${r.display_name}`, urgency: urgency(r.follow_up_at) });
+    for (const t of await this.client.many(`SELECT ct.id, ct.contact_id, ct.title, ct.deadline, c.display_name FROM contact_tasks ct JOIN contacts c ON ct.contact_id = c.id WHERE ct.deadline IS NOT NULL AND ct.deadline <= $1 AND ct.status NOT IN ('completed','cancelled')`, [futureStr]))
+      items.push({ date: t.deadline, type: "task_deadline", contact_id: t.contact_id, contact_name: t.display_name, title: t.title, urgency: urgency(t.deadline) });
+    for (const a of await this.client.many(`SELECT a.follow_up_date, a.program_name, c.display_name AS contact_name FROM applications a LEFT JOIN contacts c ON a.primary_contact_id = c.id WHERE a.follow_up_date IS NOT NULL AND a.follow_up_date <= $1`, [futureStr]))
+      items.push({ date: a.follow_up_date, type: "application_followup", contact_name: a.contact_name ?? undefined, title: `Follow up: ${a.program_name}`, urgency: urgency(a.follow_up_date) });
+    for (const v of await this.client.many(`SELECT vc.follow_up_date, vc.company_id, co.name AS company_name, vc.subject, vc.type FROM vendor_communications vc JOIN companies co ON vc.company_id = co.id WHERE vc.follow_up_date IS NOT NULL AND vc.follow_up_date <= $1 AND vc.follow_up_done = false`, [futureStr]))
+      items.push({ date: v.follow_up_date, type: "vendor_followup", company_id: v.company_id, company_name: v.company_name, title: `Follow up with ${v.company_name}: ${v.subject || v.type}`, urgency: urgency(v.follow_up_date) });
+    for (const c of await this.client.many(`SELECT id, display_name, birthday FROM contacts WHERE birthday IS NOT NULL AND do_not_contact = false`)) {
+      const bday = new Date(c.birthday);
+      const thisYear = new Date(now4.getFullYear(), bday.getMonth(), bday.getDate());
+      const nextBday = thisYear >= now4 ? thisYear : new Date(now4.getFullYear() + 1, bday.getMonth(), bday.getDate());
+      const nextStr = nextBday.toISOString().slice(0, 10);
+      if (nextStr <= futureStr)
+        items.push({ date: nextStr, type: "birthday", contact_id: c.id, contact_name: c.display_name, title: `Birthday: ${c.display_name}`, urgency: nextStr === todayStr ? "today" : "upcoming" });
+    }
+    return items.sort((a, b) => String(a.date).localeCompare(String(b.date)));
+  }
+  async listContactAudit() {
+    const rows = await this.client.many(`SELECT * FROM contacts LIMIT 500`);
+    const results = await Promise.all(rows.map(async (row) => {
+      const details = await this.loadDetails(mapContact(row));
+      const c = details;
+      const missing = [];
+      const suggestions = [];
+      let score = 0;
+      if (c.emails?.length)
+        score += 20;
+      else {
+        missing.push("email");
+        suggestions.push("Add an email address");
+      }
+      if (c.phones?.length)
+        score += 15;
+      else {
+        missing.push("phone");
+        suggestions.push("Add a phone number");
+      }
+      if (c.company_id)
+        score += 15;
+      else {
+        missing.push("company");
+        suggestions.push("Link to a company");
+      }
+      if (c.last_contacted_at)
+        score += 20;
+      else {
+        missing.push("last_contacted_at");
+        suggestions.push("Log a contact interaction");
+      }
+      if (c.tags?.length)
+        score += 10;
+      else {
+        missing.push("tags");
+        suggestions.push("Add at least one tag");
+      }
+      if (c.notes)
+        score += 10;
+      else {
+        missing.push("notes");
+        suggestions.push("Add notes");
+      }
+      if (c.job_title)
+        score += 10;
+      else {
+        missing.push("job_title");
+        suggestions.push("Add a job title");
+      }
+      return { contact_id: c.id, display_name: c.display_name, score, missing, suggestions };
+    }));
+    return results.sort((a, b) => a.score - b.score);
+  }
+  async getContactTimeline(contactId, limit = 50) {
+    const items = [];
+    for (const n of await this.client.many(`SELECT created_at, body FROM contact_notes WHERE contact_id = $1 ORDER BY created_at DESC LIMIT 50`, [contactId]))
+      items.push({ date: iso(n.created_at), type: "note", title: "Note", body: n.body });
+    for (const e of await this.client.many(`SELECT event_date, type, title, notes, outcome, duration_min FROM events WHERE contact_ids LIKE $1 ORDER BY event_date DESC LIMIT 50`, [`%${contactId}%`]))
+      items.push({ date: e.event_date, type: "event", title: `${e.type}: ${e.title}`, body: e.notes ?? undefined, metadata: { outcome: e.outcome, duration_min: e.duration_min } });
+    for (const t of await this.client.many(`SELECT title, created_at, updated_at, status, deadline, priority FROM contact_tasks WHERE contact_id = $1 ORDER BY created_at DESC LIMIT 30`, [contactId])) {
+      items.push({ date: iso(t.created_at), type: "task_created", title: `Task created: ${t.title}`, metadata: { deadline: t.deadline, priority: t.priority } });
+      if (t.status === "completed")
+        items.push({ date: iso(t.updated_at), type: "task_completed", title: `Task completed: ${t.title}` });
+    }
+    for (const c of await this.client.many(`SELECT vc.comm_date, vc.type, co.name AS company_name, vc.subject FROM vendor_communications vc JOIN companies co ON vc.company_id = co.id WHERE vc.contact_id = $1 ORDER BY vc.comm_date DESC LIMIT 20`, [contactId]))
+      items.push({ date: c.comm_date, type: "vendor_comm", title: `${c.type} \u2014 ${c.company_name}`, body: c.subject ?? undefined });
+    for (const a of await this.client.many(`SELECT created_at, action, details FROM activity_log WHERE contact_id = $1 ORDER BY created_at DESC LIMIT 30`, [contactId]))
+      items.push({ date: iso(a.created_at), type: "interaction", title: a.action, body: a.details ?? undefined });
+    return items.sort((a, b) => b.date.localeCompare(a.date)).slice(0, limit);
+  }
+  async getNetworkStats() {
+    const today = new Date().toISOString().slice(0, 10);
+    const d30 = new Date(Date.now() - 30 * 86400000).toISOString().slice(0, 10);
+    const d60 = new Date(Date.now() - 60 * 86400000).toISOString().slice(0, 10);
+    const d7 = new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 10);
+    const n = async (sql, params = []) => Number((await this.client.get(sql, params))?.c ?? 0);
+    return {
+      total_contacts: await n(`SELECT COUNT(*) c FROM contacts WHERE archived = false`),
+      total_companies: await n(`SELECT COUNT(*) c FROM companies WHERE archived = false`),
+      owned_entities: await n(`SELECT COUNT(*) c FROM companies WHERE is_owned_entity = true`),
+      total_tags: await n(`SELECT COUNT(*) c FROM tags`),
+      total_groups: await n(`SELECT COUNT(*) c FROM groups`),
+      total_deals: await n(`SELECT COUNT(*) c FROM deals WHERE stage NOT IN ('won','lost','cancelled')`),
+      total_events: await n(`SELECT COUNT(*) c FROM events`),
+      cold_30d: await n(`SELECT COUNT(*) c FROM contacts WHERE archived = false AND do_not_contact = false AND (last_contacted_at IS NULL OR last_contacted_at < $1)`, [d30]),
+      cold_60d: await n(`SELECT COUNT(*) c FROM contacts WHERE archived = false AND do_not_contact = false AND (last_contacted_at IS NULL OR last_contacted_at < $1)`, [d60]),
+      cold_never: await n(`SELECT COUNT(*) c FROM contacts WHERE archived = false AND do_not_contact = false AND last_contacted_at IS NULL`),
+      contacts_with_email: await n(`SELECT COUNT(DISTINCT contact_id) c FROM emails WHERE contact_id IS NOT NULL`),
+      contacts_with_phone: await n(`SELECT COUNT(DISTINCT contact_id) c FROM phones WHERE contact_id IS NOT NULL`),
+      contacts_no_company: await n(`SELECT COUNT(*) c FROM contacts WHERE archived = false AND company_id IS NULL`),
+      overdue_tasks: await n(`SELECT COUNT(*) c FROM contact_tasks WHERE deadline < $1 AND status NOT IN ('completed','cancelled')`, [today]),
+      pending_applications: await n(`SELECT COUNT(*) c FROM applications WHERE status IN ('submitted','pending','follow_up_needed')`),
+      missing_invoices: await n(`SELECT COUNT(*) c FROM vendor_communications WHERE type = 'invoice_request' AND status IN ('awaiting_response','no_response')`),
+      upcoming_7d: await n(`SELECT COUNT(*) c FROM contacts WHERE follow_up_at BETWEEN $1 AND $2`, [today, d7]),
+      notes_count: await n(`SELECT COUNT(*) c FROM contact_notes`),
+      active_deals_value: await n(`SELECT COALESCE(SUM(value_usd),0) c FROM deals WHERE stage NOT IN ('won','lost','cancelled') AND currency = 'USD'`)
+    };
+  }
+  async getContactCard(contactId) {
+    const contact = await this.getContact(contactId);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const details = await this.loadDetails(contact);
+    return {
+      id: details.id,
+      display_name: details.display_name,
+      job_title: details.job_title,
+      company: details.company?.name,
+      primary_email: details.emails?.find((e) => e.is_primary)?.address || details.emails?.[0]?.address,
+      primary_phone: details.phones?.find((p) => p.is_primary)?.number || details.phones?.[0]?.number
+    };
+  }
+  async getContactBrief(contactId, taskContext) {
+    const contact = await this.getContact(contactId);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const details = await this.loadDetails(contact);
+    const notes = (await this.listNotes(contactId)).slice(0, 3);
+    const learnings = (await this.getLearnings(contactId, { min_importance: 7 })).slice(0, 5);
+    const ctx = (taskContext ?? "").toLowerCase();
+    const last = contact.last_contacted_at;
+    const daysSince = last ? Math.floor((Date.now() - new Date(last).getTime()) / 86400000) : null;
+    const brief = {
+      id: contact.id,
+      display_name: contact.display_name,
+      job_title: contact.job_title,
+      company: details.company?.name,
+      status: contact.status,
+      last_contacted: daysSince !== null ? `${daysSince}d ago` : "never",
+      relationship_health: contact.relationship_health,
+      engagement_status: contact.engagement_status,
+      preferred_contact: contact.preferred_contact_method
+    };
+    if (ctx.includes("meeting") || ctx.includes("call") || ctx.includes("prep")) {
+      brief.recent_notes = notes.map((nt) => ({ date: String(nt.created_at ?? "").slice(0, 10), content: nt.body }));
+      brief.key_learnings = learnings.map((l) => l.content);
+    }
+    if (ctx.includes("outreach") || ctx.includes("email")) {
+      brief.preferred_channel = contact.preferred_channel;
+      brief.follow_up_at = contact.follow_up_at;
+    }
+    if (ctx.includes("deal"))
+      brief.company_details = details.company ? { name: details.company.name, domain: details.company.domain } : null;
+    if (learnings.length)
+      brief.top_learnings = learnings.map((l) => l.content);
+    return brief;
+  }
+  async assembleContext(contactIds, format) {
+    const briefs = await Promise.all(contactIds.map(async (id) => {
+      try {
+        return await this.getContactBrief(id, format);
+      } catch {
+        return { id, error: "not found" };
+      }
+    }));
+    return { format, contact_count: contactIds.length, assembled_at: new Date().toISOString(), contacts: briefs };
+  }
+  async generateBrief(contactId) {
+    const contact = await this.getContact(contactId);
+    if (!contact)
+      throw new Error(`Contact not found: ${contactId}`);
+    const details = await this.loadDetails(contact);
+    const notes = await this.listNotes(contactId);
+    const allTasks = await this.listContactTasks({ contact_id: contactId });
+    const tasks = allTasks.filter((t) => !["completed", "cancelled"].includes(String(t.status)));
+    const nowIsoStr = new Date().toISOString();
+    const overdueTasks = allTasks.filter((t) => t.deadline && String(t.deadline) < nowIsoStr && !["completed", "cancelled"].includes(String(t.status)));
+    const companyRels = await this.listCompanyRelationships({ contact_id: contactId });
+    const recentTimeline = await this.getContactTimeline(contactId, 5);
+    const last = contact.last_contacted_at;
+    const daysSince = last ? Math.floor((Date.now() - new Date(last).getTime()) / 86400000) : null;
+    const lines = [];
+    lines.push(`# ${contact.display_name}`);
+    if (contact.job_title)
+      lines.push(`**Role:** ${contact.job_title}${contact.company_id ? ` (linked to company)` : ""}`);
+    const emails = details.emails ?? [];
+    const phones = details.phones ?? [];
+    const pe = emails.find((e) => e.is_primary) || emails[0];
+    if (pe)
+      lines.push(`**Email:** ${pe.address}`);
+    const pp = phones.find((p) => p.is_primary) || phones[0];
+    if (pp)
+      lines.push(`**Phone:** ${pp.number}`);
+    if (contact.preferred_contact_method)
+      lines.push(`**Preferred contact:** ${contact.preferred_contact_method}`);
+    lines.push("");
+    lines.push(`## Status`);
+    lines.push(`- Last contacted: ${daysSince !== null ? `${daysSince} days ago` : "never"}`);
+    lines.push(`- Status: ${contact.status || "active"}`);
+    if (contact.follow_up_at)
+      lines.push(`- Follow-up scheduled: ${contact.follow_up_at}`);
+    if (overdueTasks.length)
+      lines.push(`- OVERDUE TASKS: ${overdueTasks.length}`);
+    if (companyRels.length) {
+      lines.push("");
+      lines.push(`## Entity Relationships`);
+      for (const r of companyRels)
+        lines.push(`- ${r.relationship_type} \u2014 ${r.notes || ""}`);
+    }
+    if (tasks.length) {
+      lines.push("");
+      lines.push(`## Open Tasks`);
+      for (const t of tasks)
+        lines.push(`- [${t.priority}] ${t.title}${t.deadline ? ` (due ${t.deadline})` : ""}`);
+    }
+    if (notes.length) {
+      lines.push("");
+      lines.push(`## Recent Notes`);
+      for (const nt of notes.slice(0, 3))
+        lines.push(`**${String(nt.created_at ?? "").slice(0, 10)}:** ${nt.body}`);
+    }
+    if (recentTimeline.length) {
+      lines.push("");
+      lines.push(`## Recent Activity`);
+      for (const item of recentTimeline)
+        lines.push(`- ${item.date.slice(0, 10)} ${item.title}`);
+    }
+    if (contact.notes) {
+      lines.push("");
+      lines.push(`## Background Notes`);
+      lines.push(String(contact.notes));
+    }
+    return lines.join(`
+`);
+  }
+  async vaultStatus() {
+    let document_count = 0;
+    try {
+      document_count = Number((await this.client.get(`SELECT COUNT(*) n FROM contact_documents`))?.n ?? 0);
+    } catch {}
+    return { initialized: false, unlocked: false, document_count };
+  }
+}
+function getContactsPgStore(client) {
+  if (!cachedStore2)
+    cachedStore2 = new ContactsPgStore(client);
+  return cachedStore2;
+}
+var cachedStore2 = null;
+
+// src/server/v1.ts
+function json5(body, status = 200) {
+  return new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+}
+function error(status, message, extra) {
+  return json5({ error: message, ...extra ?? {} }, status);
+}
+async function readJson(req) {
+  try {
+    const text = await req.text();
+    if (!text)
+      return {};
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function handleV1Request(req, url) {
+  const path = url.pathname;
+  if (path !== "/v1" && !path.startsWith("/v1/"))
+    return null;
+  const method = req.method.toUpperCase();
+  const isWrite = method !== "GET" && method !== "HEAD";
+  const requiredScopes = [isWrite ? `${CONTACTS_APP_SLUG}:write` : `${CONTACTS_APP_SLUG}:read`];
+  let verifier;
+  try {
+    verifier = getCloudVerifier();
+  } catch (e) {
+    return error(503, e.message);
+  }
+  const decision = await verifier.authenticate(req.headers, { method, path, requiredScopes });
+  if (!decision.ok) {
+    return error(decision.status, decision.message, { reason: decision.reason });
+  }
+  await ensureCloudSchemaBestEffort();
+  const store = getContactsPgStore(getCloudClient());
+  const segments = path.split("/").filter(Boolean);
+  const resource = segments[1];
+  const id = segments[2];
+  const sub = segments[3];
+  const qp = (name) => url.searchParams.get(name) ?? undefined;
+  const qn = (name) => {
+    const v = url.searchParams.get(name);
+    return v === null ? undefined : Number(v);
+  };
+  try {
+    if (resource === "contacts" && id && sub) {
+      if (method === "GET" && sub === "timeline")
+        return json5({ timeline: await store.getContactTimeline(id, qn("limit") ?? 50) });
+      if (method === "GET" && sub === "brief")
+        return json5({ brief: await store.getContactBrief(id, qp("context")) });
+      if (method === "GET" && sub === "brief-text")
+        return json5({ text: await store.generateBrief(id) });
+      if (method === "GET" && sub === "card")
+        return json5({ card: await store.getContactCard(id) });
+      if (method === "GET" && sub === "freshness")
+        return json5({ freshness: await store.getFreshnessScore(id) });
+      if (method === "GET" && sub === "signals")
+        return json5({ signals: await store.getRelationshipSignals(id) });
+      if (method === "GET" && sub === "notes")
+        return json5({ notes: qp("company_id") ? await store.listNotesForContactAtCompany(id, qp("company_id")) : await store.listNotes(id) });
+      if (method === "GET" && sub === "consent")
+        return json5({ consent: await store.listContactConsent(id) });
+      if (method === "GET" && sub === "identities")
+        return json5({ identities: await store.getContactIdentities(id) });
+      if (method === "GET" && sub === "groups")
+        return json5({ groups: await store.listGroupsForContact(id) });
+      if (method === "GET" && sub === "org-memberships")
+        return json5({ org_members: await store.listOrgMembersForContact(id) });
+      if (method === "GET" && sub === "relationships")
+        return json5({ relationships: await store.listRelationships({ contact_id: id }) });
+      if (method === "GET" && sub === "company-relationships")
+        return json5({ relationships: await store.listCompanyRelationships({ contact_id: id }) });
+      if (method === "GET" && sub === "field-history")
+        return json5({ history: await store.getFieldHistory(id, qp("field_name")) });
+      if (method === "GET" && sub === "field-at")
+        return json5({ fields: await store.getContactAt(id, qp("timestamp") ?? new Date().toISOString()) });
+      if (sub === "job-history") {
+        if (method === "GET")
+          return json5({ job_history: await store.getJobHistory(id) });
+        if (method === "POST") {
+          const body = await readJson(req);
+          return json5({ job: await store.addJobEntry(id, body ?? {}) }, 201);
+        }
+      }
+      if (sub === "learnings") {
+        if (method === "GET")
+          return json5({ learnings: await store.getLearnings(id, { type: qp("type"), min_importance: qn("min_importance"), visibility: qp("visibility") }) });
+        if (method === "POST") {
+          const body = await readJson(req);
+          return json5({ learning: await store.saveLearning(id, body ?? {}) }, 201);
+        }
+      }
+      if (sub === "consent" && method === "POST") {
+        const body = await readJson(req);
+        if (!body)
+          return error(400, "invalid JSON body");
+        return json5({ consent: await store.setContactConsent(id, body.channel, body.status, body.source) });
+      }
+      if (sub === "field-verify" && method === "POST") {
+        const body = await readJson(req);
+        if (!body)
+          return error(400, "invalid JSON body");
+        await store.markFieldVerified(id, body.field_name, body.source);
+        return json5({ ok: true });
+      }
+      return error(404, `unknown /v1/contacts/:id/${sub}`);
+    }
+    if (resource === "contacts") {
+      if (!id) {
+        if (method === "GET") {
+          const result = await store.listContacts({
+            ...url.searchParams.get("company_id") ? { company_id: url.searchParams.get("company_id") } : {},
+            ...url.searchParams.get("status") ? { status: url.searchParams.get("status") } : {},
+            ...url.searchParams.get("q") ? { q: url.searchParams.get("q") } : {},
+            ...url.searchParams.get("limit") ? { limit: Number(url.searchParams.get("limit")) } : {},
+            ...url.searchParams.get("offset") ? { offset: Number(url.searchParams.get("offset")) } : {}
+          });
+          return json5(result);
+        }
+        if (method === "POST") {
+          const body = await readJson(req);
+          if (!body)
+            return error(400, "invalid JSON body");
+          const contact = await store.createContact(body);
+          return json5({ contact }, 201);
+        }
+        return error(405, `method ${method} not allowed on /v1/contacts`);
+      }
+      if (method === "GET") {
+        const contact = await store.getContact(id);
+        return contact ? json5({ contact }) : error(404, "contact not found");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const body = await readJson(req);
+        if (!body)
+          return error(400, "invalid JSON body");
+        const contact = await store.updateContact(id, body);
+        return contact ? json5({ contact }) : error(404, "contact not found");
+      }
+      if (method === "DELETE") {
+        const deleted = await store.deleteContact(id);
+        return deleted ? json5({ deleted: true, id }) : error(404, "contact not found");
+      }
+      return error(405, `method ${method} not allowed on /v1/contacts/:id`);
+    }
+    if (resource === "companies") {
+      if (!id) {
+        if (method === "GET") {
+          const result = await store.listCompanies({
+            ...url.searchParams.get("industry") ? { industry: url.searchParams.get("industry") } : {},
+            ...url.searchParams.get("limit") ? { limit: Number(url.searchParams.get("limit")) } : {},
+            ...url.searchParams.get("offset") ? { offset: Number(url.searchParams.get("offset")) } : {}
+          });
+          return json5(result);
+        }
+        if (method === "POST") {
+          const body = await readJson(req);
+          if (!body || typeof body.name !== "string" || !body.name.trim()) {
+            return error(400, "name is required");
+          }
+          const company = await store.createCompany(body);
+          return json5({ company }, 201);
+        }
+        return error(405, `method ${method} not allowed on /v1/companies`);
+      }
+      if (method === "GET") {
+        const company = await store.getCompany(id);
+        return company ? json5({ company }) : error(404, "company not found");
       }
       if (method === "PATCH" || method === "PUT") {
         const body = await readJson(req);
@@ -17761,6 +19195,521 @@ async function handleV1Request(req, url) {
     if (resource === "stats" && method === "GET") {
       return json5(await store.stats());
     }
+    if (resource === "deals") {
+      if (id && sub === "team" && method === "GET")
+        return json5({ team: await store.getDealTeam(id) });
+      if (id && sub === "roles" && method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5({ role: await store.setDealContactRole(id, b.contact_id, b.account_role) }, 201);
+      }
+      if (!id) {
+        if (method === "GET")
+          return json5({ deals: await store.listDeals({ stage: qp("stage"), contact_id: qp("contact_id"), company_id: qp("company_id") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ deal: await store.createDeal(b) }, 201);
+        }
+        return error(405, `method ${method} not allowed on /v1/deals`);
+      }
+      if (method === "GET") {
+        const d = await store.getDeal(id);
+        return d ? json5({ deal: d }) : error(404, "deal not found");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        const d = await store.updateDeal(id, b);
+        return d ? json5({ deal: d }) : error(404, "deal not found");
+      }
+      if (method === "DELETE")
+        return await store.deleteDeal(id) ? json5({ deleted: true, id }) : error(404, "deal not found");
+      return error(405, "method not allowed");
+    }
+    if (resource === "events") {
+      if (!id) {
+        if (method === "GET")
+          return json5({ events: await store.listEvents({ contact_id: qp("contact_id"), company_id: qp("company_id"), type: qp("type"), date_from: qp("date_from"), date_to: qp("date_to") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ event: await store.logEvent(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "DELETE")
+        return await store.deleteEvent(id) ? json5({ deleted: true, id }) : error(404, "event not found");
+      return error(405, "method not allowed");
+    }
+    if (resource === "tasks") {
+      if (id === "overdue" && method === "GET")
+        return json5({ tasks: await store.listOverdueTasks() });
+      if (id === "escalations" && method === "GET")
+        return json5({ escalations: await store.checkEscalations() });
+      if (!id) {
+        if (method === "GET")
+          return json5({ tasks: await store.listContactTasks({ contact_id: qp("contact_id"), entity_id: qp("entity_id"), status: qp("status"), priority: qp("priority") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ task: await store.createContactTask(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        const t = await store.updateContactTask(id, b);
+        return t ? json5({ task: t }) : error(404, "task not found");
+      }
+      if (method === "DELETE")
+        return await store.deleteContactTask(id) ? json5({ deleted: true, id }) : error(404, "task not found");
+      return error(405, "method not allowed");
+    }
+    if (resource === "applications") {
+      if (id === "follow-up-due" && method === "GET")
+        return json5({ applications: await store.listFollowUpDueApplications() });
+      if (!id) {
+        if (method === "GET")
+          return json5({ applications: await store.listApplications({ type: qp("type"), status: qp("status"), provider_company_id: qp("provider_company_id"), applicant_contact_id: qp("applicant_contact_id") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ application: await store.createApplication(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        const a = await store.updateApplication(id, b);
+        return a ? json5({ application: a }) : error(404, "application not found");
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "groups") {
+      if (id === "for-contact" && sub && method === "GET")
+        return json5({ groups: await store.listGroupsForContact(sub) });
+      if (id === "for-company" && sub && method === "GET")
+        return json5({ groups: await store.listGroupsForCompany(sub) });
+      if (id && sub === "contacts") {
+        if (method === "GET")
+          return json5({ contact_ids: await store.listContactsInGroup(id) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b?.contact_id)
+            return error(400, "contact_id required");
+          return json5(await store.addContactToGroup(b.contact_id, id));
+        }
+        if (method === "DELETE") {
+          const cid = segments[4];
+          if (!cid)
+            return error(400, "contact id required");
+          await store.removeContactFromGroup(cid, id);
+          return json5({ ok: true });
+        }
+      }
+      if (id && sub === "companies") {
+        if (method === "GET")
+          return json5({ company_ids: await store.listCompaniesInGroup(id) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b?.company_id)
+            return error(400, "company_id required");
+          return json5(await store.addCompanyToGroup(b.company_id, id));
+        }
+        if (method === "DELETE") {
+          const coid = segments[4];
+          if (!coid)
+            return error(400, "company id required");
+          await store.removeCompanyFromGroup(coid, id);
+          return json5({ ok: true });
+        }
+      }
+      if (!id) {
+        if (method === "GET")
+          return json5({ groups: await store.listGroups(qp("project_id")) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ group: await store.createGroup(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "GET") {
+        const g = await store.getGroup(id);
+        return g ? json5({ group: g }) : error(404, "group not found");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        const g = await store.updateGroup(id, b);
+        return g ? json5({ group: g }) : error(404, "group not found");
+      }
+      if (method === "DELETE")
+        return await store.deleteGroup(id) ? json5({ deleted: true, id }) : error(404, "group not found");
+      return error(405, "method not allowed");
+    }
+    if (resource === "vendor-comms") {
+      if (id === "missing-invoices" && method === "GET")
+        return json5({ communications: await store.listMissingInvoices() });
+      if (id === "pending-follow-ups" && method === "GET")
+        return json5({ communications: await store.listPendingFollowUps() });
+      if (id && sub === "mark-done" && method === "POST") {
+        const c = await store.markFollowUpDone(id);
+        return c ? json5({ communication: c }) : error(404, "not found");
+      }
+      if (!id) {
+        if (method === "GET") {
+          const companyId = qp("company_id");
+          if (!companyId)
+            return error(400, "company_id required");
+          return json5({ communications: await store.listVendorCommunications(companyId, { type: qp("type"), status: qp("status"), direction: qp("direction") }) });
+        }
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ communication: await store.logVendorCommunication(b) }, 201);
+        }
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "org-members") {
+      if (!id) {
+        if (method === "GET") {
+          if (qp("contact_id"))
+            return json5({ org_members: await store.listOrgMembersForContact(qp("contact_id")) });
+          if (qp("company_id"))
+            return json5({ org_members: await store.listOrgMembers(qp("company_id")) });
+          return error(400, "company_id or contact_id required");
+        }
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ org_member: await store.addOrgMember(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        const m = await store.updateOrgMember(id, b);
+        return m ? json5({ org_member: m }) : error(404, "not found");
+      }
+      if (method === "DELETE")
+        return await store.removeOrgMember(id) ? json5({ deleted: true, id }) : error(404, "not found");
+      return error(405, "method not allowed");
+    }
+    if (resource === "notes") {
+      if (!id) {
+        if (method === "GET") {
+          const cid = qp("contact_id");
+          if (!cid)
+            return error(400, "contact_id required");
+          return json5({ notes: qp("company_id") ? await store.listNotesForContactAtCompany(cid, qp("company_id")) : await store.listNotes(cid) });
+        }
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b?.contact_id || !b?.body)
+            return error(400, "contact_id and body required");
+          return json5({ note: await store.addNote(b.contact_id, b.body, b.created_by, b.company_id) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "DELETE") {
+        await store.deleteNote(id);
+        return json5({ ok: true });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "relationships") {
+      if (!id) {
+        if (method === "GET")
+          return json5({ relationships: await store.listRelationships({ contact_id: qp("contact_id") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ relationship: await store.createRelationship(b) }, 201);
+        }
+      }
+      if (method === "DELETE" && id) {
+        await store.deleteRelationship(id);
+        return json5({ ok: true });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "company-relationships") {
+      if (!id) {
+        if (method === "GET")
+          return json5({ relationships: await store.listCompanyRelationships({ contact_id: qp("contact_id"), company_id: qp("company_id") }) });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ relationship: await store.createCompanyRelationship(b) }, 201);
+        }
+      }
+      if (method === "DELETE" && id) {
+        await store.deleteCompanyRelationship(id);
+        return json5({ ok: true });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "learnings") {
+      if (id === "search" && method === "GET")
+        return json5({ learnings: await store.searchLearnings(qp("q") ?? "", { type: qp("type"), contact_id: qp("contact_id") }) });
+      if (id === "stale" && method === "GET")
+        return json5({ learnings: await store.getStaleLearnings(qn("days_old") ?? 30, qn("min_confidence") ?? 0) });
+      if (id === "maintenance" && method === "POST")
+        return json5(await store.runLearningMaintenance());
+      if (id && sub === "confirm" && method === "POST") {
+        await store.confirmLearning(id);
+        return json5({ ok: true });
+      }
+      return error(404, "unknown /v1/learnings route");
+    }
+    if (resource === "locks") {
+      if (id && method === "GET") {
+        const l = await store.checkContactLock(id);
+        return json5({ lock: l });
+      }
+      if (!id && method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5(await store.acquireContactLock(b.contact_id, b.agent_name, b.ttl_seconds, b.reason, b.session_id));
+      }
+      if (id && method === "DELETE") {
+        const released = await store.releaseContactLock(id, qp("agent_name") ?? "");
+        return json5({ released });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "activity") {
+      if (method === "GET") {
+        const cid = qp("contact_id");
+        if (!cid)
+          return error(400, "contact_id required");
+        return json5({ activity: await store.getAgentActivity(cid, qn("limit") ?? 20) });
+      }
+      if (method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        await store.logAgentActivity(b.contact_id, b.agent_name, b.action, b.details, b.session_id);
+        return json5({ ok: true }, 201);
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "identity") {
+      if (id === "resolve" && method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5({ matches: await store.resolveContactIdentity(b) });
+      }
+      if (!id) {
+        if (method === "GET") {
+          const cid = qp("contact_id");
+          if (!cid)
+            return error(400, "contact_id required");
+          return json5({ identities: await store.getContactIdentities(cid) });
+        }
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ identity: await store.addContactIdentity(b.contact_id, b.system, b.external_id, b.external_url, b.confidence) }, 201);
+        }
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "signals") {
+      if (id === "ghost" && method === "GET")
+        return json5({ signals: await store.getGhostContacts() });
+      if (id === "warming" && method === "GET")
+        return json5({ signals: await store.getWarmingContacts() });
+      if (id === "recompute" && method === "POST")
+        return json5(await store.recomputeSignals());
+      if (!id && method === "GET") {
+        const cid = qp("contact_id");
+        if (!cid)
+          return error(400, "contact_id required");
+        return json5({ signals: await store.getRelationshipSignals(cid) });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "freshness") {
+      if (id === "stale" && method === "GET")
+        return json5({ contacts: await store.getStaleContacts(qn("threshold") ?? 40) });
+      if (id === "verify" && method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        await store.markFieldVerified(b.contact_id, b.field_name, b.source);
+        return json5({ ok: true });
+      }
+      if (id && method === "GET")
+        return json5({ freshness: await store.getFreshnessScore(id) });
+      return error(405, "method not allowed");
+    }
+    if (resource === "graph") {
+      if (id === "strength" && sub && method === "GET")
+        return json5({ strength: await store.computeRelationshipStrength(sub) });
+      if (id === "warm-path" && method === "GET")
+        return json5({ path: await store.findWarmPath(qp("from") ?? "", qp("to") ?? "") });
+      if (id === "company" && sub && method === "GET")
+        return json5({ connections: await store.findConnectionsAtCompany(sub) });
+      if (id === "cooling" && method === "GET")
+        return json5({ cooling: await store.detectCoolingRelationships() });
+      return error(404, "unknown /v1/graph route");
+    }
+    if (resource === "org-chart") {
+      if (id === "coverage" && sub && method === "GET")
+        return json5({ coverage: await store.getCoverageGaps(sub) });
+      if (!id) {
+        if (method === "GET") {
+          const cid = qp("company_id");
+          if (!cid)
+            return error(400, "company_id required");
+          return json5({ edges: await store.listOrgChart(cid) });
+        }
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ edge: await store.addOrgChartEdge(b.company_id, b.contact_a_id, b.contact_b_id, b.edge_type, b.inferred) }, 201);
+        }
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "audiences") {
+      if (id && sub === "resolve" && method === "GET")
+        return json5({ resolution: await store.resolveAudience(id, qp("channel") ?? "email") });
+      if (!id) {
+        if (method === "GET")
+          return json5({ audiences: await store.listAudiences() });
+        if (method === "POST") {
+          const b = await readJson(req);
+          if (!b)
+            return error(400, "invalid JSON body");
+          return json5({ audience: await store.createAudience(b) }, 201);
+        }
+        return error(405, "method not allowed");
+      }
+      if (method === "GET")
+        return json5({ audience: await store.getAudience(id) });
+      if (method === "PATCH" || method === "PUT") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5({ audience: await store.updateAudience(id, b) });
+      }
+      if (method === "DELETE") {
+        await store.deleteAudience(id);
+        return json5({ deleted: true, id });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "consent") {
+      if (method === "GET") {
+        const cid = qp("contact_id");
+        if (!cid)
+          return error(400, "contact_id required");
+        return json5({ consent: await store.listContactConsent(cid) });
+      }
+      if (method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5({ consent: await store.setContactConsent(b.contact_id, b.channel, b.status, b.source) });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "suppressions") {
+      if (method === "GET")
+        return json5({ suppressions: await store.listSuppressions({ channel: qp("channel"), unsyncedOnly: qp("unsynced") === "1" || qp("unsynced") === "true" }) });
+      if (method === "POST") {
+        const b = await readJson(req);
+        if (!b)
+          return error(400, "invalid JSON body");
+        return json5({ suppression: await store.suppressAddress(b) }, 201);
+      }
+      if (method === "DELETE") {
+        const channel = qp("channel");
+        const address = qp("address");
+        if (!channel || !address)
+          return error(400, "channel and address required");
+        await store.unsuppressAddress(channel, address);
+        return json5({ ok: true });
+      }
+      return error(405, "method not allowed");
+    }
+    if (resource === "field-history" && method === "GET") {
+      const cid = qp("contact_id");
+      if (!cid)
+        return error(400, "contact_id required");
+      if (id === "at")
+        return json5({ fields: await store.getContactAt(cid, qp("timestamp") ?? new Date().toISOString()) });
+      return json5({ history: await store.getFieldHistory(cid, qp("field_name")) });
+    }
+    if (resource === "job-history") {
+      if (method === "GET") {
+        const cid = qp("contact_id");
+        if (!cid)
+          return error(400, "contact_id required");
+        return json5({ job_history: await store.getJobHistory(cid) });
+      }
+      if (method === "POST") {
+        const b = await readJson(req);
+        if (!b?.contact_id)
+          return error(400, "contact_id required");
+        return json5({ job: await store.addJobEntry(b.contact_id, b) }, 201);
+      }
+    }
+    if (resource === "cold-contacts" && method === "GET")
+      return json5({ contacts: await store.listColdContacts(qn("days") ?? 30) });
+    if (resource === "not-contacted" && method === "GET")
+      return json5({ contacts: await store.listContactsNotContactedSince(qn("days") ?? 90, qn("limit") ?? 50) });
+    if (resource === "followup-due-contacts" && method === "GET")
+      return json5({ contacts: await store.listFollowupDueContacts(qp("on_or_before") ?? new Date().toISOString()) });
+    if (resource === "contacts-for-context" && method === "GET")
+      return json5({ contacts: await store.findContactsForContext(qp("topic") ?? "", qn("limit") ?? 20) });
+    if (resource === "email-duplicates" && method === "GET")
+      return json5({ duplicates: await store.findEmailDuplicates() });
+    if (resource === "name-duplicates" && method === "GET")
+      return json5({ duplicates: await store.findNameDuplicates() });
+    if (resource === "contact-audit" && method === "GET")
+      return json5({ audit: await store.listContactAudit() });
+    if (resource === "upcoming" && method === "GET")
+      return json5({ items: await store.getUpcomingItems(qn("days") ?? 7) });
+    if (resource === "network-stats" && method === "GET")
+      return json5({ stats: await store.getNetworkStats() });
+    if (resource === "recent-events" && method === "GET")
+      return json5({ events: await store.getRecentContactEvents(qp("since"), qp("types") ? qp("types").split(",") : undefined) });
+    if (resource === "vault-status" && method === "GET")
+      return json5({ vault: await store.vaultStatus() });
+    if (resource === "assemble-context" && method === "POST") {
+      const b = await readJson(req);
+      if (!b)
+        return error(400, "invalid JSON body");
+      return json5({ context: await store.assembleContext(b.contact_ids ?? [], b.format ?? "meeting_prep") });
+    }
     return error(404, `unknown /v1 resource: ${resource ?? "(root)"}`);
   } catch (e) {
     const msg = e.message || "internal error";