@agifyai/leadify-mcp 8.6.7 → 8.6.9

package/README.md

@@ -289,11 +289,14 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `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. |
+| `configure_lead_group_relations` | Configurer, dans un tenant explicitement vérifié, la projection legacy relue par une migration canonique. |
+| `preview_canonical_identity_backfill` | Prévisualiser le backfill d'identité tenant-scoped d'un groupe et de ses parents Company configurés. |
+| `apply_canonical_identity_backfill` | Appliquer exactement un backfill d'identité relu par digest, sans outreach ni activation. |
 | `update_company_brain_sections` | Modifier uniquement les sections globales encore actives (`identity`, `positioning`, `allowedVocabulary`, `prohibitedVocabulary`, `legalConstraints`). Les anciennes sections Offre/Verticale sont filtrées et refusées. |
 | `publish_context_workspace` | Publier une révision prête du Company Brain après confirmation explicite (`confirm_publish: true`). Admin de l'organisation requis ; les raisons de non-readiness sont renvoyées par le serveur. |
 | `list_persona_contracts` / `get_persona_contract` | Lister ou lire les contrats Persona canoniques d’une organisation explicitement sélectionnée. |
-| `create_persona_contract` | Créer un Persona tenant-scoped et lié à une Verticale depuis un contrat canonique complet. |
-| `replace_persona_contract` / `patch_persona_contract` | Remplacer ou modifier un contrat canonique avec verrou optimiste ; aucune colonne Persona historique n’est exposée. |
+| `create_persona_contract` | Créer un Persona tenant-scoped et lié à une Verticale depuis un contrat canonique v2 complet et strict. Toute clé inconnue est refusée. |
+| `replace_persona_contract` / `patch_persona_contract` | Remplacer ou modifier un contrat canonique v2 avec verrou optimiste. Le document est revalidé intégralement avant l’écriture et aucune colonne Persona historique n’est exposée. |
 | `change_persona_status` | Passer un Persona entre `DRAFT`, `ACTIVE` et `ARCHIVED` avec le même verrou `updated_at`, readiness et protection des références. |
 | `list_data_sources` | Lister toutes les sources de données configurées (par pays puis nom). |
 | `create_data_source` | Créer une nouvelle source de données (admin uniquement). |

package/dist/server.js

@@ -15,6 +15,7 @@ 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";
+import { registerCanonicalBackfillTools } from "./tools/canonical_backfill.js";
 import { registerCommercialTruthTools } from "./tools/commercial_truth.js";
 import { registerEventTools } from "./tools/events.js";
 import { registerContextEntityTools } from "./tools/context_entities.js";
@@ -30,6 +31,7 @@ export function createServer() {
     registerLeadViewTools(server);
     registerLeadTools(server);
     registerRelationshipTools(server);
+    registerCanonicalBackfillTools(server);
     registerEventTools(server);
     registerCommercialTruthTools(server);
     registerSchemaTools(server);

package/dist/tools/canonical_backfill.d.ts

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

package/dist/tools/canonical_backfill.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { handleToolError, toolResult } from "../types.js";
+const relationshipType = z.enum(["EMPLOYED_BY", "AFFILIATED_WITH", "PART_OF", "COLLEAGUE_OF"]);
+const relation = z.object({
+    field: z.string().trim().min(1),
+    lead_group_id: z.string().trim().min(1),
+    target_field: z.string().trim().min(1).optional(),
+    display_field: z.string().trim().min(1).optional(),
+    inverse_field: z.string().trim().min(1).optional(),
+    canonical_type: relationshipType.optional(),
+    canonical_endpoint_role: z.enum(["SOURCE", "TARGET"]).optional(),
+    canonical_label: z.string().trim().min(1).max(120).optional(),
+}).strict().superRefine((value, context) => {
+    if (Boolean(value.canonical_type) === Boolean(value.canonical_endpoint_role))
+        return;
+    context.addIssue({ code: z.ZodIssueCode.custom, path: ["canonical_type"], message: "canonical_type and canonical_endpoint_role must be provided together" });
+});
+function apiRelation(value) {
+    return {
+        field: value.field,
+        leadGroupId: value.lead_group_id,
+        targetField: value.target_field,
+        displayField: value.display_field,
+        inverseField: value.inverse_field,
+        canonicalType: value.canonical_type,
+        canonicalEndpointRole: value.canonical_endpoint_role,
+        canonicalLabel: value.canonical_label,
+    };
+}
+const backfillScope = {
+    organization_id: z.string().trim().min(1),
+    lead_group_id: z.string().trim().min(1),
+    lead_ids: z.array(z.string().trim().min(1)).min(1).max(100),
+};
+export function registerCanonicalBackfillTools(server, client = getClient()) {
+    server.tool("configure_lead_group_relations", "Configure the legacy projection that a canonical migration reads. The organization is mandatory and verified against both groups; canonical_type and canonical_endpoint_role must be specified together. This changes no lead, identity, canonical relationship, campaign, or outreach.", { organization_id: z.string().trim().min(1), lead_group_id: z.string().trim().min(1), relations: z.array(relation).max(100) }, async ({ organization_id, lead_group_id, relations }) => {
+        try {
+            return toolResult(await client.put(`/api/lead-group/${encodeURIComponent(lead_group_id)}/relations`, {
+                organizationId: organization_id,
+                relations: relations.map(apiRelation),
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("preview_canonical_identity_backfill", "Preview the tenant-scoped canonical identity backfill for one LeadGroup. It reads only the listed leads and their configured Company parent, returns an exact plan digest, and creates no identity, relationship, outreach, or activation.", backfillScope, async ({ organization_id, lead_group_id, lead_ids }) => {
+        try {
+            return toolResult(await client.post("/api/canonical-identity/backfill", {
+                organizationId: organization_id, leadGroupId: lead_group_id, leadIds: lead_ids,
+                projectionTarget: "lead", dryRun: true,
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("apply_canonical_identity_backfill", "Apply exactly a reviewed canonical identity backfill plan. The organization and LeadGroup stay explicit, and the backend rejects a changed digest, cross-tenant lead, missing parent, or missing canonical Company account. It never sends outreach or activates campaigns.", { ...backfillScope, expected_plan_digest: z.string().regex(/^[a-f0-9]{64}$/) }, async ({ organization_id, lead_group_id, lead_ids, expected_plan_digest }) => {
+        try {
+            return toolResult(await client.post("/api/canonical-identity/backfill", {
+                organizationId: organization_id, leadGroupId: lead_group_id, leadIds: lead_ids,
+                projectionTarget: "lead", dryRun: false, expectedPlanDigest: expected_plan_digest,
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/context_entities.d.ts

@@ -161,6 +161,13 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         implication?: string | undefined;
     }>, "many">>;
 }, "strict", z.ZodTypeAny, {
+    painPoints?: {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        customerCaseIds?: string[] | undefined;
+        useCaseIds?: string[] | undefined;
+    }[] | undefined;
     allowedVocabulary?: string[] | undefined;
     prohibitedVocabulary?: string[] | undefined;
     legalConstraints?: {
@@ -191,13 +198,6 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         description?: string | undefined;
         customerCaseIds?: string[] | undefined;
     }[] | undefined;
-    painPoints?: {
-        id: string;
-        title: string;
-        description?: string | undefined;
-        customerCaseIds?: string[] | undefined;
-        useCaseIds?: string[] | undefined;
-    }[] | undefined;
     qualificationSignals?: {
         id: string;
         title: string;
@@ -226,6 +226,13 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         implication?: string | undefined;
     }[] | undefined;
 }, {
+    painPoints?: {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        customerCaseIds?: string[] | undefined;
+        useCaseIds?: string[] | undefined;
+    }[] | undefined;
     allowedVocabulary?: string[] | undefined;
     prohibitedVocabulary?: string[] | undefined;
     legalConstraints?: {
@@ -256,13 +263,6 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         description?: string | undefined;
         customerCaseIds?: string[] | undefined;
     }[] | undefined;
-    painPoints?: {
-        id: string;
-        title: string;
-        description?: string | undefined;
-        customerCaseIds?: string[] | undefined;
-        useCaseIds?: string[] | undefined;
-    }[] | undefined;
     qualificationSignals?: {
         id: string;
         title: string;
@@ -291,6 +291,13 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         implication?: string | undefined;
     }[] | undefined;
 }>, {
+    painPoints?: {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        customerCaseIds?: string[] | undefined;
+        useCaseIds?: string[] | undefined;
+    }[] | undefined;
     allowedVocabulary?: string[] | undefined;
     prohibitedVocabulary?: string[] | undefined;
     legalConstraints?: {
@@ -321,13 +328,6 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         description?: string | undefined;
         customerCaseIds?: string[] | undefined;
     }[] | undefined;
-    painPoints?: {
-        id: string;
-        title: string;
-        description?: string | undefined;
-        customerCaseIds?: string[] | undefined;
-        useCaseIds?: string[] | undefined;
-    }[] | undefined;
     qualificationSignals?: {
         id: string;
         title: string;
@@ -356,6 +356,13 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         implication?: string | undefined;
     }[] | undefined;
 }, {
+    painPoints?: {
+        id: string;
+        title: string;
+        description?: string | undefined;
+        customerCaseIds?: string[] | undefined;
+        useCaseIds?: string[] | undefined;
+    }[] | undefined;
     allowedVocabulary?: string[] | undefined;
     prohibitedVocabulary?: string[] | undefined;
     legalConstraints?: {
@@ -386,13 +393,6 @@ export declare const verticalContextContentSchema: z.ZodEffects<z.ZodObject<{
         description?: string | undefined;
         customerCaseIds?: string[] | undefined;
     }[] | undefined;
-    painPoints?: {
-        id: string;
-        title: string;
-        description?: string | undefined;
-        customerCaseIds?: string[] | undefined;
-        useCaseIds?: string[] | undefined;
-    }[] | undefined;
     qualificationSignals?: {
         id: string;
         title: string;

package/dist/tools/personas.js

@@ -6,9 +6,68 @@ import { LeadifyApiError, handleToolError, toolResult } from "../types.js";
  * versioned `personaContract`. These tools deliberately do not expose any
  * historical Persona field or field-specific patch operation.
  */
-const contractSchema = z
-    .record(z.unknown())
-    .describe("Complete versioned Persona contract. Leadify validates its exact schema.");
+const tierSchema = z.object({
+    rule: z.string(),
+    expectedEvidence: z.string(),
+    examples: z.array(z.string()).max(20),
+}).strict();
+const commonContractSchema = z.object({
+    schemaVersion: z.literal(2),
+    kind: z.enum(["PERSON", "COMPANY"]),
+    targeting: z.object({
+        targetProfile: z.unknown().nullable(),
+        disqualificationCriteria: z.unknown().nullable(),
+        schemaPacks: z.array(z.string()).max(2),
+        agentDomain: z.string().nullable(),
+        outputLanguage: z.string().nullable(),
+    }).strict(),
+    qualification: z.object({
+        tiers: z.object({
+            hot: tierSchema,
+            warm: tierSchema,
+            cold: tierSchema,
+            disqualified: tierSchema,
+        }).strict(),
+        signalExamples: z.array(z.object({
+            id: z.string().min(1),
+            signal: z.string().min(1),
+            level: z.enum(["GOLDEN", "CRITICAL", "STRONG", "INFO"]),
+            justification: z.string().min(1),
+        }).strict()).max(100),
+        signalTierRules: z.unknown().nullable(),
+        enableSignals: z.boolean(),
+    }).strict(),
+    intelligence: z.object({
+        activeTools: z.array(z.string()),
+        painPoints: z.unknown().nullable(),
+        icpStrategy: z.unknown().nullable(),
+        cardAnalysisSections: z.unknown().nullable(),
+    }).strict(),
+    outreach: z.object({
+        outreachSignalRouting: z.unknown().nullable(),
+        outreachTemplates: z.unknown().nullable(),
+        toneInstructions: z.string().nullable(),
+        outreachFields: z.unknown().nullable(),
+    }).strict(),
+}).strict();
+const personExtensionSchema = z.object({
+    assessmentAxes: z.object({
+        identityAndEmployment: z.object({ question: z.string(), expectedEvidence: z.string() }).strict(),
+        commercialLink: z.object({ question: z.string(), expectedEvidence: z.string() }).strict(),
+        actionPower: z.object({ question: z.string(), expectedEvidence: z.string() }).strict(),
+        individualMoment: z.object({ question: z.string(), expectedEvidence: z.string() }).strict(),
+    }).strict(),
+    roleArchetypes: z.array(z.object({
+        name: z.string().min(1),
+        relevanceRule: z.string(),
+        expectedEvidence: z.string(),
+        examples: z.array(z.string()).max(20),
+    }).strict()).max(50),
+}).strict();
+const contractSchema = z.discriminatedUnion("kind", [
+    commonContractSchema.extend({ kind: z.literal("COMPANY"), person: z.null() }).strict(),
+    commonContractSchema.extend({ kind: z.literal("PERSON"), person: personExtensionSchema }).strict(),
+]).describe("Complete strict Persona contract, schemaVersion 2.");
 const tenantScope = {
     organization_id: z
         .string()
@@ -27,6 +86,7 @@ function canonicalPersona(persona) {
     if (!persona.personaContract || typeof persona.personaContract !== "object") {
         throw new Error("PERSONA_CONTRACT_REQUIRED: run the audited Persona migration before using this MCP.");
     }
+    const contract = contractSchema.parse(persona.personaContract);
     return {
         id: persona.id,
         name: persona.name,
@@ -34,7 +94,7 @@ function canonicalPersona(persona) {
         updatedAt: persona.updatedAt,
         revision: persona.revision ?? 0,
         status: persona.status,
-        contract: persona.personaContract,
+        contract,
     };
 }
 async function fetchPersona(id, organizationId, client) {
@@ -155,7 +215,7 @@ export function registerPersonaTools(server, injectedClient) {
                 organizationId: organization_id,
                 id,
                 expectedUpdatedAt: expected_updated_at,
-                contract: setContractPath(contract, path, value),
+                contract: contractSchema.parse(setContractPath(contract, path, value)),
                 client,
             }));
         }

package/package.json

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