@agifyai/leadify-mcp 8.7.1 → 8.7.3

package/README.md

@@ -233,6 +233,7 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `update_lead_group` | Modifier un groupe, y compris son `entity_kind`, avec réconciliation du schéma côté Leadify. |
 | `add_leads` | Ajouter un ou plusieurs leads à un groupe. |
 | `upsert_person_leads_with_employment` | Créer ou réconcilier atomiquement des Person Leads, PERSON, EMPLOYED_BY, projections et historique, sans effet commercial. |
+| `create_person_employment_evidence` / `get_person_employment_evidence` | Créer puis relire une preuve d’emploi individuelle tenant-scopée ; transmettre l’`evidence.id` retourné tel quel à l’upsert Person. |
 | `get_leads` | Rechercher et lister des leads avec filtres, recherche et pagination, dont le critère composé `event_filter`. |
 | `get_lead` | Récupérer les détails complets d'un lead par son ID. |
 | `update_lead` | Mettre à jour un ou plusieurs champs d'un lead existant. |
@@ -277,6 +278,9 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `leadify_read_activity_feed` | Lire l'audit borné d'un lead ; le feed ne constitue jamais une preuve de réponse. |
 | `get_commercial_truth` | Réconcilier CRM, email, LinkedIn, Unipile et activité avec un statut, une fraîcheur et une action recommandée ; aucune écriture ni envoi. |
 | `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, sans choisir de cible implicite. |
+| `get_claim_contradiction` | Lire une contradiction canonique tenant-scopée avec ses deux claims immuables, leurs preuves, sa version et son éventuelle résolution auditée. |
+| `resolve_claim_contradiction` | Arbitrer explicitement une contradiction relue par sélection d’un claim ou coexistence, avec justification, version, état attendu et clé d’idempotence ; aucun effet commercial. |
+| `resolve_claim_contradictions_batch` | Soumettre jusqu’à 100 arbitrages explicites et relire chaque résultat ordonné, sans choix automatique ni résolution implicite. |
 | `get_context_workspace` | Lire le seul Context Workspace encore exposé et versionné : le `company_brain` d'une organisation explicitement sélectionnée. Retourne le brouillon et la dernière version publiée ; l'historique GTM reste stocké mais n'est plus exposé. |
 | `list_verticals` / `get_vertical` | Lister ou lire les Verticales JSON simples d’une organisation explicitement sélectionnée, avec leurs Personas et Offres liées. |
 | `create_vertical` | Créer une Verticale tenant-scoped en `DRAFT`, sans activation ni sélection implicite. Son schéma JSON fermé porte les règles sectorielles et `commercialExperience` ; les métadonnées de preuve/source/provenance et les champs propres à l’Offre sont refusés. |
@@ -320,3 +324,7 @@ Leadify et ne doit jamais être envoyée par un agent MCP.
 | `append_fine_tuning` | Appendre du contenu à une section du Fine Tuning (nonNegotiableRules, pitfalls, structure, examples). Toujours en mode append — garantie contractuelle. |
 | `set_fine_tuning_output_config` | Remplacer uniquement la configuration métier de sorties d’un Fine Tuning (`linkedinConnection`, `linkedinMessage`, `email`, activations et quantités). Préserve Markdown, langues et fallback ; ne génère, ne planifie, n’active ni n’envoie aucun outreach. |
 | `pipeline_next_lead` | Sélectionner le prochain lead à traiter (score descendant, sans message). Exclusion des IDs déjà vus, limit 1-5. |
+
+### `source-icp-prospects` : preuve d’emploi
+
+Pour chaque candidat accepté, créer `create_person_employment_evidence` avec le tenant, la Company Lead, l’identité Person, la provenance et une clé idempotente. Relire si nécessaire avec `get_person_employment_evidence`, puis transmettre exclusivement l’`evidence.id` retourné dans `evidence_ids` de `upsert_person_leads_with_employment`.

package/dist/server.js

@@ -20,6 +20,7 @@ import { registerCommercialTruthTools } from "./tools/commercial_truth.js";
 import { registerEventTools } from "./tools/events.js";
 import { registerContextEntityTools } from "./tools/context_entities.js";
 import { registerPersonEmploymentTools } from "./tools/person_employment.js";
+import { registerClaimContradictionTools } from "./tools/claim_contradictions.js";
 import { MCP_SERVER_NAME, MCP_VERSION } from "./version.js";
 export function createServer() {
     const server = new McpServer({
@@ -33,6 +34,7 @@ export function createServer() {
     registerLeadTools(server);
     registerRelationshipTools(server);
     registerCanonicalBackfillTools(server);
+    registerClaimContradictionTools(server);
     registerPersonEmploymentTools(server);
     registerEventTools(server);
     registerCommercialTruthTools(server);

package/dist/tools/claim_contradictions.d.ts

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

package/dist/tools/claim_contradictions.js

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import { getClient } from "../client.js";
+import { handleToolError, toolResult } from "../types.js";
+const id = z.string().trim().min(1).max(200);
+const decision = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("SELECT_CLAIM"), retained_claim_id: id }).strict(),
+    z.object({ type: z.literal("COEXIST") }).strict(),
+]);
+const resolutionFields = {
+    decision,
+    justification: z.string().trim().min(8).max(2_000),
+    expected_version: z.number().int().min(1),
+    expected_status: z.literal("OPEN"),
+    idempotency_key: z.string().trim().min(8).max(220),
+};
+const resolution = z.object(resolutionFields).strict();
+const resolutionItem = resolution.extend({ contradiction_id: id }).strict();
+function apiResolution(input) {
+    return {
+        decision: input.decision.type === "SELECT_CLAIM"
+            ? { type: input.decision.type, retainedClaimId: input.decision.retained_claim_id }
+            : { type: input.decision.type },
+        justification: input.justification,
+        expectedVersion: input.expected_version,
+        expectedStatus: input.expected_status,
+        idempotencyKey: input.idempotency_key,
+    };
+}
+export function registerClaimContradictionTools(server, client = getClient()) {
+    server.registerTool("get_claim_contradiction", {
+        title: "Read a canonical claim contradiction",
+        description: "Read one tenant-scoped ClaimContradiction with both immutable claims, their evidence, provenance, current version and audited resolution. This never resolves the contradiction or changes commercial state.",
+        inputSchema: {
+            organization_id: id.describe("Organization explicitly selected through discover_leadify_context."),
+            contradiction_id: id.describe("ClaimContradiction ID obtained from a fresh Context Pack or prior read."),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ organization_id, contradiction_id }) => {
+        try {
+            return toolResult(await client.get(`/api/claim-contradictions/${encodeURIComponent(contradiction_id)}`, new URLSearchParams({ organizationId: organization_id })));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.registerTool("resolve_claim_contradiction", {
+        title: "Resolve a canonical claim contradiction",
+        description: "Persist one explicit, audited decision after reading the contradiction. SELECT_CLAIM must name one member claim; COEXIST keeps both. The server rejects stale versions, changed state, cross-tenant access and divergent idempotent replays. This never qualifies leads, creates messages, changes campaigns or sends outreach.",
+        inputSchema: {
+            organization_id: id.describe("Explicit organization; an admin write key is required."),
+            contradiction_id: id.describe("ClaimContradiction ID read immediately before this decision."),
+            ...resolutionFields,
+        },
+        annotations: { destructiveHint: false, idempotentHint: true },
+    }, async ({ organization_id, contradiction_id, ...input }) => {
+        try {
+            return toolResult(await client.post(`/api/claim-contradictions/${encodeURIComponent(contradiction_id)}/resolve`, { organizationId: organization_id, ...apiResolution(input) }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.registerTool("resolve_claim_contradictions_batch", {
+        title: "Resolve explicit claim contradictions in a batch",
+        description: "Submit up to 100 independent, explicit ClaimContradiction decisions. The API reports each item in order as resolved, replayed or error; there is no automatic choice, latest-wins rule or commercial side effect.",
+        inputSchema: {
+            organization_id: id.describe("Explicit organization shared by every decision; an admin write key is required."),
+            decisions: z.array(resolutionItem).min(1).max(100),
+        },
+        annotations: { destructiveHint: false, idempotentHint: true },
+    }, async ({ organization_id, decisions }) => {
+        try {
+            return toolResult(await client.post("/api/claim-contradictions/resolve-batch", {
+                organizationId: organization_id,
+                decisions: decisions.map(({ contradiction_id, ...input }) => ({
+                    contradictionId: contradiction_id,
+                    ...apiResolution(input),
+                })),
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+}

package/dist/tools/person_employment.js

@@ -1,7 +1,49 @@
 import { z } from "zod";
 import { getClient } from "../client.js";
 import { handleToolError, toolResult } from "../types.js";
+const evidenceDate = z.string().datetime();
+const evidenceId = z.string().trim().min(1);
 export function registerPersonEmploymentTools(server, client = getClient()) {
+    server.tool("create_person_employment_evidence", "Create one tenant-scoped, idempotent employment proof for an exact Person and Company Lead. Use the returned evidence.id unchanged in upsert_person_leads_with_employment; do not invent or reuse Company or event evidence IDs.", {
+        organization_id: z.string().trim().min(1),
+        company_lead_id: z.string().trim().min(1),
+        person: z.object({
+            full_name: z.string().trim().min(1).max(500),
+            email: z.string().trim().email().max(320).optional(),
+            linkedin_url: z.string().trim().url().max(2_000).optional(),
+        }).strict(),
+        provider: z.string().trim().min(1).max(120),
+        source_url: z.string().trim().url().max(2_000),
+        excerpt: z.string().trim().min(1).max(20_000),
+        observed_at: evidenceDate,
+        verified_at: evidenceDate,
+        idempotency_key: z.string().trim().min(1).max(220),
+    }, async ({ organization_id, company_lead_id, person, provider, source_url, excerpt, observed_at, verified_at, idempotency_key }) => {
+        try {
+            return toolResult(await client.post("/api/person-employment/evidence", {
+                organizationId: organization_id,
+                companyLeadId: company_lead_id,
+                person: { fullName: person.full_name, email: person.email, linkedinUrl: person.linkedin_url },
+                provider,
+                sourceUrl: source_url,
+                excerpt,
+                observedAt: observed_at,
+                verifiedAt: verified_at,
+                idempotencyKey: idempotency_key,
+            }));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
+    server.tool("get_person_employment_evidence", "Read back one employment proof only within the explicitly selected tenant. Use this to obtain or verify the evidence.id before the atomic Person employment upsert.", { organization_id: z.string().trim().min(1), evidence_id: evidenceId }, async ({ organization_id, evidence_id }) => {
+        try {
+            return toolResult(await client.get(`/api/person-employment/evidence/${encodeURIComponent(evidence_id)}`, new URLSearchParams({ organizationId: organization_id })));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
     server.tool("upsert_person_leads_with_employment", "Atomically create or reconcile Person Leads with their canonical PERSON identity, EMPLOYED_BY relationship, parent_lead/child_leads projections, evidence and append-only card_history. company_lead_id must be exact and already project an Account plus Legal Entity or compatible Establishment. Each batch entry is independently transactional and idempotent. This is the only supported Person write path for sourcing; never fall back to add_leads, canonical backfill, or separate relationship writes. It never qualifies, enriches contact details, sends outreach, creates campaigns, or activates anything.", {
         people: z.array(z.object({
             organization_id: z.string().trim().min(1),

package/package.json

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