@agifyai/leadify-mcp 8.3.8 → 8.4.0

package/README.md

@@ -198,6 +198,7 @@ Conséquences pratiques :
 | `update_schema` | Ajouter ou modifier les définitions de champs d'un groupe. |
 | `delete_columns` | Supprimer des colonnes du schéma et des données d'un groupe. |
 | `update_hidden_columns` | Afficher ou masquer des colonnes dans la vue tableau (réversible). |
+| `list_crm_schema_packs` | Lister le catalogue canonique des CRM Schema Packs, leurs domaines et contraintes de compatibilité. |
 | `add_campaign_log` | Enregistrer une entrée de log de campagne pour un lead. |
 | `get_campaign_logs` | Récupérer les logs de campagne avec filtres et pagination. |
 | `delete_campaign_log` | Supprimer une entrée de log de campagne. |
@@ -214,6 +215,13 @@ Conséquences pratiques :
 | `add_activity` | Journaliser une interaction prospect (LinkedIn, email, call) dans le feed du lead. |
 | `compile_context_pack` | Compiler en lecture seule un Context Pack canonique depuis une cible explicite (`organization`, `lead_group`, `campaign`, `account`, `person`) ou un couple lead + campagne pour `WRITE_OUTREACH`. Retourne publications courantes, sources, freshness, contradictions et provenance. N’utilise jamais la Data Room legacy ni ne choisit de cible implicite. |
 | `get_context_workspace` | Lire le Context Workspace canonique versionné (`company_brain` ou `gtm_playbook`) d'une organisation explicitement sélectionnée. Retourne le brouillon et la dernière version publiée. |
+| `list_canonical_relationships` | Lire les liens canoniques typés d'une organisation, dans les deux directions. |
+| `create_canonical_relationship` | Créer un lien canonique tenant-scoped et idempotent entre deux identités fortes. |
+| `update_canonical_relationship` | Modifier, restaurer ou tombstoner un lien via le ledger transactionnel partagé. |
+| `tombstone_canonical_relationship` | Retirer réversiblement un lien sans supprimer son historique ni ses preuves. |
+| `preview_canonical_relationship_migration` | Prévisualiser une migration de champs historiques, divergences et quarantaines comprises, sans mutation. |
+| `apply_canonical_relationship_migration` | Appliquer exactement un plan prévisualisé et borné grâce à son digest. |
+| `rollback_canonical_relationship_migration` | Tombstoner les liens créés par un plan de migration précis. |
 | `update_company_brain_sections` | Modifier uniquement les sections indiquées du Company Brain : le MCP relit le brouillon ou la dernière publication, fusionne les sections ciblées, puis sauvegarde avec révision attendue et clé d'idempotence. |
 | `update_gtm_playbook_sections` | Modifier uniquement les sections indiquées du GTM Playbook, avec la même lecture-fusion-révision atomiquement contrôlée. |
 | `publish_context_workspace` | Publier une révision prête du Context Workspace après confirmation explicite (`confirm_publish: true`). Admin de l'organisation requis ; les raisons de non-readiness sont renvoyées par le serveur. |
@@ -225,7 +233,8 @@ Conséquences pratiques :
 | `update_company_info_economics` | Patch du bloc economics (pricingModel, ticketRange, salesCycleMonths, triggers, defaultBaseline). |
 | `update_company_info_product_icp` | Add / replace / remove un seul ICP dans productICPs[]. Lookup par productId (must match a products[].name). Cap 5. |
 | `update_company_info_proof_wording` | Patch du bloc proofWording (keyMetrics, miniStories, forbiddenWords). |
-| `upsert_persona` | Créer ou mettre à jour un persona (ciblage, messaging, outils actifs). |
+| `upsert_persona` | Créer ou mettre à jour atomiquement un Persona, avec `schema_packs` obligatoire à la création. |
+| `update_persona_schema_packs` | Remplacer uniquement les CRM Schema Packs d’un Persona et relire les preuves de readiness des groupes liés. |
 | `get_persona` | Récupérer un persona par son ID. |
 | `get_lead_group_persona` | Récupérer le persona assigné à un groupe de leads. |
 | `list_data_sources` | Lister toutes les sources de données configurées (par pays puis nom). |

package/dist/client.d.ts

@@ -7,6 +7,6 @@ export declare class LeadifyClient {
     post(path: string, body: unknown): Promise<unknown>;
     put(path: string, body: unknown): Promise<unknown>;
     patch(path: string, body: unknown): Promise<unknown>;
-    delete(path: string): Promise<unknown>;
+    delete(path: string, body?: unknown): Promise<unknown>;
 }
 export declare function getClient(): LeadifyClient;

package/dist/client.js

@@ -17,7 +17,7 @@ export class LeadifyClient {
         };
         const init = { method, headers };
         if (body !== undefined &&
-            (method === "POST" || method === "PUT" || method === "PATCH")) {
+            (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE")) {
             headers["Content-Type"] = "application/json";
             init.body = JSON.stringify(body);
         }
@@ -53,9 +53,9 @@ export class LeadifyClient {
         const url = new URL(path, this.baseUrl);
         return this.request("PATCH", url, body);
     }
-    async delete(path) {
+    async delete(path, body) {
         const url = new URL(path, this.baseUrl);
-        return this.request("DELETE", url);
+        return this.request("DELETE", url, body);
     }
 }
 let _client = null;

package/dist/server.js

@@ -14,16 +14,18 @@ import { registerPipelineTools } from "./tools/pipeline.js";
 import { registerFineTuningTools } from "./tools/fine_tuning.js";
 import { registerContextWorkspaceTools } from "./tools/context_workspace.js";
 import { registerLeadViewTools } from "./tools/views.js";
+import { registerRelationshipTools } from "./tools/relationships.js";
 export function createServer() {
     const server = new McpServer({
         name: "leadify",
-        version: "8.3.6",
+        version: "8.4.0",
     });
     registerAuthTools(server);
     registerOrganizationTools(server);
     registerLeadGroupTools(server);
     registerLeadViewTools(server);
     registerLeadTools(server);
+    registerRelationshipTools(server);
     registerSchemaTools(server);
     registerLogTools(server);
     registerCampaignTools(server);

package/dist/tools/leads.js

@@ -24,7 +24,8 @@ export function registerLeadTools(server, client = getClient()) {
     server.tool("add_leads", "Add one or more leads to a specific lead group in Leadify. Provide the group ID " +
         "and an array of lead objects with any combination of fields (email, firstName, " +
         "lastName, company, jobTitle, phone, custom fields, card_* fields, percent_* " +
-        "fields, relation fields, etc.). Optionally specify which fields should be " +
+        "fields, etc.). Canonical relation fields are read-only here: use " +
+        "create_canonical_relationship or the migration tools instead. Optionally specify which fields should be " +
         "treated as 'select' dropdowns in the UI. Returns the count of successfully " +
         "imported leads and any errors. Use this for both bulk imports and single lead creation.", {
         lead_group_id: z
@@ -35,7 +36,7 @@ export function registerLeadTools(server, client = getClient()) {
             .describe("Array of lead objects. Each object is a key-value map of field names to values. " +
             "Common fields: email, firstName, lastName, company, jobTitle, phone, linkedin, " +
             "website, location, seniority, specialty, age. Also supports card_* fields, " +
-            "percent_* fields, boolean flags (decisionMaking, excluded), and relation fields."),
+            "percent_* fields and boolean flags (decisionMaking, excluded). Canonical relation fields are rejected."),
         is_select_fields: z
             .array(z.string())
             .optional()
@@ -149,7 +150,8 @@ export function registerLeadTools(server, client = getClient()) {
     server.tool("update_lead", "Update one or more fields on an existing lead. Each update specifies the field " +
         "name, new value, and optionally whether the field is a 'select' dropdown type. " +
         "Supports all field types including special fields (card_*, percent_*, boolean flags " +
-        "like decisionMaking/excluded), and relation fields. Returns the updated lead. " +
+        "like decisionMaking/excluded). When a configured canonical relation field is changed, " +
+        "the backend routes it through the typed relationship service and keeps the JSON field read-only. Returns the updated lead. " +
         "For bulk updates across many leads, call this tool once per lead.", {
         lead_id: z.string().describe("ID of the lead to update."),
         updates: z

package/dist/tools/personas.d.ts

@@ -1,2 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerPersonaTools(server: McpServer): void;
+import { type LeadifyClient } from "../client.js";
+export declare const CRM_SCHEMA_PACKS: readonly ["base_person", "base_company", "healthcare", "medtech", "recruitment_hr", "community_creator"];
+type PersonaClient = Pick<LeadifyClient, "get" | "post" | "delete">;
+export declare function crmSchemaPackSelectionError(packs: readonly string[], workflowMode?: "person_first" | "company_first" | null): string | null;
+export declare function registerPersonaTools(server: McpServer, client?: PersonaClient): void;
+export {};

package/dist/tools/personas.js

@@ -55,6 +55,41 @@ const icpStrategyShape = {
     keyObjections: z.array(z.string()).optional(),
     decisionDrivers: z.array(z.string()).optional(),
 };
+export const CRM_SCHEMA_PACKS = [
+    "base_person",
+    "base_company",
+    "healthcare",
+    "medtech",
+    "recruitment_hr",
+    "community_creator",
+];
+const SECTOR_BASE_COMPATIBILITY = {
+    healthcare: ["base_person", "base_company"],
+    medtech: ["base_person", "base_company"],
+    recruitment_hr: ["base_person", "base_company"],
+    community_creator: ["base_person", "base_company"],
+};
+export function crmSchemaPackSelectionError(packs, workflowMode) {
+    const unknown = [...new Set(packs.filter(pack => !CRM_SCHEMA_PACKS.includes(pack)))];
+    if (unknown.length > 0)
+        return `Unknown CRM Schema Pack: ${unknown.sort().join(", ")}. Call list_crm_schema_packs first.`;
+    const selected = [...new Set(packs)];
+    const bases = selected.filter(pack => pack === "base_person" || pack === "base_company");
+    const sectors = selected.filter(pack => pack !== "base_person" && pack !== "base_company");
+    if (bases.length !== 1 || sectors.length > 1 || selected.length !== packs.length) {
+        return "Select exactly one base CRM Schema Pack and at most one sector pack; duplicates are not allowed.";
+    }
+    const base = bases[0];
+    if (workflowMode !== undefined && workflowMode !== null) {
+        const expectedBase = workflowMode === "company_first" ? "base_company" : "base_person";
+        if (base !== expectedBase)
+            return `${base} is incompatible with workflow_mode=${workflowMode}; use ${expectedBase}.`;
+    }
+    const incompatibleSector = sectors.find(sector => !SECTOR_BASE_COMPATIBILITY[sector].includes(base));
+    return incompatibleSector
+        ? `${incompatibleSector} is incompatible with ${base}. Call list_crm_schema_packs for compatible combinations.`
+        : null;
+}
 // camelCase mapping for nested objects that the backend expects as-is.
 function mapLookalikeClient(c) {
     const out = { name: c.name };
@@ -139,10 +174,10 @@ class PersonaPatchError extends Error {
  * Strategy: fast-path the direct GET; on 404, fall back to the permissive
  * list endpoint and find by id. Other errors propagate immediately.
  */
-async function fetchPersona(id) {
+async function fetchPersona(id, client = getClient()) {
     const directPath = `/api/persona/${encodeURIComponent(id)}`;
     try {
-        const data = await getClient().get(directPath);
+        const data = await client.get(directPath);
         if (!data || typeof data !== "object") {
             throw new PersonaPatchError("read", directPath, null, data, "Unexpected response shape (expected an object).");
         }
@@ -162,7 +197,7 @@ async function fetchPersona(id) {
     const listPath = "/api/persona";
     let listed;
     try {
-        listed = await getClient().get(listPath);
+        listed = await client.get(listPath);
     }
     catch (err) {
         if (err instanceof LeadifyApiError) {
@@ -183,10 +218,10 @@ async function fetchPersona(id) {
     }
     return found;
 }
-async function postPersonaUpdate(id, name, fieldsToWrite) {
+async function postPersonaUpdate(id, name, fieldsToWrite, client = getClient()) {
     const path = "/api/persona";
     try {
-        return await getClient().post(path, {
+        return await client.post(path, {
             id,
             name,
             ...fieldsToWrite,
@@ -227,7 +262,7 @@ function handlePersonaToolError(error) {
     return handleToolError(error);
 }
 // ─── Tool registrations ────────────────────────────────────────────────────
-export function registerPersonaTools(server) {
+export function registerPersonaTools(server, client) {
     // ════════════════════════════════════════════════════════════════════════
     // ESCAPE HATCH — wholesale upsert
     // ════════════════════════════════════════════════════════════════════════
@@ -297,6 +332,12 @@ export function registerPersonaTools(server) {
             .nullable()
             .optional()
             .describe("Qualification mode."),
+        schema_packs: z
+            .array(z.enum(CRM_SCHEMA_PACKS))
+            .optional()
+            .describe("Canonical CRM Schema Packs. REQUIRED on create: exactly one base pack " +
+            "(base_person for person_first or base_company for company_first) and at most one " +
+            "compatible sector pack. Call list_crm_schema_packs before selecting values."),
         output_language: z
             .string()
             .nullable()
@@ -345,6 +386,14 @@ export function registerPersonaTools(server) {
             .describe("Snippets inserted at named points. scope: 'qualify' | 'outreach'; insertion_point: 'prefix' | 'phase_1_5' | 'phase_2_extra' | 'suffix'."),
     }, async (params) => {
         try {
+            if (params.id === undefined && params.schema_packs === undefined) {
+                throw new Error("schema_packs is required when creating a Persona. Call list_crm_schema_packs, then select exactly one base pack and at most one compatible sector pack.");
+            }
+            if (params.schema_packs !== undefined) {
+                const selectionError = crmSchemaPackSelectionError(params.schema_packs, params.workflow_mode ?? (params.id === undefined ? "person_first" : undefined));
+                if (selectionError)
+                    throw new Error(selectionError);
+            }
             const body = { name: params.name };
             if (params.id !== undefined)
                 body.id = params.id;
@@ -376,6 +425,8 @@ export function registerPersonaTools(server) {
                 body.strictMatch = params.strict_match;
             if (params.workflow_mode !== undefined)
                 body.workflowMode = params.workflow_mode;
+            if (params.schema_packs !== undefined)
+                body.schemaPacks = params.schema_packs;
             if (params.output_language !== undefined)
                 body.outputLanguage = params.output_language;
             if (params.enable_signals !== undefined)
@@ -404,7 +455,32 @@ export function registerPersonaTools(server) {
             if (params.extra_prompt_phases !== undefined)
                 body.extraPromptPhases =
                     params.extra_prompt_phases.map(mapExtraPromptPhase);
-            const data = await getClient().post("/api/persona", body);
+            const data = await (client ?? getClient()).post("/api/persona", body);
+            return toolResult(data);
+        }
+        catch (error) {
+            return handlePersonaToolError(error);
+        }
+    });
+    // ── update_persona_schema_packs ───────────────────────────────────────
+    server.tool("update_persona_schema_packs", "Safely replace one Persona's CRM Schema Packs without rewriting unrelated Persona sections. " +
+        "Reads the current Persona, validates exactly one workflow-compatible base and at most one " +
+        "compatible sector pack, then writes schemaPacks through the canonical Persona endpoint. " +
+        "The response includes the persisted Persona and readiness proofs for every linked group.", {
+        id: z.string().describe("Persona ID to update."),
+        schema_packs: z
+            .array(z.enum(CRM_SCHEMA_PACKS))
+            .min(1)
+            .describe("Complete replacement selection. Call list_crm_schema_packs first."),
+    }, async ({ id, schema_packs }) => {
+        try {
+            const api = client ?? getClient();
+            const persona = await fetchPersona(id, api);
+            const workflowMode = persona.workflowMode === "company_first" ? "company_first" : "person_first";
+            const selectionError = crmSchemaPackSelectionError(schema_packs, workflowMode);
+            if (selectionError)
+                throw new Error(selectionError);
+            const data = await postPersonaUpdate(id, persona.name, { schemaPacks: schema_packs }, api);
             return toolResult(data);
         }
         catch (error) {
@@ -428,7 +504,7 @@ export function registerPersonaTools(server) {
             "in its own tool)."),
     }, async ({ id, include_outreach }) => {
         try {
-            const data = await getClient().get(`/api/persona/${encodeURIComponent(id)}`);
+            const data = await (client ?? getClient()).get(`/api/persona/${encodeURIComponent(id)}`);
             // SILO defense in depth: strip the outreach trio locally unless the
             // caller explicitly opted in. Outreach data belongs to the dedicated
             // outreach tools — never mix it with the persona read by default.
@@ -470,14 +546,14 @@ export function registerPersonaTools(server) {
             // Step 1: resolve the persona assigned to this lead group (slim view).
             // We only need the persona's id from here — we re-fetch the full
             // persona below to grab the outreach trio.
-            const groupPersona = (await getClient().get(`/api/lead-group/${encodeURIComponent(lead_group_id)}/persona`));
+            const groupPersona = (await (client ?? getClient()).get(`/api/lead-group/${encodeURIComponent(lead_group_id)}/persona`));
             const personaId = groupPersona?.persona?.id;
             if (!personaId) {
                 return toolError(`No persona is assigned to lead group "${lead_group_id}". ` +
                     `Assign one via update_lead_group({ persona_id }) before reading outreach templates.`);
             }
             // Step 2: fetch the full persona so we can project the trio.
-            const full = (await getClient().get(`/api/persona/${encodeURIComponent(personaId)}`));
+            const full = (await (client ?? getClient()).get(`/api/persona/${encodeURIComponent(personaId)}`));
             // The API may return either a bare persona or {persona: {...}}.
             const persona = full.persona ?? full;
             const trio = {
@@ -523,7 +599,7 @@ export function registerPersonaTools(server) {
                 params.set("organizationId", organization_id);
             if (include_globals !== undefined)
                 params.set("includeGlobals", String(include_globals));
-            const data = await getClient().get("/api/persona", params);
+            const data = await (client ?? getClient()).get("/api/persona", params);
             if (verbose)
                 return toolResult(data);
             // Project to compact view: id, name, organizationId, truncated description.
@@ -562,7 +638,7 @@ export function registerPersonaTools(server) {
         id: z.string().describe("Persona ID to delete."),
     }, async ({ id }) => {
         try {
-            const data = await getClient().delete(`/api/persona/${encodeURIComponent(id)}`);
+            const data = await (client ?? getClient()).delete(`/api/persona/${encodeURIComponent(id)}`);
             return toolResult(data);
         }
         catch (error) {
@@ -580,7 +656,7 @@ export function registerPersonaTools(server) {
             .describe("Target organization ID (Clerk org ID). Pass null to make the persona global."),
     }, async ({ id, organization_id }) => {
         try {
-            const data = await getClient().post(`/api/persona/${encodeURIComponent(id)}/move`, { organizationId: organization_id });
+            const data = await (client ?? getClient()).post(`/api/persona/${encodeURIComponent(id)}/move`, { organizationId: organization_id });
             return toolResult(data);
         }
         catch (error) {
@@ -625,7 +701,7 @@ export function registerPersonaTools(server) {
                 enable_signals === undefined) {
                 return toolError("Provide at least one field to update.");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const body = {};
             if (description !== undefined)
                 body.description = description;
@@ -637,7 +713,7 @@ export function registerPersonaTools(server) {
                 body.strictMatch = strict_match;
             if (enable_signals !== undefined)
                 body.enableSignals = enable_signals;
-            const data = await postPersonaUpdate(id, name ?? current.name, body);
+            const data = await postPersonaUpdate(id, name ?? current.name, body, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -665,11 +741,11 @@ export function registerPersonaTools(server) {
                 (remove_keys === undefined || remove_keys.length === 0)) {
                 return toolError("Provide at least one of: patch (non-empty), remove_keys (non-empty).");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const next = { ...asObject(current.targetProfile), ...(patch ?? {}) };
             for (const k of remove_keys ?? [])
                 delete next[k];
-            const data = await postPersonaUpdate(id, current.name, { targetProfile: next });
+            const data = await postPersonaUpdate(id, current.name, { targetProfile: next }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -694,11 +770,11 @@ export function registerPersonaTools(server) {
                 (remove_keys === undefined || remove_keys.length === 0)) {
                 return toolError("Provide at least one of: patch (non-empty), remove_keys (non-empty).");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const next = { ...asObject(current.disqualificationCriteria), ...(patch ?? {}) };
             for (const k of remove_keys ?? [])
                 delete next[k];
-            const data = await postPersonaUpdate(id, current.name, { disqualificationCriteria: next });
+            const data = await postPersonaUpdate(id, current.name, { disqualificationCriteria: next }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -730,7 +806,7 @@ export function registerPersonaTools(server) {
             if (tools !== undefined && (add !== undefined || remove !== undefined)) {
                 return toolError("'tools' is mutually exclusive with 'add' / 'remove'.");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             let next;
             if (tools !== undefined) {
                 next = tools;
@@ -743,7 +819,7 @@ export function registerPersonaTools(server) {
                     set.delete(t);
                 next = Array.from(set);
             }
-            const data = await postPersonaUpdate(id, current.name, { activeTools: next });
+            const data = await postPersonaUpdate(id, current.name, { activeTools: next }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -781,7 +857,7 @@ export function registerPersonaTools(server) {
                 disqualified: "disqualifiedCriteria",
             };
             const field = fieldMap[tier];
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             let nextValue;
             if (typeof criteria === "string") {
                 nextValue = criteria;
@@ -793,7 +869,7 @@ export function registerPersonaTools(server) {
                     : {};
                 nextValue = { ...base, ...criteria };
             }
-            const data = await postPersonaUpdate(id, current.name, { [field]: nextValue });
+            const data = await postPersonaUpdate(id, current.name, { [field]: nextValue }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -816,29 +892,29 @@ export function registerPersonaTools(server) {
         client: lookalikeClient
             .optional()
             .describe("Client payload. Required for 'add' and 'replace'. Schema: {name, sector?, size?, segment?, comparison_criteria?}."),
-    }, async ({ id, action, name, client }) => {
+    }, async ({ id, action, name, client: lookalikeClientInput }) => {
         try {
-            if ((action === "add" || action === "replace") && !client) {
+            if ((action === "add" || action === "replace") && !lookalikeClientInput) {
                 return toolError(`client is required for action '${action}'.`);
             }
             if ((action === "replace" || action === "remove") && !name) {
                 return toolError(`name is required for action '${action}'.`);
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const list = asArray(current.lookalikeClients).map((c) => ({ ...c }));
             if (action === "add") {
-                const newName = client.name;
+                const newName = lookalikeClientInput.name;
                 if (list.some((c) => c.name === newName)) {
                     return toolError(`A lookalike client with name "${newName}" already exists. Use action 'replace' instead.`);
                 }
-                list.push(mapLookalikeClient(client));
+                list.push(mapLookalikeClient(lookalikeClientInput));
             }
             else if (action === "replace") {
                 const idx = list.findIndex((c) => c.name === name);
                 if (idx === -1) {
                     return toolError(`No lookalike client found with name "${name}".`);
                 }
-                list[idx] = mapLookalikeClient(client);
+                list[idx] = mapLookalikeClient(lookalikeClientInput);
             }
             else {
                 const before = list.length;
@@ -851,7 +927,7 @@ export function registerPersonaTools(server) {
             }
             const data = await postPersonaUpdate(id, current.name, {
                 lookalikeClients: list,
-            });
+            }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -883,7 +959,7 @@ export function registerPersonaTools(server) {
             if ((action === "replace" || action === "remove") && index === undefined) {
                 return toolError(`index is required for action '${action}'.`);
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const list = asArray(current.painPoints).map((p) => ({ ...p }));
             if (action === "add") {
                 list.push(pain);
@@ -900,7 +976,7 @@ export function registerPersonaTools(server) {
                 }
                 list.splice(index, 1);
             }
-            const data = await postPersonaUpdate(id, current.name, { painPoints: list });
+            const data = await postPersonaUpdate(id, current.name, { painPoints: list }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -941,7 +1017,7 @@ export function registerPersonaTools(server) {
                 context === undefined) {
                 return toolError("Provide at least one field to update.");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const body = {};
             if (normalization_rules !== undefined)
                 body.normalizationRules = normalization_rules;
@@ -951,7 +1027,7 @@ export function registerPersonaTools(server) {
                 body.toneInstructions = tone_instructions;
             if (context !== undefined)
                 body.context = context;
-            const data = await postPersonaUpdate(id, current.name, body);
+            const data = await postPersonaUpdate(id, current.name, body, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {
@@ -1004,7 +1080,7 @@ export function registerPersonaTools(server) {
                 (remove_keys === undefined || remove_keys.length === 0)) {
                 return toolError("Provide at least one field to update.");
             }
-            const current = await fetchPersona(id);
+            const current = await fetchPersona(id, client ?? getClient());
             const next = { ...asObject(current.icpStrategy) };
             if (dealType !== undefined)
                 next.dealType = dealType;
@@ -1020,7 +1096,7 @@ export function registerPersonaTools(server) {
                 Object.assign(next, patch);
             for (const k of remove_keys ?? [])
                 delete next[k];
-            const data = await postPersonaUpdate(id, current.name, { icpStrategy: next });
+            const data = await postPersonaUpdate(id, current.name, { icpStrategy: next }, client ?? getClient());
             return toolResult(data);
         }
         catch (error) {

package/dist/tools/relationships.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerRelationshipTools(server: McpServer, client?: import("../client.js").LeadifyClient): void;

package/dist/tools/relationships.js

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { handleToolError, toolResult } from "../types.js";
+const entityKind = z.enum(["ACCOUNT", "LEGAL_ENTITY", "ESTABLISHMENT", "PERSON", "EMPLOYMENT"]);
+const relationshipType = z.enum(["EMPLOYED_BY", "AFFILIATED_WITH", "PART_OF", "COLLEAGUE_OF"]);
+const entityRef = z.object({ kind: entityKind, id: z.string().min(1) }).strict();
+const confidence = z.object({
+    value: z.number().min(0).max(1),
+    method: z.string().min(1).max(100),
+    assessed_at: z.string().datetime(),
+}).strict();
+export function registerRelationshipTools(server, client = getClient()) {
+    server.tool("list_canonical_relationships", "List tenant-scoped canonical relationships. The response is direction-independent for consumers: filter by one entity to find both incoming and outgoing links. Legacy lead relation fields are compatibility projections, not the source of truth.", {
+        organization_id: z.string().min(1),
+        entity_kind: entityKind.optional(),
+        entity_id: z.string().min(1).optional(),
+        relationship_type: relationshipType.optional(),
+        state: z.enum(["ACTIVE", "TOMBSTONED"]).optional().default("ACTIVE"),
+        limit: z.number().int().min(1).max(500).optional().default(100),
+        cursor: z.string().optional(),
+    }, async ({ organization_id, entity_kind, entity_id, relationship_type, state, limit, cursor }) => {
+        try {
+            if (Boolean(entity_kind) !== Boolean(entity_id))
+                return toolResult({ error: "entity_kind and entity_id must be provided together" });
+            const params = new URLSearchParams({ organizationId: organization_id, state, limit: String(limit) });
+            if (entity_kind)
+                params.set("entityKind", entity_kind);
+            if (entity_id)
+                params.set("entityId", entity_id);
+            if (relationship_type)
+                params.set("relationshipType", relationship_type);
+            if (cursor)
+                params.set("cursor", cursor);
+            return toolResult(await client.get("/api/canonical-relationships", params));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("create_canonical_relationship", "Create one typed canonical relationship in a tenant. Endpoints must already be strong canonical identities in that tenant. Retries with the same idempotency key and payload are safe; a changed payload is rejected. This tool never creates placeholder identities or activates outreach.", {
+        organization_id: z.string().min(1), relationship_type: relationshipType,
+        source: entityRef, target: entityRef,
+        trust_state: z.enum(["CONFIRMED", "PROPOSED", "AMBIGUOUS", "CONFLICTED", "UNKNOWN"]).optional().default("UNKNOWN"),
+        confidence: confidence.optional(), evidence_ids: z.array(z.string()).max(100).optional().default([]),
+        valid_from: z.string().datetime().nullable().optional(), valid_to: z.string().datetime().nullable().optional(),
+        attributes: z.record(z.unknown()).optional(), idempotency_key: z.string().min(1).max(255),
+    }, async (params) => {
+        try {
+            return toolResult(await client.post("/api/canonical-relationships", {
+                organizationId: params.organization_id, relationshipType: params.relationship_type,
+                source: params.source, target: params.target, trustState: params.trust_state,
+                confidence: params.confidence ? { ...params.confidence, assessedAt: params.confidence.assessed_at, assessed_at: undefined } : undefined,
+                evidenceIds: params.evidence_ids, validFrom: params.valid_from, validTo: params.valid_to,
+                attributes: params.attributes, idempotencyKey: params.idempotency_key,
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("update_canonical_relationship", "Update, tombstone, or restore one canonical relationship through the shared transactional service. Every mutation is versioned in the immutable ledger and requires a unique idempotency key.", {
+        organization_id: z.string().min(1), relationship_id: z.string().min(1),
+        relationship_type: relationshipType.optional(), source: entityRef.optional(), target: entityRef.optional(),
+        trust_state: z.enum(["CONFIRMED", "PROPOSED", "AMBIGUOUS", "CONFLICTED", "UNKNOWN"]).optional(),
+        state: z.enum(["ACTIVE", "TOMBSTONED"]).optional(), evidence_ids: z.array(z.string()).max(100).optional(),
+        valid_from: z.string().datetime().nullable().optional(), valid_to: z.string().datetime().nullable().optional(),
+        attributes: z.record(z.unknown()).nullable().optional(), idempotency_key: z.string().min(1).max(255),
+    }, async (params) => {
+        try {
+            return toolResult(await client.patch(`/api/canonical-relationships/${encodeURIComponent(params.relationship_id)}`, {
+                organizationId: params.organization_id, relationshipType: params.relationship_type,
+                source: params.source, target: params.target, trustState: params.trust_state, state: params.state,
+                evidenceIds: params.evidence_ids, validFrom: params.valid_from, validTo: params.valid_to,
+                attributes: params.attributes, idempotencyKey: params.idempotency_key,
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("tombstone_canonical_relationship", "Soft-delete one canonical relationship while preserving its evidence and immutable history. Use this instead of deleting legacy relation fields.", { organization_id: z.string().min(1), relationship_id: z.string().min(1), idempotency_key: z.string().min(1).max(255) }, async ({ organization_id, relationship_id, idempotency_key }) => {
+        try {
+            return toolResult(await client.delete(`/api/canonical-relationships/${encodeURIComponent(relationship_id)}`, { organizationId: organization_id, idempotencyKey: idempotency_key }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    const migrationFields = {
+        organization_id: z.string().min(1), source_group_id: z.string().min(1), field: z.string().min(1),
+        relationship_type: relationshipType, endpoint_role: z.enum(["SOURCE", "TARGET"]),
+        source_label: z.string().min(1).max(120), target_label: z.string().min(1).max(120),
+        limit: z.number().int().min(1).max(500).optional().default(500),
+    };
+    const migrationBody = (params) => ({
+        organizationId: params.organization_id, sourceGroupId: params.source_group_id, field: params.field,
+        relationshipType: params.relationship_type, endpointRole: params.endpoint_role,
+        sourceLabel: params.source_label, targetLabel: params.target_label, limit: params.limit,
+    });
+    server.tool("preview_canonical_relationship_migration", "Read-only planner for a legacy LeadGroup relation. Returns the exact forward/inverse divergence matrix, unresolved identities, quarantine candidates, and a digest. It creates no identities, links, placeholders, campaigns, or outreach.", migrationFields, async (params) => {
+        try {
+            return toolResult(await client.post("/api/canonical-relationships/migration/preview", migrationBody(params)));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("apply_canonical_relationship_migration", "Apply exactly a previously reviewed canonical relationship migration plan. Requires its digest; the backend rejects drift, limits the batch, quarantines unresolved identities, and keeps external activation at zero.", { ...migrationFields, expected_plan_digest: z.string().regex(/^[a-f0-9]{64}$/) }, async (params) => {
+        try {
+            return toolResult(await client.post("/api/canonical-relationships/migration/apply", { ...migrationBody(params), expectedPlanDigest: params.expected_plan_digest }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("rollback_canonical_relationship_migration", "Tombstone every active relationship created by one migration digest. This is reversible and does not delete identities, evidence, leads, groups, or history.", { organization_id: z.string().min(1), plan_digest: z.string().regex(/^[a-f0-9]{64}$/), idempotency_key: z.string().min(1).max(200) }, async ({ organization_id, plan_digest, idempotency_key }) => {
+        try {
+            return toolResult(await client.post("/api/canonical-relationships/migration/rollback", { organizationId: organization_id, planDigest: plan_digest, idempotencyKey: idempotency_key }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/schema.d.ts

@@ -1,2 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerSchemaTools(server: McpServer): void;
+import { type LeadifyClient } from "../client.js";
+type SchemaClient = Pick<LeadifyClient, "get" | "post">;
+export declare function registerSchemaTools(server: McpServer, client?: SchemaClient): void;
+export {};

package/dist/tools/schema.js

@@ -1,7 +1,20 @@
 import { z } from "zod";
 import { getClient } from "../client.js";
 import { toolResult, handleToolError } from "../types.js";
-export function registerSchemaTools(server) {
+export function registerSchemaTools(server, client) {
+    // ── list_crm_schema_packs ──────────────────────────────────────────────
+    server.tool("list_crm_schema_packs", "List the canonical CRM Schema Pack catalogue before creating or updating a Persona. " +
+        "Returns every pack id, label, domain, base/sector kind, compatible base packs and " +
+        "workflow modes, field count, registry version and composition constraints. The catalogue " +
+        "is global code configuration, not organization-owned data.", {}, async () => {
+        try {
+            const data = await (client ?? getClient()).get("/api/persona-types");
+            return toolResult(data);
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
     // ── update_schema ──────────────────────────────────────────────────────
     server.tool("update_schema", "Add or modify field definitions in a lead group's schema. Each field update " +
         "specifies the internal field name, display label, data type, whether it's required, " +
@@ -58,7 +71,7 @@ export function registerSchemaTools(server) {
                     ...(u.options ? { options: u.options } : {}),
                 })),
             };
-            const data = await getClient().post("/update-schema", body);
+            const data = await (client ?? getClient()).post("/update-schema", body);
             return toolResult(data);
         }
         catch (error) {
@@ -88,7 +101,7 @@ export function registerSchemaTools(server) {
             else {
                 body.columnNames = column_names;
             }
-            const data = await getClient().post("/delete-column", body);
+            const data = await (client ?? getClient()).post("/delete-column", body);
             return toolResult(data);
         }
         catch (error) {
@@ -120,7 +133,7 @@ export function registerSchemaTools(server) {
                 body.addHiddenColumns = add_hidden;
             if (remove_hidden)
                 body.removeHiddenColumns = remove_hidden;
-            const data = await getClient().post("/update-hidden-columns", body);
+            const data = await (client ?? getClient()).post("/update-hidden-columns", body);
             return toolResult(data);
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agifyai/leadify-mcp",
-  "version": "8.3.8",
+  "version": "8.4.0",
   "description": "MCP server for Leadify lead management API",
   "type": "module",
   "main": "dist/index.js",