@datasynx/agentic-crm 0.1.0

package/dist/server-Dyva03K8.js

@@ -0,0 +1,4287 @@
+import { a as writeMainFacts, i as readMainFacts, n as ensureCustomerDir, r as listCustomerSlugs, t as customerExists } from "./customer-dir-DIylZ8Q6.js";
+import { n as getSession } from "./session-store-CEa39Dxs.js";
+import { a as searchKbSimple, n as getKbArticle, o as writeKbArticle, r as getKbMetaForExport, s as CAPABILITIES_TEXT } from "./knowledge-base-D0Fh40kc.js";
+import { i as readBackupLog, n as listBackupsInDir, o as runBackup } from "./backup-CeMk9z86.js";
+import { r as updateSlugSyncState, t as getLastGmailSync } from "./sync-state-ChaLbamC.js";
+import { t as withFileQueue } from "./write-queue-IbsAjUnh.js";
+import { n as formatInteractionEntry, t as appendInteraction } from "./interactions-writer-SLHnoEeE.js";
+import { i as writeAuditEntry, n as getActor, r as readAuditLog, t as filterAuditLog } from "./audit-log-DNMY9mUZ.js";
+import { a as enforceRbac, n as canSeeCustomer } from "./rbac-CTIktZaC.js";
+import { f as getPipelineStages, i as buildSimulationInput, l as runSimulation, n as buildConfidenceMessage } from "./revenue-simulation-Bqf2DLVB.js";
+import { t as readPipeline } from "./pipeline-writer-BvVquKIe.js";
+import { a as updateGraphFromInteraction, c as readGraph, i as writeHealth, n as readHealth, o as findPath, r as updateHealthFromInteraction, s as getStakeholders, t as computeCustomerHealth } from "./relationship-health-odxEoQdJ.js";
+import { t as callLlm } from "./llm-DvzZqva0.js";
+import { d as pursueGoal, i as getActiveGoals, p as readGoals } from "./goal-engine-KpBftn4V.js";
+import { n as readSubscriptions, r as register, s as writeSubscriptions } from "./push-manager-CdqIIkuh.js";
+import { a as writeEnrollment, c as extractVariables, d as getTemplate, f as listTemplates, i as updateEnrollment, l as interpolate, n as listSequences, r as readEnrollments, s as buildVariablesFromCustomer, t as getSequence } from "./sequence-store-DaaWr0Os.js";
+import { n as listQuotes, r as readQuote, t as generateQuote } from "./quote-generator-BfwENXzg.js";
+import { i as upsertTicket, n as nextTicketId, r as readTickets, t as listAllTickets } from "./ticket-writer-j2oX_Wal.js";
+import { i as loadSlaRules, t as calcSlaDue } from "./sla-engine-BqX-7u-7.js";
+import { i as getSurvey, l as savePendingSurvey, n as calcNpsScore, o as loadSurveyResponses, r as generateSurveyToken, t as buildSurveyEmail } from "./survey-engine-DBjCYqCv.js";
+import { t as buildContext } from "./context-builder-BzWAp3Zs.js";
+import { a as loadCustomObjects, i as listRecords, n as defineCustomObject, t as createRecord } from "./custom-objects-BHgn1GEX.js";
+import { r as searchKnowledge } from "./lancedb-rlvWoPwl.js";
+import { t as buildDailyBriefing } from "./proactive-agent-BgQXw3ac.js";
+import { a as protectedResourceMetadata, o as verifyBearer, r as isAuthRequired, s as wwwAuthenticateHeader } from "./auth-DFWwWcYD.js";
+import { i as verifyGmailPubSubSignature, n as decodeGmailPubSubPayload, r as handleGmailPushEvent } from "./gmail-webhook-handler-e5Od25FX.js";
+import { n as registerUpdateDeal } from "./update-deal-DKC79skb.js";
+import path from "path";
+import fs from "fs";
+import matter from "gray-matter";
+import { z } from "zod";
+import crypto from "crypto";
+import yaml from "js-yaml";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+//#region src/core/oauth-store.ts
+let _auth = null;
+async function initOAuthFromDisk(dataDir) {
+	const credPath = path.join(dataDir, ".agentic", "gmail-credentials.json");
+	const tokenPath = path.join(dataDir, ".agentic", "gmail-token.json");
+	if (!fs.existsSync(credPath) || !fs.existsSync(tokenPath)) return false;
+	try {
+		const { getGmailAuth: loadAuth } = await import("./gmail-auth-OComS92L.js");
+		_auth = await loadAuth(credPath, tokenPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getGmailAuth() {
+	return _auth;
+}
+//#endregion
+//#region src/sync/microsoft-webhook-handler.ts
+function verifyMicrosoftGraphSignature(body, expectedClientState) {
+	const notifications = body.value ?? [];
+	if (notifications.length === 0) return expectedClientState === "";
+	return notifications.every((n) => n.clientState === expectedClientState);
+}
+function handleMicrosoftValidationRequest(queryParams) {
+	const token = queryParams["validationToken"];
+	if (token) return {
+		isValidation: true,
+		token
+	};
+	return { isValidation: false };
+}
+function findSubscriptionByMsId(subs, subscriptionId) {
+	return subs.find((s) => s.provider === "microsoft-graph" && s.status === "active" && s.providerData.microsoftSubscriptionId === subscriptionId) ?? null;
+}
+async function handleMicrosoftPushEvent(dataDir, notifications, accessToken, options = {}) {
+	const subs = await readSubscriptions(dataDir);
+	const { fetchMessageFn, appendInteractionFn = appendInteraction } = options;
+	let processed = 0;
+	let skipped = 0;
+	let anyProcessed = false;
+	for (const notification of notifications) {
+		const sub = findSubscriptionByMsId(subs, notification.subscriptionId);
+		if (!sub) {
+			skipped++;
+			continue;
+		}
+		const messageId = notification.resourceData?.id;
+		if (!messageId || !fetchMessageFn) {
+			skipped++;
+			continue;
+		}
+		try {
+			const message = await fetchMessageFn(accessToken, messageId);
+			if (!message) {
+				skipped++;
+				continue;
+			}
+			const from = message.from?.emailAddress?.address ?? "unknown";
+			const sourceRef = `msgraph://message/${message.id}`;
+			await appendInteractionFn(dataDir, sub.slug, {
+				date: message.receivedDateTime ? new Date(message.receivedDateTime).toISOString().slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+				type: "Email",
+				direction: "inbound",
+				with: from,
+				subject: message.subject ?? "(no subject)",
+				summary: message.bodyPreview ?? "(no preview)",
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			processed++;
+			anyProcessed = true;
+			const idx = subs.findIndex((s) => s.id === sub.id);
+			if (idx !== -1) subs[idx] = {
+				...subs[idx],
+				eventsProcessed: subs[idx].eventsProcessed + 1,
+				lastEventAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+		} catch {
+			skipped++;
+		}
+	}
+	if (anyProcessed) await writeSubscriptions(dataDir, subs);
+	return {
+		processed,
+		skipped
+	};
+}
+//#endregion
+//#region src/sync/slack-webhook-handler.ts
+function verifySlackSignature(body, headers, signingSecret) {
+	const sig = headers["x-slack-signature"];
+	const ts = headers["x-slack-request-timestamp"];
+	if (!sig || !ts) return false;
+	const tsNum = Number(ts);
+	if (Math.abs(Date.now() / 1e3 - tsNum) > 300) return false;
+	const sigBase = `v0:${ts}:${body}`;
+	const expected = "v0=" + crypto.createHmac("sha256", signingSecret).update(sigBase).digest("hex");
+	try {
+		const sigBuf = Buffer.from(sig);
+		const expBuf = Buffer.from(expected);
+		if (sigBuf.length !== expBuf.length) return false;
+		return crypto.timingSafeEqual(sigBuf, expBuf);
+	} catch {
+		return false;
+	}
+}
+function handleSlackUrlVerification(body) {
+	if (body.type === "url_verification") return {
+		isVerification: true,
+		challenge: body.challenge ?? ""
+	};
+	return { isVerification: false };
+}
+function findSubscriptionByTeam(subs, teamId) {
+	return subs.find((s) => s.provider === "slack" && s.status === "active" && (!teamId || s.providerData.slackTeamId === teamId)) ?? null;
+}
+async function handleSlackPushEvent(dataDir, event, botToken, options = {}) {
+	if (event.type !== "message") return {
+		processed: 0,
+		skipped: 1
+	};
+	if (event.bot_id) return {
+		processed: 0,
+		skipped: 1
+	};
+	if (!event.text?.trim()) return {
+		processed: 0,
+		skipped: 1
+	};
+	const subs = await readSubscriptions(dataDir);
+	const sub = findSubscriptionByTeam(subs, options.teamId);
+	if (!sub) return {
+		processed: 0,
+		skipped: 1
+	};
+	const { appendInteractionFn = appendInteraction, fetchUserInfoFn } = options;
+	let senderName = event.user ?? "unknown";
+	if (fetchUserInfoFn && event.user) try {
+		const info = await fetchUserInfoFn(botToken, event.user);
+		senderName = info.name ?? info.email ?? event.user;
+	} catch {}
+	const ts = event.ts ? (/* @__PURE__ */ new Date(Number(event.ts) * 1e3)).toISOString().slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const sourceRef = `slack://channel/${event.channel ?? "dm"}/ts/${event.ts ?? Date.now()}`;
+	try {
+		await appendInteractionFn(dataDir, sub.slug, {
+			date: ts,
+			type: "Meeting",
+			direction: "inbound",
+			with: senderName,
+			subject: `Slack message in ${event.channel ?? "DM"}`,
+			summary: event.text.slice(0, 300),
+			nextSteps: [],
+			sourceRef,
+			synced: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const idx = subs.findIndex((s) => s.id === sub.id);
+		if (idx !== -1) {
+			subs[idx] = {
+				...subs[idx],
+				eventsProcessed: subs[idx].eventsProcessed + 1,
+				lastEventAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await writeSubscriptions(dataDir, subs);
+		}
+		return {
+			processed: 1,
+			skipped: 0
+		};
+	} catch {
+		return {
+			processed: 0,
+			skipped: 1
+		};
+	}
+}
+//#endregion
+//#region src/mcp/tools/get-capabilities.ts
+async function handleGetCapabilities() {
+	return { content: [{
+		type: "text",
+		text: CAPABILITIES_TEXT
+	}] };
+}
+function registerGetCapabilities(server) {
+	server.registerTool("get_capabilities", {
+		title: "Get Capabilities",
+		description: "Returns all available MCP tools, their inputs, and the CRM workflow guide. Call this first to understand what DatasynxOpenCRM can do.",
+		inputSchema: z.object({})
+	}, async () => handleGetCapabilities());
+}
+//#endregion
+//#region src/mcp/tools/get-active-session.ts
+async function handleGetActiveSession() {
+	const session = getSession();
+	const result = session ? {
+		hasSession: true,
+		customerSlug: session.customerSlug,
+		customerName: session.customerName,
+		startedAt: session.startedAt,
+		...session.owner !== void 0 ? { owner: session.owner } : {}
+	} : { hasSession: false };
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result, null, 2)
+	}] };
+}
+function registerGetActiveSession(server) {
+	server.registerTool("get_active_session", {
+		title: "Get Active Session",
+		description: "Check which customer is currently active in the session store. Returns session info if a customer session is open, otherwise returns hasSession: false.",
+		inputSchema: z.object({})
+	}, async () => handleGetActiveSession());
+}
+//#endregion
+//#region src/mcp/tools/get-customer-context.ts
+const DATA_DIR$50 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+function triggerOnQuerySync(dataDir, slug) {
+	const auth = getGmailAuth();
+	if (!auth) return;
+	const lastSync = getLastGmailSync(dataDir, slug);
+	const thirtyMinAgo = /* @__PURE__ */ new Date(Date.now() - 1800 * 1e3);
+	if (lastSync && lastSync >= thirtyMinAgo) return;
+	const sourcesPath = path.join(dataDir, "customers", slug, "sources.json");
+	if (!fs.existsSync(sourcesPath)) return;
+	try {
+		const sources = JSON.parse(fs.readFileSync(sourcesPath, "utf-8"));
+		if (!sources.gmail?.enabled || !sources.gmail.query) return;
+		const query = sources.gmail.query;
+		import("./gmail-sync-DIaxInDT.js").then(({ syncGmail }) => syncGmail({
+			slug,
+			dataDir,
+			auth,
+			query
+		}).then(() => updateSlugSyncState(dataDir, slug, { lastGmailSync: (/* @__PURE__ */ new Date()).toISOString() })).catch(() => {})).catch(() => {});
+	} catch {}
+}
+async function handleGetCustomerContext(input, dataDir = DATA_DIR$50) {
+	const targetSlug = input.slug ?? getSession()?.customerSlug;
+	if (!targetSlug) return {
+		content: [{
+			type: "text",
+			text: "No customer specified and no active session. Use: get_customer_context({ slug: 'acme-corp' })"
+		}],
+		isError: true
+	};
+	const actor = process.env["DXCRM_ACTOR"] ?? "system";
+	if (!canSeeCustomer(dataDir, actor, targetSlug)) return {
+		content: [{
+			type: "text",
+			text: `Access denied: '${actor}' cannot view customer '${targetSlug}'.`
+		}],
+		isError: true
+	};
+	triggerOnQuerySync(dataDir, targetSlug);
+	try {
+		return { content: [{
+			type: "text",
+			text: await buildContext(dataDir, targetSlug)
+		}] };
+	} catch (err) {
+		return {
+			content: [{
+				type: "text",
+				text: `Error: ${err.message}`
+			}],
+			isError: true
+		};
+	}
+}
+function registerGetCustomerContext(server) {
+	server.registerTool("get_customer_context", {
+		title: "Get Customer Context",
+		description: `Returns a complete, LLM-ready context block for a customer.
+Use this before any customer-related conversation or action.
+Automatically triggers a background Gmail sync if last sync was >30 minutes ago.
+
+Args:
+  slug: Customer ID (e.g. "acme-corp"). Leave empty to use active session customer.
+
+Returns: Structured markdown with Quick Reference, Contacts, Critical Context,
+Recent Activity (last 10 interactions), Pipeline, and Open Questions.
+
+Performance: <3 seconds. Token budget: <3000.`,
+		inputSchema: z.object({ slug: z.string().optional().describe("Customer slug (e.g. 'acme-corp'). Leave empty for active session customer.") })
+	}, async ({ slug }) => handleGetCustomerContext({ ...slug !== void 0 ? { slug } : {} }));
+}
+//#endregion
+//#region src/mcp/tools/search-customer-knowledge.ts
+const DATA_DIR$49 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleSearchCustomerKnowledge(input, dataDir = DATA_DIR$49) {
+	const limit = input.limit ?? 5;
+	try {
+		const results = await searchKnowledge(dataDir, input.slug, input.query, limit);
+		const response = results.length === 0 ? {
+			results: [],
+			message: `No results found for "${input.query}" in customer "${input.slug}". The customer may not have been synced yet. Run dxcrm sync to index emails and transcripts.`
+		} : { results };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(response, null, 2)
+		}] };
+	} catch {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				results: [],
+				message: `Search unavailable for customer "${input.slug}". LanceDB may not be initialized.`
+			})
+		}] };
+	}
+}
+function registerSearchCustomerKnowledge(server) {
+	server.registerTool("search_customer_knowledge", {
+		title: "Search Customer Knowledge",
+		description: `Hybrid vector + full-text search across all emails and transcripts for a customer.
+Use when you need to find specific information from past communications.
+
+Args:
+  slug: Customer ID (e.g. "acme-corp")
+  query: Natural language search query (e.g. "pricing discussion", "GDPR concerns")
+  limit: Max results to return (default 5)
+
+Returns: { results: Array<{ content, score, source }> }
+If no results: returns empty array with a helpful sync suggestion.`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug (e.g. 'acme-corp')"),
+			query: z.string().describe("Search query (natural language or keywords)"),
+			limit: z.number().int().min(1).max(50).optional().describe("Max results to return (default 5)")
+		})
+	}, async ({ slug, query, limit }) => handleSearchCustomerKnowledge({
+		slug,
+		query,
+		...limit !== void 0 ? { limit } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/list-customers.ts
+const DATA_DIR$48 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+function extractLastInteractionDate(interactionsPath) {
+	if (!fs.existsSync(interactionsPath)) return void 0;
+	const content = fs.readFileSync(interactionsPath, "utf-8");
+	const match = /^## (\d{4}-\d{2}-\d{2})/m.exec(content);
+	return match ? match[1] : void 0;
+}
+async function handleListCustomers(input, dataDir = DATA_DIR$48) {
+	const customersDir = path.join(dataDir, "customers");
+	const customers = [];
+	if (!fs.existsSync(customersDir)) return { content: [{
+		type: "text",
+		text: JSON.stringify([], null, 2)
+	}] };
+	const entries = fs.readdirSync(customersDir);
+	for (const entry of entries) {
+		const customerDir = path.join(customersDir, entry);
+		try {
+			if (!fs.statSync(customerDir).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const mainFactsPath = path.join(customerDir, "main_facts.md");
+		if (!fs.existsSync(mainFactsPath)) continue;
+		try {
+			const data = matter(fs.readFileSync(mainFactsPath, "utf-8")).data;
+			const name = typeof data["name"] === "string" ? data["name"] : entry;
+			const stage = typeof data["relationship_stage"] === "string" ? data["relationship_stage"] : "unknown";
+			const dealValue = typeof data["deal_value"] === "number" ? data["deal_value"] : void 0;
+			const lastInteraction = extractLastInteractionDate(path.join(customerDir, "interactions.md"));
+			const summary = {
+				slug: entry,
+				name,
+				stage,
+				...lastInteraction !== void 0 ? { lastInteraction } : {},
+				...dealValue !== void 0 ? { dealValue } : {}
+			};
+			if (input.filter) {
+				const filterLower = input.filter.toLowerCase();
+				if (!(name.toLowerCase().includes(filterLower) || entry.toLowerCase().includes(filterLower) || stage.toLowerCase().includes(filterLower))) continue;
+			}
+			if (!canSeeCustomer(dataDir, process.env["DXCRM_ACTOR"] ?? "system", entry)) continue;
+			customers.push(summary);
+		} catch {
+			continue;
+		}
+	}
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(customers, null, 2)
+	}] };
+}
+function registerListCustomers(server) {
+	server.registerTool("list_customers", {
+		title: "List Customers",
+		description: `List all customers with their pipeline stage, last interaction date, and deal value.
+Useful for morning briefings and pipeline overviews.
+
+Args:
+  filter: Optional substring to filter by name or slug (case-insensitive)
+
+Returns: Array of { slug, name, stage, lastInteraction?, dealValue? }`,
+		inputSchema: z.object({ filter: z.string().optional().describe("Substring filter on customer name or slug (case-insensitive)") })
+	}, async ({ filter }) => handleListCustomers({ ...filter !== void 0 ? { filter } : {} }));
+}
+//#endregion
+//#region src/mcp/tools/log-interaction.ts
+const DATA_DIR$47 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleLogInteraction(input, dataDir = DATA_DIR$47) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+	const interactionDate = input.date ?? today;
+	const sourceRef = input.source ?? `agent://log/${Date.now()}`;
+	const entry = {
+		date: interactionDate,
+		type: input.type,
+		with: input.with,
+		summary: input.summary,
+		nextSteps: input.nextSteps ?? [],
+		sourceRef,
+		synced: (/* @__PURE__ */ new Date()).toISOString(),
+		...input.direction !== void 0 ? { direction: input.direction } : {}
+	};
+	const interactionsPath = path.join(dataDir, "customers", input.slug, "interactions.md");
+	const entryText = formatInteractionEntry(entry);
+	try {
+		enforceRbac(dataDir, "log_interaction");
+		await appendInteraction(dataDir, input.slug, entry);
+		updateGraphFromInteraction(dataDir, input.slug, {
+			withStr: input.with,
+			interactionDate
+		}).catch(() => {});
+		updateHealthFromInteraction(dataDir, input.slug).catch(() => {});
+		const mainFactsPath = path.join(dataDir, "customers", input.slug, "main_facts.md");
+		if (fs.existsSync(mainFactsPath)) try {
+			const raw = matter(fs.readFileSync(mainFactsPath, "utf-8"));
+			raw.data.last_touchpoint = interactionDate;
+			let serialized = matter.stringify(raw.content, raw.data);
+			serialized = serialized.replace(/^(last_touchpoint:\s*)['"](\d{4}-\d{2}-\d{2})['"]/m, "$1$2");
+			fs.writeFileSync(mainFactsPath, serialized, "utf-8");
+		} catch {}
+		writeAuditEntry(dataDir, {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			actor: getActor(),
+			tool: "log_interaction",
+			slug: input.slug,
+			summary: input.summary
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				path: interactionsPath,
+				entry: entryText
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerLogInteraction(server) {
+	server.registerTool("log_interaction", {
+		title: "Log Interaction",
+		description: `Write a new interaction entry to the CRM. Use after every call, meeting, or email.
+Format matches auto-synced entries exactly — immediately searchable.
+
+Args:
+  slug: Customer ID
+  type: Interaction type ("Email" | "Call" | "Meeting" | "Note" | "Demo" | "Proposal" | "Contract" | "Other")
+  summary: 2-5 sentences describing what happened (min 1 char)
+  with: Who was involved (name or email address)
+  nextSteps: Array of action items (optional)
+  direction: "inbound" or "outbound" (optional)
+  source: Source reference string (optional, auto-generated if omitted)
+
+Returns: { success: boolean, path: string, entry: string }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug (e.g. 'acme-corp')"),
+			type: z.enum([
+				"Email",
+				"Call",
+				"Meeting",
+				"Note",
+				"Demo",
+				"Proposal",
+				"Contract",
+				"Other"
+			]).describe("Type of interaction"),
+			summary: z.string().min(1).describe("2-5 sentence summary of what happened"),
+			with: z.string().describe("Who was involved (name or email)"),
+			nextSteps: z.array(z.string()).optional().describe("Action items for follow-up"),
+			direction: z.enum(["inbound", "outbound"]).optional().describe("Direction of communication"),
+			source: z.string().optional().describe("Source reference (e.g. gmail://thread/123). Auto-generated if omitted."),
+			date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Date of interaction (YYYY-MM-DD). Defaults to today.")
+		})
+	}, async ({ slug, type, summary, with: withStr, nextSteps, direction, source, date }) => handleLogInteraction({
+		slug,
+		type,
+		summary,
+		with: withStr,
+		...nextSteps !== void 0 ? { nextSteps } : {},
+		...direction !== void 0 ? { direction } : {},
+		...source !== void 0 ? { source } : {},
+		...date !== void 0 ? { date } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/export-customer.ts
+const DATA_DIR$46 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+function countInteractions(content) {
+	const matches = content.match(/^## \d{4}-\d{2}-\d{2}/gm);
+	return matches ? matches.length : 0;
+}
+async function handleExportCustomer(input, dataDir = DATA_DIR$46) {
+	enforceRbac(dataDir, "export_customer");
+	const customerDir = path.join(dataDir, "customers", input.slug);
+	if (!fs.existsSync(customerDir)) return {
+		content: [{
+			type: "text",
+			text: `Error: Customer '${input.slug}' not found. Check 'list_customers()' for available customers.`
+		}],
+		isError: true
+	};
+	const format = input.format ?? "json";
+	const mainFactsPath = path.join(customerDir, "main_facts.md");
+	let mainFacts = {};
+	let mainFactsContent = "";
+	if (fs.existsSync(mainFactsPath)) {
+		const raw = matter(fs.readFileSync(mainFactsPath, "utf-8"));
+		mainFacts = raw.data;
+		mainFactsContent = raw.content ?? "";
+	}
+	const interactionsPath = path.join(customerDir, "interactions.md");
+	let interactionsContent = "";
+	let interactionsCount = 0;
+	if (fs.existsSync(interactionsPath)) {
+		interactionsContent = fs.readFileSync(interactionsPath, "utf-8");
+		interactionsCount = countInteractions(interactionsContent);
+	}
+	const pipeline = await readPipeline(dataDir, input.slug);
+	const attachmentsDir = path.join(customerDir, "attachments");
+	const attachments = [];
+	if (fs.existsSync(attachmentsDir)) try {
+		const files = fs.readdirSync(attachmentsDir);
+		for (const f of files) try {
+			if (fs.statSync(path.join(attachmentsDir, f)).isFile()) attachments.push(f);
+		} catch {}
+	} catch {}
+	if (format === "markdown") return { content: [{
+		type: "text",
+		text: [
+			`# Export: ${input.slug}`,
+			"",
+			"## Main Facts",
+			mainFactsContent.trim() || "(no content)",
+			"",
+			"## Metadata",
+			Object.entries(mainFacts).map(([k, v]) => `- **${k}**: ${JSON.stringify(v)}`).join("\n") || "(no metadata)",
+			"",
+			`## Interactions (${interactionsCount} total)`,
+			interactionsContent.trim() || "(no interactions)",
+			"",
+			"## Pipeline",
+			pipeline.length > 0 ? pipeline.map((d) => `- **${d.name}** · ${d.stage}${d.value !== void 0 ? ` · €${d.value}` : ""}${d.close_date ? ` · close: ${d.close_date}` : ""}`).join("\n") : "(no deals)",
+			"",
+			`## Attachments (${attachments.length})`,
+			attachments.length > 0 ? attachments.map((f) => `- ${f}`).join("\n") : "(none)"
+		].join("\n")
+	}] };
+	const exported = {
+		slug: input.slug,
+		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		mainFacts,
+		interactionsCount,
+		pipeline,
+		attachments
+	};
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(exported, null, 2)
+	}] };
+}
+function registerExportCustomer(server) {
+	server.registerTool("export_customer", {
+		title: "Export Customer",
+		description: `Export all customer data (main_facts + interactions count + pipeline deals).
+Useful for reporting, audits, or creating backups.
+
+Args:
+  slug: Customer ID (e.g. "acme-corp")
+  format: Output format — "json" (default) or "markdown"
+
+Returns:
+  JSON: { slug, exportedAt, mainFacts, interactionsCount, pipeline }
+  Markdown: Formatted document with all sections`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug (e.g. 'acme-corp')"),
+			format: z.enum(["json", "markdown"]).optional().describe("Output format: 'json' (default) or 'markdown'")
+		})
+	}, async ({ slug, format }) => handleExportCustomer({
+		slug,
+		...format !== void 0 ? { format } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/update-customer-facts.ts
+const DATA_DIR$45 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleUpdateCustomerFacts(input, dataDir = DATA_DIR$45) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	try {
+		enforceRbac(dataDir, "update_customer_facts");
+		let existing;
+		let created = false;
+		if (!customerExists(dataDir, input.slug)) {
+			await ensureCustomerDir(dataDir, input.slug);
+			existing = {
+				name: input.name ?? input.slug,
+				relationship_stage: "prospect",
+				currency: "EUR",
+				tags: [],
+				created: today,
+				updated: today
+			};
+			created = true;
+		} else existing = await readMainFacts(dataDir, input.slug);
+		const updated = {
+			...existing,
+			...input.name !== void 0 ? { name: input.name } : {},
+			...input.domain !== void 0 ? { domain: input.domain } : {},
+			...input.email !== void 0 ? { email: input.email } : {},
+			...input.phone !== void 0 ? { phone: input.phone } : {},
+			...input.industry !== void 0 ? { industry: input.industry } : {},
+			...input.relationshipStage !== void 0 ? { relationship_stage: input.relationshipStage } : {},
+			...input.dealValue !== void 0 ? { deal_value: input.dealValue } : {},
+			...input.primaryContact !== void 0 ? { primary_contact: input.primaryContact } : {},
+			...input.timezone !== void 0 ? { timezone: input.timezone } : {},
+			...input.tags !== void 0 ? { tags: input.tags } : {},
+			updated: today
+		};
+		await writeMainFacts(dataDir, input.slug, updated);
+		writeAuditEntry(dataDir, {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			actor: getActor(),
+			tool: "update_customer_facts",
+			slug: input.slug,
+			summary: Object.keys(input).filter((k) => k !== "slug").join(", ")
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				created,
+				facts: updated
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerUpdateCustomerFacts(server) {
+	server.registerTool("update_customer_facts", {
+		title: "Update Customer Facts",
+		description: `Create or update a customer's main_facts.md profile.
+If the customer slug does not exist yet, creates the customer directory and initial profile.
+If it exists, merges the provided fields into existing data.
+
+Use to add a new customer ("create acme-corp") or update existing info.
+
+Args:
+  slug: Customer ID / slug — e.g. "acme-corp" (kebab-case, no spaces)
+  name: Company name (used as display name)
+  domain: Primary domain (e.g. "acme.com")
+  email: Primary contact email
+  phone: Phone number
+  industry: Industry vertical
+  relationshipStage: "prospect" | "active" | "churned" | "paused"
+  dealValue: Expected deal value in EUR
+  primaryContact: Primary contact person name
+  timezone: Timezone (e.g. "Europe/Berlin")
+  tags: Array of tags (replaces existing tags)
+
+Returns: { success: boolean, created: boolean, facts: object }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug (e.g. 'acme-corp')"),
+			name: z.string().optional().describe("Company name"),
+			domain: z.string().optional().describe("Primary domain"),
+			email: z.string().optional().describe("Primary contact email"),
+			phone: z.string().optional().describe("Phone number"),
+			industry: z.string().optional().describe("Industry vertical"),
+			relationshipStage: z.enum([
+				"prospect",
+				"active",
+				"churned",
+				"paused"
+			]).optional().describe("Relationship stage"),
+			dealValue: z.number().optional().describe("Expected deal value in EUR"),
+			primaryContact: z.string().optional().describe("Primary contact person name"),
+			timezone: z.string().optional().describe("Timezone (e.g. Europe/Berlin)"),
+			tags: z.array(z.string()).optional().describe("Tags (replaces existing)")
+		})
+	}, async (input) => handleUpdateCustomerFacts(input));
+}
+//#endregion
+//#region src/core/deal-health.ts
+function grade(score) {
+	if (score >= 80) return "A";
+	if (score >= 65) return "B";
+	if (score >= 50) return "C";
+	if (score >= 35) return "D";
+	return "F";
+}
+function scoreDeal(deal, signals) {
+	let score = 100;
+	const warnings = [];
+	if (signals.daysSinceLastActivity > 60) {
+		score -= 40;
+		warnings.push(`No activity in ${signals.daysSinceLastActivity} days`);
+	} else if (signals.daysSinceLastActivity > 30) {
+		score -= 25;
+		warnings.push(`Low activity — last touch ${signals.daysSinceLastActivity} days ago`);
+	} else if (signals.daysSinceLastActivity > 14) score -= 10;
+	if (signals.daysInCurrentStage > 90) {
+		score -= 25;
+		warnings.push(`Stuck in "${deal.stage}" for ${signals.daysInCurrentStage} days`);
+	} else if (signals.daysInCurrentStage > 45) {
+		score -= 12;
+		warnings.push(`Slow progress in "${deal.stage}"`);
+	}
+	if (signals.daysToClose !== void 0) {
+		if (signals.daysToClose < 0) {
+			score -= 20;
+			warnings.push("Close date passed");
+		} else if (signals.daysToClose < 7) {
+			score -= 10;
+			warnings.push("Close date in less than 7 days");
+		}
+	}
+	if (signals.probability !== void 0) {
+		if (signals.probability < 20 && deal.stage !== "lead") {
+			score -= 15;
+			warnings.push(`Low probability (${signals.probability}%) for stage "${deal.stage}"`);
+		}
+	}
+	score = Math.max(0, score);
+	return {
+		score,
+		grade: grade(score),
+		signals,
+		warnings
+	};
+}
+//#endregion
+//#region src/mcp/tools/get-deal-health.ts
+const DATA_DIR$44 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetDealHealth(input, dataDir = DATA_DIR$44) {
+	try {
+		const deals = await readPipeline(dataDir, input.slug);
+		const today = /* @__PURE__ */ new Date();
+		const results = [];
+		for (const deal of deals) {
+			const updatedDate = deal.updated ? new Date(deal.updated) : today;
+			const daysSinceLastActivity = Math.floor((today.getTime() - updatedDate.getTime()) / (1e3 * 60 * 60 * 24));
+			const daysToClose = deal.close_date ? Math.floor((new Date(deal.close_date).getTime() - today.getTime()) / (1e3 * 60 * 60 * 24)) : void 0;
+			const health = scoreDeal(deal, {
+				daysSinceLastActivity,
+				daysInCurrentStage: daysSinceLastActivity,
+				...daysToClose !== void 0 ? { daysToClose } : {},
+				...deal.probability !== void 0 ? { probability: deal.probability } : {}
+			});
+			results.push({
+				deal: deal.name,
+				stage: deal.stage,
+				...health
+			});
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				slug: input.slug,
+				deals: results
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetDealHealth(server) {
+	server.registerTool("get_deal_health", {
+		title: "Get Deal Health",
+		description: `Score the health of all deals for a customer (0–100). Grade A–F based on activity recency, stage velocity, close date proximity, and probability.
+
+Returns: { slug, deals: [{ deal, stage, score, grade, signals, warnings }] }`,
+		inputSchema: z.object({ slug: z.string().describe("Customer slug") })
+	}, async ({ slug }) => handleGetDealHealth({ slug }));
+}
+//#endregion
+//#region src/mcp/tools/get-pipeline-forecast.ts
+const DATA_DIR$43 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetPipelineForecast(input, dataDir = DATA_DIR$43) {
+	try {
+		const customersDir = path.join(dataDir, "customers");
+		if (!fs.existsSync(customersDir)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				deals: [],
+				totalWeightedValue: 0,
+				byStage: {}
+			}, null, 2)
+		}] };
+		const slugs = fs.readdirSync(customersDir).filter((d) => {
+			if (input.filter && !d.includes(input.filter)) return false;
+			return fs.statSync(path.join(customersDir, d)).isDirectory();
+		});
+		const allDeals = [];
+		for (const slug of slugs) {
+			const pipelinePath = path.join(customersDir, slug, "pipeline.md");
+			if (!fs.existsSync(pipelinePath)) continue;
+			const { readPipeline } = await import("./pipeline-writer-BqBrYrQc.js");
+			const deals = await readPipeline(dataDir, slug).catch(() => []);
+			for (const deal of deals) {
+				if (deal.stage === "won" || deal.stage === "lost") continue;
+				const prob = deal.probability ?? 50;
+				const value = deal.value ?? 0;
+				const forecastDeal = {
+					slug,
+					dealName: deal.name,
+					stage: deal.stage,
+					value,
+					probability: prob,
+					weightedValue: Math.round(value * prob / 100)
+				};
+				if (deal.close_date !== void 0) forecastDeal.closeDate = deal.close_date;
+				allDeals.push(forecastDeal);
+			}
+		}
+		const totalWeightedValue = allDeals.reduce((sum, d) => sum + d.weightedValue, 0);
+		const byStage = allDeals.reduce((acc, d) => {
+			if (!acc[d.stage]) acc[d.stage] = {
+				count: 0,
+				weightedValue: 0
+			};
+			acc[d.stage].count++;
+			acc[d.stage].weightedValue += d.weightedValue;
+			return acc;
+		}, {});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				deals: allDeals,
+				totalWeightedValue,
+				byStage
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetPipelineForecast(server) {
+	server.registerTool("get_pipeline_forecast", {
+		title: "Get Pipeline Forecast",
+		description: `Aggregate weighted pipeline revenue across all customers. Groups open deals by stage, computes probability-weighted expected revenue.
+
+Returns: { deals: [...], totalWeightedValue: number, byStage: { stage: { count, weightedValue } } }`,
+		inputSchema: z.object({ filter: z.string().optional().describe("Filter by customer slug substring") })
+	}, async ({ filter }) => handleGetPipelineForecast({ ...filter !== void 0 ? { filter } : {} }));
+}
+//#endregion
+//#region src/mcp/tools/summarize-meeting.ts
+const DATA_DIR$42 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleSummarizeMeeting(input, dataDir = DATA_DIR$42) {
+	try {
+		let summary = input.transcript.slice(0, 400);
+		let nextSteps = [];
+		try {
+			const { callLlm } = await import("./llm-DEjWcqmW.js");
+			const response = await callLlm(`Summarize this meeting transcript in 3-5 sentences and extract action items.\n\nTranscript:\n${input.transcript.slice(0, 3e3)}\n\nRespond as JSON: { "summary": "...", "nextSteps": ["..."] }`);
+			const parsed = JSON.parse(response);
+			summary = parsed.summary ?? summary;
+			nextSteps = parsed.nextSteps ?? [];
+		} catch {}
+		const date = input.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const sourceRef = `agent://meeting/${Date.now()}`;
+		await appendInteraction(dataDir, input.slug, {
+			date,
+			type: "Meeting",
+			with: input.with ?? "Meeting Participant",
+			summary,
+			nextSteps,
+			sourceRef,
+			synced: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		writeAuditEntry(dataDir, {
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			actor: getActor(),
+			tool: "summarize_meeting",
+			slug: input.slug,
+			summary: summary.slice(0, 100)
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				summary,
+				nextSteps,
+				sourceRef
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerSummarizeMeeting(server) {
+	server.registerTool("summarize_meeting", {
+		title: "Summarize Meeting",
+		description: `Summarize a meeting transcript and log it as an interaction. Uses LLM to extract key points and action items (falls back to raw text slice if LLM unavailable).
+
+Args:
+  slug: Customer ID
+  transcript: Full meeting transcript text
+  with: Participant name(s) (optional)
+  date: Meeting date YYYY-MM-DD (optional, defaults to today)
+
+Returns: { success, summary, nextSteps, sourceRef }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			transcript: z.string().min(1).describe("Full meeting transcript"),
+			with: z.string().optional().describe("Participant names"),
+			date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("Meeting date")
+		})
+	}, async ({ slug, transcript, with: withStr, date }) => handleSummarizeMeeting({
+		slug,
+		transcript,
+		...withStr !== void 0 ? { with: withStr } : {},
+		...date !== void 0 ? { date } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/get-pipeline-stages.ts
+const DATA_DIR$41 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetPipelineStages(_input, dataDir = DATA_DIR$41) {
+	const stages = getPipelineStages(dataDir);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ stages }, null, 2)
+	}] };
+}
+function registerGetPipelineStages(server) {
+	server.registerTool("get_pipeline_stages", {
+		title: "Get Pipeline Stages",
+		description: "Returns all configured pipeline stages. Falls back to default stages (lead, qualified, proposal, negotiation, won, lost) if no custom stages are configured.",
+		inputSchema: z.object({})
+	}, async () => handleGetPipelineStages({}));
+}
+//#endregion
+//#region src/core/cross-customer.ts
+async function searchAcrossCustomers(dataDir, query, limit = 5, excludeSlug) {
+	const slugs = listCustomerSlugs(dataDir).filter((d) => d !== excludeSlug);
+	const allResults = [];
+	for (const slug of slugs) {
+		const results = await searchKnowledge(dataDir, slug, query, 2);
+		for (const r of results) allResults.push({
+			slug,
+			relevantContent: r.content.slice(0, 200),
+			score: r.score
+		});
+	}
+	return allResults.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+//#endregion
+//#region src/mcp/tools/get-market-intelligence.ts
+const DATA_DIR$40 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetMarketIntelligence(input, dataDir = DATA_DIR$40) {
+	const excludeSlug = input.excludeCurrentCustomer ? input.slug : void 0;
+	const all = listCustomerSlugs(dataDir);
+	const totalCustomersSearched = excludeSlug ? all.filter((s) => s !== excludeSlug).length : all.length;
+	const results = await searchAcrossCustomers(dataDir, input.query, 10, excludeSlug);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			query: input.query,
+			results,
+			totalCustomersSearched
+		}, null, 2)
+	}] };
+}
+function registerGetMarketIntelligence(server) {
+	server.registerTool("get_market_intelligence", {
+		title: "Get Market Intelligence",
+		description: "Search across all customers to find patterns, common topics, or similar issues. Uses semantic search (LanceDB) across all customer knowledge bases. Results use slug (not real names) for privacy.",
+		inputSchema: z.object({
+			query: z.string().describe("What to search for across all customers"),
+			excludeCurrentCustomer: z.boolean().optional().describe("Exclude the current customer from results"),
+			slug: z.string().optional().describe("Current customer slug (used with excludeCurrentCustomer)")
+		})
+	}, async ({ query, excludeCurrentCustomer, slug }) => handleGetMarketIntelligence({
+		query,
+		...excludeCurrentCustomer !== void 0 ? { excludeCurrentCustomer } : {},
+		...slug !== void 0 ? { slug } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/get-relationship-graph.ts
+const DATA_DIR$39 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+function summarizeNode(n) {
+	return {
+		id: n.id,
+		name: n.label,
+		email: n.properties["email"]
+	};
+}
+async function handleGetRelationshipGraph(input, dataDir = DATA_DIR$39) {
+	try {
+		const graph = readGraph(dataDir, input.slug);
+		const stakeholders = getStakeholders(graph);
+		const ownerContactIds = graph.nodes.filter((n) => n.type === "person" && n.properties["isOwnerContact"] === true).map((n) => n.id);
+		const economicBuyerIds = stakeholders.economicBuyers.map((n) => n.id);
+		const warmIntroPaths = [];
+		for (const ebId of economicBuyerIds) for (const ownerId of ownerContactIds) {
+			const p = findPath(graph, ownerId, ebId);
+			if (p.length > 1) {
+				warmIntroPaths.push({
+					target: ebId,
+					path: p
+				});
+				break;
+			}
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				slug: input.slug,
+				nodeCount: graph.nodes.length,
+				edgeCount: graph.edges.length,
+				updatedAt: graph.updatedAt,
+				stakeholders: {
+					champions: stakeholders.champions.map(summarizeNode),
+					blockers: stakeholders.blockers.map(summarizeNode),
+					economicBuyers: stakeholders.economicBuyers.map(summarizeNode),
+					allContacts: stakeholders.allContacts.map(summarizeNode),
+					missingRoles: stakeholders.missingRoles
+				},
+				warmIntroPaths,
+				nodes: graph.nodes,
+				edges: graph.edges
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetRelationshipGraph(server) {
+	server.registerTool("get_relationship_graph", {
+		title: "Get Relationship Graph",
+		description: `Returns the knowledge graph for a customer: all known contacts, companies,
+and the relationships between them (KNOWS, WORKS_AT, IS_CHAMPION, IS_BLOCKER, IS_ECONOMIC_BUYER).
+
+The graph auto-populates from every log_interaction call.
+Use this before a complex deal conversation to understand the stakeholder map.
+
+Args:
+  slug: Customer slug
+
+Returns: {
+  stakeholders: { champions[], blockers[], economicBuyers[], allContacts[], missingRoles[] },
+  nodes: GraphNode[],
+  edges: GraphEdge[]
+}`,
+		inputSchema: z.object({ slug: z.string().describe("Customer slug (e.g. 'acme-corp')") })
+	}, async ({ slug }) => handleGetRelationshipGraph({ slug }));
+}
+//#endregion
+//#region src/mcp/tools/get-relationship-health.ts
+const DATA_DIR$38 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+const MAX_HEALTH_AGE_MS = 3600 * 1e3;
+async function handleGetRelationshipHealth(input, dataDir = DATA_DIR$38) {
+	try {
+		let health = readHealth(dataDir, input.slug);
+		if (health === null || Date.now() - new Date(health.updatedAt).getTime() > MAX_HEALTH_AGE_MS) {
+			health = computeCustomerHealth(dataDir, input.slug);
+			writeHealth(dataDir, input.slug, health);
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				slug: input.slug,
+				overallHealth: health.overallHealth,
+				updatedAt: health.updatedAt,
+				atRiskContacts: health.contacts.filter((c) => c.riskFlags.length > 0).map((c) => c.email ?? c.contactId),
+				coldContacts: health.contacts.filter((c) => c.trend === "cold").map((c) => c.email ?? c.contactId),
+				contacts: health.contacts
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetRelationshipHealth(server) {
+	server.registerTool("get_relationship_health", {
+		title: "Get Relationship Health",
+		description: `Returns health scores for all contacts of a customer.
+Scores decay automatically when communication cadence breaks — without any manual input.
+
+Each contact gets:
+- score (0–100), grade (A–F), trend (rising|stable|declining|cold)
+- riskFlags: NO_CONTACT_14D, NO_CONTACT_30D, CHAMPION_SILENT
+- recommendation: concrete next action
+
+overallHealth is the average across all contacts.
+atRiskContacts + coldContacts are pre-filtered for quick triage.
+Health auto-updates after every log_interaction call. Recomputes if stale (>1h).
+
+Args:
+  slug: Customer slug
+
+Returns: {
+  overallHealth: number,
+  atRiskContacts: string[],
+  coldContacts: string[],
+  contacts: ContactHealth[]
+}`,
+		inputSchema: z.object({ slug: z.string().describe("Customer slug (e.g. 'acme-corp')") })
+	}, async ({ slug }) => handleGetRelationshipHealth({ slug }));
+}
+//#endregion
+//#region src/core/playbooks.ts
+function playbooksDir(dataDir, slug) {
+	return path.join(dataDir, "customers", slug, "playbooks");
+}
+function listPlaybooks(dataDir, slug) {
+	const dir = playbooksDir(dataDir, slug);
+	if (!fs.existsSync(dir)) return [];
+	return fs.readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => {
+		const filePath = path.join(dir, f);
+		const parsed = matter(fs.readFileSync(filePath, "utf-8"));
+		return {
+			slug,
+			name: f.replace(/\.md$/, ""),
+			frontmatter: parsed.data,
+			content: parsed.content.trim(),
+			path: filePath
+		};
+	});
+}
+async function writePlaybook(dataDir, slug, playbook) {
+	const dir = playbooksDir(dataDir, slug);
+	const filePath = path.join(dir, `${playbook.name}.md`);
+	await withFileQueue(filePath, async () => {
+		fs.mkdirSync(dir, { recursive: true });
+		const raw = matter.stringify(playbook.content, playbook.frontmatter);
+		fs.writeFileSync(filePath, raw, "utf-8");
+	});
+}
+function toKebabCase(name) {
+	return name.replace(/[^a-z0-9-]/gi, "-").toLowerCase().replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function parseTokens(tokens) {
+	return tokens.flatMap((token) => {
+		if (token.startsWith("deal_stage_")) return [{
+			type: "stage",
+			stage: token.slice(11)
+		}];
+		const valueGt = token.match(/^value\s*>\s*(\d+)$/);
+		if (valueGt) return [{
+			type: "value_gt",
+			value: Number(valueGt[1])
+		}];
+		const valueLt = token.match(/^value\s*<\s*(\d+)$/);
+		if (valueLt) return [{
+			type: "value_lt",
+			value: Number(valueLt[1])
+		}];
+		const stalledGt = token.match(/^days_stalled\s*>\s*(\d+)$/);
+		if (stalledGt) return [{
+			type: "days_stalled_gt",
+			value: Number(stalledGt[1])
+		}];
+		const stalledLt = token.match(/^days_stalled\s*<\s*(\d+)$/);
+		if (stalledLt) return [{
+			type: "days_stalled_lt",
+			value: Number(stalledLt[1])
+		}];
+		const healthLt = token.match(/^health\s*<\s*(\d+)$/);
+		if (healthLt) return [{
+			type: "health_lt",
+			value: Number(healthLt[1])
+		}];
+		const healthGt = token.match(/^health\s*>\s*(\d+)$/);
+		if (healthGt) return [{
+			type: "health_gt",
+			value: Number(healthGt[1])
+		}];
+		if (token === "no_champion") return [{ type: "no_champion" }];
+		if (token === "has_champion") return [{ type: "has_champion" }];
+		return [];
+	});
+}
+function parseTriggerFull(triggerStr) {
+	if (!triggerStr?.trim()) return {
+		conditions: [],
+		operator: "AND"
+	};
+	const orTokens = triggerStr.split(/\s+OR\s+/).map((t) => t.trim()).filter(Boolean);
+	if (orTokens.length > 1) return {
+		conditions: parseTokens(orTokens),
+		operator: "OR"
+	};
+	return {
+		conditions: parseTokens(triggerStr.split(/\s+AND\s+/).map((t) => t.trim()).filter(Boolean)),
+		operator: "AND"
+	};
+}
+function evaluateCondition(cond, deal, daysSinceContact) {
+	switch (cond.type) {
+		case "stage": return deal.stage === cond.stage;
+		case "value_gt": return deal.value > (cond.value ?? 0);
+		case "value_lt": return deal.value < (cond.value ?? Infinity);
+		case "days_stalled_gt": return daysSinceContact > (cond.value ?? 0);
+		case "days_stalled_lt": return daysSinceContact < (cond.value ?? Infinity);
+		case "health_lt": return deal.healthScore < (cond.value ?? 100);
+		case "health_gt": return deal.healthScore > (cond.value ?? 0);
+		case "no_champion": return !deal.championPresent;
+		case "has_champion": return deal.championPresent;
+		default: return false;
+	}
+}
+function matchPlaybooks(playbooks, deal, daysSinceContact = 0) {
+	const results = [];
+	for (const pb of playbooks) {
+		const { conditions, operator } = parseTriggerFull(pb.frontmatter.trigger);
+		if (conditions.length === 0) continue;
+		const matched = conditions.filter((c) => evaluateCondition(c, deal, daysSinceContact));
+		if (operator === "OR" ? matched.length > 0 : matched.length === conditions.length) results.push({
+			playbook: pb,
+			score: 1,
+			matchedConditions: matched,
+			totalConditions: conditions.length
+		});
+	}
+	return results.sort((a, b) => {
+		const rateDiff = (b.playbook.frontmatter.successRate ?? 0) - (a.playbook.frontmatter.successRate ?? 0);
+		return rateDiff !== 0 ? rateDiff : (b.playbook.frontmatter.usedCount ?? 0) - (a.playbook.frontmatter.usedCount ?? 0);
+	});
+}
+function buildDistillPrompt(slug, dealName, outcome, interactions) {
+	return `You are analyzing a sales deal to extract a reusable playbook.
+
+Customer: ${slug}
+Deal: ${dealName}
+Outcome: ${outcome}
+Interactions (chronological):
+${interactions.slice(0, 4e3)}
+
+Extract a reusable playbook from this deal's journey.
+
+Allowed trigger tokens (combine with " AND "):
+- deal_stage_<stage>    (e.g. deal_stage_negotiation)
+- value > <n>           (e.g. value > 50000)
+- value < <n>
+- days_stalled > <n>    (e.g. days_stalled > 7)
+- days_stalled < <n>
+- health < <n>          (e.g. health < 60)
+- health > <n>
+- no_champion
+- has_champion
+
+Return JSON only (no markdown wrapper):
+{
+  "name": "<kebab-case-playbook-name>",
+  "trigger": "<DSL string using allowed tokens>",
+  "content": "<markdown with ## Situation, ## Steps, ## Warnings sections>",
+  "successRate": <0.0-1.0>,
+  "reasoning": "<why these trigger conditions>"
+}`;
+}
+function parseLlmDistillation(response, outcomeFallback = .5) {
+	try {
+		const match = response.match(/\{[\s\S]*\}/);
+		if (!match) return null;
+		const parsed = JSON.parse(match[0]);
+		if (!parsed.name || !parsed.trigger || !parsed.content) return null;
+		return {
+			name: parsed.name,
+			trigger: parsed.trigger,
+			content: parsed.content,
+			successRate: typeof parsed.successRate === "number" ? parsed.successRate : outcomeFallback,
+			reasoning: parsed.reasoning ?? ""
+		};
+	} catch {
+		return null;
+	}
+}
+async function distillPlaybook(dataDir, slug, dealName, outcome, llmFn = callLlm) {
+	const interactionsPath = path.join(dataDir, "customers", slug, "interactions.md");
+	if (!fs.existsSync(interactionsPath)) return {
+		ok: false,
+		errorKind: "no_interactions"
+	};
+	const distillation = parseLlmDistillation(await llmFn(buildDistillPrompt(slug, dealName, outcome, fs.readFileSync(interactionsPath, "utf-8"))), outcome === "won" ? 1 : 0);
+	if (!distillation) return {
+		ok: false,
+		errorKind: "parse_failed"
+	};
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const name = toKebabCase(distillation.name);
+	const playbook = {
+		slug,
+		name,
+		frontmatter: {
+			trigger: distillation.trigger,
+			successRate: distillation.successRate,
+			usedCount: 1,
+			lastUpdated: today
+		},
+		content: distillation.content,
+		path: path.join(playbooksDir(dataDir, slug), `${name}.md`)
+	};
+	await writePlaybook(dataDir, slug, playbook);
+	return {
+		ok: true,
+		playbook,
+		reasoning: distillation.reasoning
+	};
+}
+//#endregion
+//#region src/agents/deal-agent.ts
+function agentQueuePath(dataDir, slug) {
+	return path.join(dataDir, "customers", slug, "agent-queue.json");
+}
+function readAgentQueue(dataDir, slug) {
+	const p = agentQueuePath(dataDir, slug);
+	if (!fs.existsSync(p)) return {
+		schemaVersion: "1",
+		slug,
+		pendingActions: [],
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	try {
+		return JSON.parse(fs.readFileSync(p, "utf-8"));
+	} catch {
+		return {
+			schemaVersion: "1",
+			slug,
+			pendingActions: [],
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+}
+function writeAgentQueue(dataDir, slug, queue) {
+	const p = agentQueuePath(dataDir, slug);
+	const dir = path.dirname(p);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	const updated = {
+		...queue,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	fs.writeFileSync(p, JSON.stringify(updated, null, 2), "utf-8");
+}
+function makeActionId() {
+	return `da_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function buildRecentInteractionsSummary(interactionsPath) {
+	if (!fs.existsSync(interactionsPath)) return "(no interactions)";
+	return fs.readFileSync(interactionsPath, "utf-8").split(/(?=^## \d{4}-\d{2}-\d{2})/m).filter((b) => b.trim().length > 0).slice(0, 3).map((b) => {
+		const dateMatch = b.match(/^## (\d{4}-\d{2}-\d{2}) · (\w+)/m);
+		const summaryMatch = b.match(/^\*\*Summary:\*\*\s*(.+)$/m);
+		if (!dateMatch || !summaryMatch) return "";
+		return `[${dateMatch[1]}/${dateMatch[2]}] ${summaryMatch[1].trim()}`;
+	}).filter(Boolean).join("\n");
+}
+function buildContextSummary(data) {
+	return [
+		`Deal: ${data.deal.name} | Stage: ${data.deal.stage} | Value: €${data.deal.value ?? "?"} | Close: ${data.deal.close_date ?? "not set"}`,
+		`Days since activity: ${data.daysSinceLastActivity} | Days to close: ${data.daysToClose ?? "?"}`,
+		`Deal health: grade ${data.dealHealthScore.grade} (score ${data.dealHealthScore.score})`,
+		`Warnings: ${data.dealHealthScore.warnings.join("; ") || "none"}`,
+		``,
+		`Relationship health: ${data.health.overallHealth}/100`,
+		`At-risk contacts: ${data.atRiskContacts.join(", ") || "none"}`,
+		`Cold contacts: ${data.coldContacts.join(", ") || "none"}`,
+		`Missing stakeholder roles: ${data.missingRoles.map((r) => r.role).join(", ") || "none"}`,
+		`Champions identified: ${data.championCount}`,
+		``,
+		`Recent interactions:`,
+		data.recentInteractionsSummary || "(none)"
+	].join("\n");
+}
+async function observeDeal(dataDir, slug, dealName, today) {
+	const deal = (await readPipeline(dataDir, slug).catch(() => [])).find((d) => d.name.toLowerCase() === dealName.toLowerCase());
+	if (!deal) return null;
+	const todayDate = new Date(today);
+	const updatedDate = deal.updated ? new Date(deal.updated) : todayDate;
+	const daysSinceLastActivity = Math.floor((todayDate.getTime() - updatedDate.getTime()) / 864e5);
+	const daysInCurrentStage = daysSinceLastActivity;
+	const daysToClose = deal.close_date && deal.close_date.trim() !== "" ? Math.floor((new Date(deal.close_date).getTime() - todayDate.getTime()) / 864e5) : void 0;
+	const dealHealthScore = scoreDeal(deal, {
+		daysSinceLastActivity,
+		daysInCurrentStage,
+		...daysToClose !== void 0 ? { daysToClose } : {},
+		...deal.probability !== void 0 ? { probability: deal.probability } : {}
+	});
+	const health = computeCustomerHealth(dataDir, slug, today);
+	const atRiskContacts = health.contacts.filter((c) => c.riskFlags.length > 0).map((c) => c.email ?? c.contactId);
+	const coldContacts = health.contacts.filter((c) => c.trend === "cold").map((c) => c.email ?? c.contactId);
+	const stakeholders = getStakeholders(readGraph(dataDir, slug));
+	const missingRoles = stakeholders.missingRoles.map((r) => ({
+		role: r.role,
+		urgency: r.urgency
+	}));
+	const championCount = stakeholders.champions.length;
+	const recentInteractionsSummary = buildRecentInteractionsSummary(path.join(dataDir, "customers", slug, "interactions.md"));
+	const contextSummary = buildContextSummary({
+		deal,
+		daysSinceLastActivity,
+		daysInCurrentStage,
+		daysToClose,
+		dealHealthScore,
+		health,
+		atRiskContacts,
+		coldContacts,
+		missingRoles,
+		championCount,
+		recentInteractionsSummary
+	});
+	const obs = {
+		deal,
+		daysSinceLastActivity,
+		daysInCurrentStage,
+		dealHealthScore,
+		overallRelationshipHealth: health.overallHealth,
+		atRiskContacts,
+		coldContacts,
+		missingRoles,
+		championCount,
+		recentInteractionsSummary,
+		contextSummary
+	};
+	if (daysToClose !== void 0) obs.daysToClose = daysToClose;
+	const dealSnap = {
+		slug,
+		name: deal.name,
+		stage: deal.stage,
+		value: deal.value ?? 0,
+		probability: deal.probability ?? 50,
+		healthScore: health.overallHealth,
+		daysSinceContact: daysSinceLastActivity,
+		championPresent: championCount > 0
+	};
+	const matchingPlaybooks = matchPlaybooks(listPlaybooks(dataDir, slug), dealSnap, daysSinceLastActivity);
+	if (matchingPlaybooks.length > 0) obs.matchingPlaybooks = matchingPlaybooks;
+	return obs;
+}
+function buildLlmPrompt(obs, config) {
+	const instruction = config.instruction ?? "Analyze this deal and recommend next actions.";
+	const playbookSection = obs.matchingPlaybooks && obs.matchingPlaybooks.length > 0 ? `\n## Matching Playbooks (${obs.matchingPlaybooks.length} found — apply these proven tactics)\n` + obs.matchingPlaybooks.slice(0, 2).map((m) => `### ${m.playbook.name} (${Math.round(m.playbook.frontmatter.successRate * 100)}% success rate, used ${m.playbook.frontmatter.usedCount}x)\n${m.playbook.content.slice(0, 500)}`).join("\n\n") : "";
+	return `You are a CRM deal agent. Analyze the deal situation and return an action plan.
+Return ONLY valid JSON — no markdown, no explanation.
+
+${obs.contextSummary}${playbookSection}
+
+Instruction: ${instruction}
+
+Respond with JSON matching exactly:
+{
+  "assessment": "<2-3 sentence situation assessment>",
+  "riskLevel": "low" | "medium" | "high" | "critical",
+  "plan": [
+    { "step": 1, "action": "<what to do>", "priority": "urgent" | "high" | "medium" | "low", "reason": "<why>" }
+  ],
+  "actions": [
+    {
+      "type": "log_interaction" | "update_deal" | "alert" | "schedule_meeting",
+      "payload": { /* tool-specific fields */ },
+      "confidence": 0.0-1.0,
+      "reasoning": "<why this action>"
+    }
+  ]
+}
+
+Payload schema per type:
+- log_interaction: { slug, type: "Note"|"Call"|"Meeting", summary, with }
+- update_deal: { slug, dealName, stage?, probability?, closeDate?, notes? }
+- alert: { slug, message, urgency: "critical"|"high"|"medium" }
+- schedule_meeting: { slug, with, notes }`;
+}
+function parseLlmResponse(response) {
+	try {
+		const cleaned = response.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+		const parsed = JSON.parse(cleaned);
+		if (!parsed.assessment || !parsed.riskLevel || !Array.isArray(parsed.plan)) return null;
+		return {
+			assessment: String(parsed.assessment),
+			riskLevel: parsed.riskLevel,
+			plan: Array.isArray(parsed.plan) ? parsed.plan : [],
+			actions: Array.isArray(parsed.actions) ? parsed.actions : []
+		};
+	} catch {
+		return null;
+	}
+}
+function buildRuleBasedAnalysis(obs, config) {
+	const plan = [];
+	const actions = [];
+	let riskLevel = "low";
+	if (obs.dealHealthScore.grade === "F" || obs.coldContacts.length > 0) riskLevel = "critical";
+	else if (obs.dealHealthScore.grade === "D" || obs.atRiskContacts.length > 0) riskLevel = "high";
+	else if (obs.dealHealthScore.grade === "C") riskLevel = "medium";
+	let step = 1;
+	if (obs.matchingPlaybooks && obs.matchingPlaybooks.length > 0) for (const match of obs.matchingPlaybooks.slice(0, 2)) {
+		plan.push({
+			step: step++,
+			action: `Apply playbook: "${match.playbook.name}"`,
+			priority: "high",
+			reason: `Proven tactic (${Math.round(match.playbook.frontmatter.successRate * 100)}% success, used ${match.playbook.frontmatter.usedCount}x) — trigger: ${match.playbook.frontmatter.trigger}`
+		});
+		actions.push({
+			type: "alert",
+			payload: {
+				slug: config.slug,
+				message: `Playbook available: "${match.playbook.name}" (${Math.round(match.playbook.frontmatter.successRate * 100)}% success rate)`,
+				playbookContent: match.playbook.content.slice(0, 1e3),
+				urgency: "high"
+			},
+			confidence: match.playbook.frontmatter.successRate,
+			reasoning: `Trigger matched: ${match.playbook.frontmatter.trigger}`
+		});
+	}
+	if (obs.coldContacts.length > 0) {
+		plan.push({
+			step: step++,
+			action: `Re-engage cold contacts: ${obs.coldContacts.join(", ")}`,
+			priority: "urgent",
+			reason: "No contact in 30+ days"
+		});
+		actions.push({
+			type: "alert",
+			payload: {
+				slug: config.slug,
+				message: `Cold contacts: ${obs.coldContacts.join(", ")}`,
+				urgency: "critical"
+			},
+			confidence: .95,
+			reasoning: "No contact in 30+ days"
+		});
+	}
+	if (obs.atRiskContacts.length > 0) {
+		plan.push({
+			step: step++,
+			action: `Schedule call with at-risk contacts`,
+			priority: "high",
+			reason: "14+ days without contact"
+		});
+		actions.push({
+			type: "schedule_meeting",
+			payload: {
+				slug: config.slug,
+				with: obs.atRiskContacts[0] ?? "",
+				notes: "Scheduled by deal agent — relationship at risk"
+			},
+			confidence: .8,
+			reasoning: "At-risk contact identified"
+		});
+	}
+	if (obs.missingRoles.some((r) => r.role === "economic_buyer")) plan.push({
+		step: step++,
+		action: "Identify economic buyer",
+		priority: "high",
+		reason: "No budget owner identified"
+	});
+	if (obs.daysToClose !== void 0 && obs.daysToClose < 14 && obs.dealHealthScore.grade !== "A") {
+		plan.push({
+			step: step++,
+			action: "Update deal close date or probability",
+			priority: "urgent",
+			reason: `Close date in ${obs.daysToClose} days, deal at grade ${obs.dealHealthScore.grade}`
+		});
+		actions.push({
+			type: "update_deal",
+			payload: {
+				slug: config.slug,
+				dealName: config.dealName,
+				notes: `Reviewed by deal agent — ${obs.daysToClose}d to close`
+			},
+			confidence: .75,
+			reasoning: "Close date imminent"
+		});
+	}
+	if (plan.length === 0) plan.push({
+		step: 1,
+		action: "Maintain current cadence",
+		priority: "low",
+		reason: "Deal healthy"
+	});
+	return {
+		assessment: `Deal "${config.dealName}" in stage "${obs.deal.stage}" — health grade ${obs.dealHealthScore.grade} (${obs.dealHealthScore.score}/100). Risk: ${riskLevel}.`,
+		riskLevel,
+		plan,
+		actions
+	};
+}
+function selectActions(analysis, obs, config) {
+	return analysis.actions.map((a) => {
+		const dealValue = obs.deal.value ?? 0;
+		const autoExecutable = config.autonomyLevel === "act" && a.confidence >= .7 && dealValue < config.valueThreshold;
+		return {
+			actionId: makeActionId(),
+			type: a.type,
+			payload: a.payload,
+			confidence: a.confidence,
+			reasoning: a.reasoning,
+			requiresHumanApproval: !autoExecutable,
+			status: "pending",
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	});
+}
+const VALID_STAGES = [
+	"lead",
+	"qualified",
+	"proposal",
+	"negotiation",
+	"won",
+	"lost"
+];
+async function executeAction(action, dataDir) {
+	const slug = action.payload["slug"];
+	if (!slug) return "skipped";
+	switch (action.type) {
+		case "log_interaction": {
+			const { appendInteraction } = await import("./interactions-writer-dSPy1XfO.js");
+			await appendInteraction(dataDir, slug, {
+				date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+				type: action.payload["type"] ?? "Note",
+				with: String(action.payload["with"] ?? "agent"),
+				summary: String(action.payload["summary"] ?? ""),
+				nextSteps: [],
+				sourceRef: `agent://deal-agent/${action.actionId}`,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return "executed";
+		}
+		case "schedule_meeting": {
+			const { appendInteraction } = await import("./interactions-writer-dSPy1XfO.js");
+			await appendInteraction(dataDir, slug, {
+				date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+				type: "Note",
+				with: String(action.payload["with"] ?? ""),
+				summary: `[Agent scheduled] ${String(action.payload["notes"] ?? "Meeting scheduled by deal agent")}`,
+				nextSteps: [`Schedule meeting with ${String(action.payload["with"] ?? "contact")}`],
+				sourceRef: `agent://deal-agent/${action.actionId}`,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return "executed";
+		}
+		case "update_deal": {
+			const { handleUpdateDeal } = await import("./update-deal-BNwPGaTV.js");
+			const payload = action.payload;
+			const validStage = VALID_STAGES.find((s) => s === payload.stage);
+			await handleUpdateDeal({
+				slug: payload.slug,
+				dealName: payload.dealName,
+				...validStage !== void 0 ? { stage: validStage } : {},
+				...payload.value !== void 0 ? { value: payload.value } : {},
+				...payload.probability !== void 0 ? { probability: payload.probability } : {},
+				...payload.closeDate !== void 0 ? { closeDate: payload.closeDate } : {},
+				...payload.notes !== void 0 ? { notes: payload.notes } : {}
+			}, dataDir);
+			return "executed";
+		}
+		case "alert": {
+			const queue = readAgentQueue(dataDir, slug);
+			const alertAction = {
+				...action,
+				status: "pending"
+			};
+			if (!queue.pendingActions.find((a) => a.actionId === action.actionId)) {
+				queue.pendingActions.push(alertAction);
+				writeAgentQueue(dataDir, slug, queue);
+			}
+			return "executed";
+		}
+	}
+}
+async function runDealAgent(config, dataDir, llmFn = callLlm) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const obs = await observeDeal(dataDir, config.slug, config.dealName, config.today);
+	if (!obs) throw new Error(`Deal "${config.dealName}" not found for customer "${config.slug}"`);
+	let analysis;
+	try {
+		analysis = parseLlmResponse(await llmFn(buildLlmPrompt(obs, config))) ?? buildRuleBasedAnalysis(obs, config);
+	} catch {
+		analysis = buildRuleBasedAnalysis(obs, config);
+	}
+	const allActions = selectActions(analysis, obs, config);
+	const actionsQueued = [];
+	const actionsExecuted = [];
+	if (config.autonomyLevel === "observe") {} else if (config.autonomyLevel === "suggest") {
+		if (allActions.length > 0) {
+			const queue = readAgentQueue(dataDir, config.slug);
+			for (const action of allActions) {
+				queue.pendingActions.push({
+					...action,
+					requiresHumanApproval: true
+				});
+				actionsQueued.push(action);
+			}
+			writeAgentQueue(dataDir, config.slug, queue);
+		}
+	} else {
+		const queue = readAgentQueue(dataDir, config.slug);
+		let queueDirty = false;
+		for (const action of allActions) if (!action.requiresHumanApproval) {
+			const outcome = await executeAction(action, dataDir).catch(() => "skipped");
+			actionsExecuted.push({
+				...action,
+				status: outcome === "executed" ? "executed" : "skipped"
+			});
+		} else {
+			queue.pendingActions.push(action);
+			actionsQueued.push(action);
+			queueDirty = true;
+		}
+		if (queueDirty) writeAgentQueue(dataDir, config.slug, queue);
+	}
+	const trace = {
+		timestamp,
+		slug: config.slug,
+		dealName: config.dealName,
+		autonomyLevel: config.autonomyLevel,
+		observation: obs.contextSummary,
+		plan: analysis.plan.map((s) => `${s.step}. ${s.action} [${s.priority}]`),
+		actionsConsidered: allActions,
+		actionTaken: actionsExecuted[0] ?? null,
+		outcome: actionsExecuted.length > 0 ? "executed" : actionsQueued.length > 0 ? "queued" : "observed"
+	};
+	return {
+		slug: config.slug,
+		dealName: config.dealName,
+		assessment: analysis.assessment,
+		riskLevel: analysis.riskLevel,
+		plan: analysis.plan,
+		actionsQueued,
+		actionsExecuted,
+		trace
+	};
+}
+//#endregion
+//#region src/mcp/tools/run-deal-agent.ts
+const DATA_DIR$37 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleRunDealAgent(input, dataDir = DATA_DIR$37) {
+	try {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const result = await runDealAgent({
+			slug: input.slug,
+			dealName: input.dealName,
+			autonomyLevel: input.autonomyLevel ?? "suggest",
+			valueThreshold: input.valueThreshold ?? 5e4,
+			today,
+			...input.instruction !== void 0 ? { instruction: input.instruction } : {}
+		}, dataDir);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(result, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerRunDealAgent(server) {
+	server.registerTool("run_deal_agent", {
+		title: "Run Deal Agent",
+		description: `Analyzes a specific deal and generates a prioritized action plan.
+
+Three autonomy levels:
+- observe: analyze and return plan, no side effects
+- suggest (default): queue actions for human review in agent-queue.json
+- act: auto-execute actions with confidence ≥ 0.7 and value < valueThreshold
+
+Each action includes confidence score and reasoning (glass-box).
+Returns full trace for inspection.
+
+Args:
+  slug: Customer slug
+  dealName: Exact deal name
+  autonomyLevel: "observe" | "suggest" | "act" (default: "suggest")
+  instruction: Optional context/question for the agent
+  valueThreshold: EUR value above which no auto-execution (default: 50000)
+
+Returns: { assessment, riskLevel, plan[], actionsQueued[], actionsExecuted[], trace }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			dealName: z.string().describe("Exact deal name"),
+			autonomyLevel: z.enum([
+				"observe",
+				"suggest",
+				"act"
+			]).optional().describe("Autonomy level (default: suggest)"),
+			instruction: z.string().optional().describe("Optional instruction for the agent"),
+			valueThreshold: z.number().optional().describe("EUR value above which no auto-execution (default: 50000)")
+		})
+	}, async ({ slug, dealName, autonomyLevel, instruction, valueThreshold }) => handleRunDealAgent({
+		slug,
+		dealName,
+		...autonomyLevel !== void 0 ? { autonomyLevel } : {},
+		...instruction !== void 0 ? { instruction } : {},
+		...valueThreshold !== void 0 ? { valueThreshold } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/approve-agent-action.ts
+const DATA_DIR$36 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleApproveAgentAction(input, dataDir = DATA_DIR$36) {
+	try {
+		const queue = readAgentQueue(dataDir, input.slug);
+		const idx = queue.pendingActions.findIndex((a) => a.actionId === input.actionId);
+		if (idx === -1) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: `Action ${input.actionId} not found in queue`
+			}, null, 2)
+		}] };
+		const action = queue.pendingActions[idx];
+		if (!input.approved) {
+			queue.pendingActions[idx] = {
+				...action,
+				status: "rejected"
+			};
+			writeAgentQueue(dataDir, input.slug, queue);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					actionId: input.actionId,
+					status: "rejected"
+				}, null, 2)
+			}] };
+		}
+		const outcome = await executeAction(action, dataDir);
+		queue.pendingActions[idx] = {
+			...action,
+			status: outcome === "executed" ? "executed" : "skipped"
+		};
+		writeAgentQueue(dataDir, input.slug, queue);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				actionId: input.actionId,
+				status: queue.pendingActions[idx].status
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerApproveAgentAction(server) {
+	server.registerTool("approve_agent_action", {
+		title: "Approve Agent Action",
+		description: `Approve or reject a pending action from the deal agent queue.
+
+Find actionId in the actionsQueued array returned by run_deal_agent.
+
+Args:
+  slug: Customer slug
+  actionId: Action ID from the agent queue
+  approved: true to execute, false to reject
+
+Returns: { success, actionId, status }`,
+		inputSchema: z.object({
+			slug: z.string(),
+			actionId: z.string(),
+			approved: z.boolean()
+		})
+	}, async ({ slug, actionId, approved }) => handleApproveAgentAction({
+		slug,
+		actionId,
+		approved
+	}));
+}
+//#endregion
+//#region src/mcp/tools/simulate-revenue.ts
+const DATA_DIR$35 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleSimulateRevenue(input, dataDir = DATA_DIR$35) {
+	try {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const horizon = input.horizon ?? "quarter";
+		const simInput = await buildSimulationInput(dataDir, horizon, today);
+		if (input.iterations !== void 0) simInput.iterations = input.iterations;
+		const result = runSimulation(simInput);
+		const confidence = buildConfidenceMessage(result, simInput.deals.length);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				forecast: result,
+				confidence,
+				dealCount: simInput.deals.length,
+				horizon,
+				simulatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerSimulateRevenue(server) {
+	server.registerTool("simulate_revenue", {
+		title: "Simulate Revenue",
+		description: `Monte Carlo pipeline revenue simulation with P10/P50/P90 confidence intervals.
+
+Adjusts deal win probabilities using relationship health scores (D12) and
+champion presence (D11). Returns the range of possible quarterly/annual outcomes.
+
+Use this instead of (or alongside) get_pipeline_forecast when you need:
+- Uncertainty quantification (not just expected value)
+- At-risk revenue identification
+- Deal sensitivity analysis ("which deal matters most")
+- Month-by-month close distribution
+
+Args:
+  horizon: "quarter" (default) | "year"
+  iterations: simulation iterations (default: 10000)
+
+Returns: { forecast: { p10, p50, p90, expected, stdDev, atRiskRevenue, byCloseMonth, topRisks, sensitivityMap }, confidence, dealCount, horizon }`,
+		inputSchema: z.object({
+			horizon: z.enum(["quarter", "year"]).optional().describe("Forecast horizon (default: \"quarter\")"),
+			iterations: z.number().optional().describe("Monte Carlo iterations (default: 10000)")
+		})
+	}, async ({ horizon, iterations }) => handleSimulateRevenue({
+		...horizon !== void 0 ? { horizon } : {},
+		...iterations !== void 0 ? { iterations } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/get-playbook.ts
+const DATA_DIR$34 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetPlaybook(input, dataDir = DATA_DIR$34) {
+	try {
+		const playbooks = listPlaybooks(dataDir, input.slug);
+		if (!(input.stage !== void 0 || input.value !== void 0 || input.healthScore !== void 0)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				matches: playbooks.map((pb) => ({
+					name: pb.name,
+					trigger: pb.frontmatter.trigger,
+					successRate: pb.frontmatter.successRate,
+					usedCount: pb.frontmatter.usedCount,
+					lastUpdated: pb.frontmatter.lastUpdated,
+					content: pb.content
+				})),
+				totalPlaybooks: playbooks.length,
+				slug: input.slug
+			}, null, 2)
+		}] };
+		const matches = matchPlaybooks(playbooks, {
+			slug: input.slug,
+			name: "",
+			stage: input.stage ?? "lead",
+			value: input.value ?? 0,
+			probability: 50,
+			healthScore: input.healthScore ?? 60,
+			daysSinceContact: input.daysSinceContact ?? 0,
+			championPresent: input.championPresent ?? false
+		}, input.daysSinceContact ?? 0);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				matches: matches.map((m) => ({
+					name: m.playbook.name,
+					score: m.score,
+					matchedConditions: m.matchedConditions,
+					trigger: m.playbook.frontmatter.trigger,
+					successRate: m.playbook.frontmatter.successRate,
+					usedCount: m.playbook.frontmatter.usedCount,
+					content: m.playbook.content
+				})),
+				totalPlaybooks: playbooks.length,
+				slug: input.slug
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetPlaybook(server) {
+	server.registerTool("get_playbook", {
+		title: "Get Playbook",
+		description: `Retrieve playbooks for a customer. With deal context, returns only matching playbooks sorted by success rate. Without deal context, returns all playbooks.
+
+Use after run_deal_agent or before a sales call to get proven guidance for the current situation.
+
+Args:
+  slug: Customer ID (required)
+  stage: Deal stage (optional — enables trigger matching)
+  value: Deal value in euros (optional)
+  healthScore: Relationship health score 0–100 (optional)
+  daysSinceContact: Days since last contact / days_stalled proxy (optional)
+  championPresent: Whether a champion is identified (optional)
+
+Returns: { matches: [{ name, score, trigger, successRate, usedCount, content }], totalPlaybooks, slug }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer ID"),
+			stage: z.string().optional().describe("Deal stage"),
+			value: z.number().optional().describe("Deal value in euros"),
+			healthScore: z.number().optional().describe("Health score 0–100"),
+			daysSinceContact: z.number().optional().describe("Days since last contact"),
+			championPresent: z.boolean().optional().describe("Champion identified")
+		})
+	}, async ({ slug, stage, value, healthScore, daysSinceContact, championPresent }) => handleGetPlaybook({
+		slug,
+		...stage !== void 0 ? { stage } : {},
+		...value !== void 0 ? { value } : {},
+		...healthScore !== void 0 ? { healthScore } : {},
+		...daysSinceContact !== void 0 ? { daysSinceContact } : {},
+		...championPresent !== void 0 ? { championPresent } : {}
+	}, DATA_DIR$34));
+}
+//#endregion
+//#region src/mcp/tools/create-playbook.ts
+const DATA_DIR$33 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleCreatePlaybook(input, dataDir = DATA_DIR$33) {
+	try {
+		const name = toKebabCase(input.name);
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const filePath = path.join(playbooksDir(dataDir, input.slug), `${name}.md`);
+		const playbook = {
+			slug: input.slug,
+			name,
+			frontmatter: {
+				trigger: input.trigger,
+				successRate: input.successRate ?? .5,
+				usedCount: 0,
+				lastUpdated: today
+			},
+			content: input.content,
+			path: filePath
+		};
+		await writePlaybook(dataDir, input.slug, playbook);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				playbook: {
+					name,
+					trigger: input.trigger,
+					successRate: playbook.frontmatter.successRate,
+					usedCount: 0,
+					lastUpdated: today,
+					path: filePath
+				}
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerCreatePlaybook(server) {
+	server.registerTool("create_playbook", {
+		title: "Create Playbook",
+		description: `Create or update a playbook for a customer. Playbooks encode proven tactics for specific deal situations.
+
+Trigger DSL uses AND-only conditions:
+  deal_stage_<stage> | value > N | value < N | days_stalled > N | health < N | health > N | no_champion | has_champion
+
+Example: "deal_stage_negotiation AND value > 50000 AND days_stalled > 7"
+
+Args:
+  slug: Customer ID
+  name: Playbook name (auto-converted to kebab-case)
+  trigger: Trigger DSL string (conditions separated by AND)
+  content: Playbook markdown body (## Situation, ## Steps, ## Warnings, ## Templates)
+  successRate: Historical win rate 0.0–1.0 (default: 0.5)
+
+Returns: { success: true, playbook: { name, trigger, successRate, path } }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer ID"),
+			name: z.string().describe("Playbook name"),
+			trigger: z.string().describe("Trigger DSL string"),
+			content: z.string().describe("Playbook markdown body"),
+			successRate: z.number().min(0).max(1).optional().describe("Historical win rate 0.0–1.0")
+		})
+	}, async ({ slug, name, trigger, content, successRate }) => handleCreatePlaybook({
+		slug,
+		name,
+		trigger,
+		content,
+		...successRate !== void 0 ? { successRate } : {}
+	}, DATA_DIR$33));
+}
+//#endregion
+//#region src/mcp/tools/list-playbooks.ts
+const DATA_DIR$32 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListPlaybooks(input, dataDir = DATA_DIR$32) {
+	try {
+		const playbooks = listPlaybooks(dataDir, input.slug);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				playbooks: playbooks.map((pb) => ({
+					name: pb.name,
+					trigger: pb.frontmatter.trigger,
+					successRate: pb.frontmatter.successRate,
+					usedCount: pb.frontmatter.usedCount,
+					lastUpdated: pb.frontmatter.lastUpdated
+				})),
+				count: playbooks.length,
+				slug: input.slug
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerListPlaybooks(server) {
+	server.registerTool("list_playbooks", {
+		title: "List Playbooks",
+		description: `List all playbooks for a customer (metadata only, no body content).
+
+Use to discover available playbooks before calling get_playbook with deal context.
+
+Args:
+  slug: Customer ID
+
+Returns: { playbooks: [{ name, trigger, successRate, usedCount, lastUpdated }], count, slug }`,
+		inputSchema: z.object({ slug: z.string().describe("Customer ID") })
+	}, async ({ slug }) => handleListPlaybooks({ slug }, DATA_DIR$32));
+}
+//#endregion
+//#region src/mcp/tools/distill-playbook.ts
+const DATA_DIR$31 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleDistillPlaybook(input, dataDir = DATA_DIR$31, llmFn = callLlm) {
+	try {
+		const result = await distillPlaybook(dataDir, input.slug, input.dealName, input.outcome, llmFn);
+		if (!result.ok) {
+			const error = result.errorKind === "no_interactions" ? `No interactions.md found for ${input.slug}` : "LLM response could not be parsed as playbook";
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: false,
+					error
+				}, null, 2)
+			}] };
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: true,
+				playbook: {
+					name: result.playbook.name,
+					trigger: result.playbook.frontmatter.trigger,
+					successRate: result.playbook.frontmatter.successRate,
+					usedCount: result.playbook.frontmatter.usedCount,
+					path: result.playbook.path
+				},
+				reasoning: result.reasoning
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerDistillPlaybook(server) {
+	server.registerTool("distill_playbook", {
+		title: "Distill Playbook",
+		description: `Use LLM to extract a reusable playbook from a won or lost deal's interaction history. Analyzes the customer's interactions.md and identifies the winning/losing pattern as a structured playbook.
+
+Run after every won or lost deal to build your procedural memory library.
+
+Args:
+  slug: Customer ID
+  dealName: Name of the deal to analyze
+  outcome: "won" or "lost"
+
+Returns: { success: true, playbook: { name, trigger, successRate, path }, reasoning }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer ID"),
+			dealName: z.string().describe("Deal name to analyze"),
+			outcome: z.enum(["won", "lost"]).describe("Deal outcome")
+		})
+	}, async ({ slug, dealName, outcome }) => handleDistillPlaybook({
+		slug,
+		dealName,
+		outcome
+	}, DATA_DIR$31));
+}
+//#endregion
+//#region src/mcp/tools/pursue-goal.ts
+const DATA_DIR$30 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handlePursueGoal(input, dataDir = DATA_DIR$30, options = {}) {
+	try {
+		enforceRbac(dataDir, "pursue_goal");
+		const goal = await pursueGoal(dataDir, {
+			description: input.goal,
+			deadline: input.deadline,
+			...input.context ? { context: input.context } : {}
+		}, {
+			actor: getActor(),
+			...options.buildInputFn ? { buildInputFn: options.buildInputFn } : {},
+			...options.llmFn ? { llmFn: options.llmFn } : {}
+		});
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				goalId: goal.id,
+				description: goal.description,
+				target: goal.target,
+				deadline: goal.deadline,
+				type: goal.type,
+				decomposition: {
+					analysis: goal.decomposition.analysis,
+					currentPipeline: goal.decomposition.currentPipeline,
+					gap: goal.decomposition.gap,
+					subGoals: goal.decomposition.subGoals,
+					probabilisticOutcome: goal.decomposition.probabilisticOutcome
+				}
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerPursueGoal(server) {
+	server.registerTool("pursue_goal", {
+		title: "Pursue Goal",
+		description: `Set a revenue or pipeline goal and get an AI-decomposed action plan.
+
+Analyzes current pipeline (P50 forecast) and decomposes the gap into prioritized sub-goals per deal. Persists the goal in .agentic/goals.json for tracking.
+
+RBAC: manager+
+
+Args:
+  goal: Natural language goal description (e.g. "Close €500k ARR this quarter")
+  deadline: Target deadline (YYYY-MM-DD)
+  context: Optional constraints (e.g. "Focus on existing pipeline only")
+
+Returns: { goalId, description, target, deadline, decomposition: { analysis, currentPipeline, gap, subGoals, probabilisticOutcome } }`,
+		inputSchema: z.object({
+			goal: z.string().describe("Natural language goal (e.g. 'Close €500k ARR this quarter')"),
+			deadline: z.string().describe("Target deadline YYYY-MM-DD"),
+			context: z.string().optional().describe("Optional constraints or focus areas")
+		})
+	}, async ({ goal, deadline, context }) => handlePursueGoal({
+		goal,
+		deadline,
+		...context !== void 0 ? { context } : {}
+	}, DATA_DIR$30));
+}
+//#endregion
+//#region src/mcp/tools/get-goal-status.ts
+const DATA_DIR$29 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetGoalStatus(input, dataDir = DATA_DIR$29) {
+	try {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const allGoals = input.goalId ? readGoals(dataDir).filter((g) => g.id === input.goalId) : getActiveGoals(dataDir);
+		if (input.goalId && allGoals.length === 0) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: `Goal '${input.goalId}' not found`
+			}, null, 2)
+		}] };
+		const goals = allGoals.map((g) => {
+			const deadlineMs = new Date(g.deadline).getTime();
+			const todayMs = new Date(today).getTime();
+			const daysRemaining = Math.max(0, Math.ceil((deadlineMs - todayMs) / 864e5));
+			return {
+				id: g.id,
+				description: g.description,
+				target: g.target,
+				progress: g.progress,
+				status: g.status,
+				deadline: g.deadline,
+				daysRemaining,
+				subGoals: g.decomposition.subGoals.slice(0, 3),
+				createdAt: g.createdAt
+			};
+		});
+		const active = allGoals.filter((g) => g.status === "active");
+		const completed = allGoals.filter((g) => g.status === "completed");
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				goals,
+				activeCount: active.length,
+				completedCount: completed.length
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetGoalStatus(server) {
+	server.registerTool("get_goal_status", {
+		title: "Get Goal Status",
+		description: `Get the status of active goals. Without goalId, returns all active goals. With goalId, returns that specific goal.
+
+Returns progress, days remaining, and top sub-goals for each goal.
+
+Args:
+  goalId: (optional) Specific goal ID — if omitted, returns all active goals
+
+Returns: { goals: [{ id, description, target, progress, status, deadline, daysRemaining, subGoals }], activeCount, completedCount }`,
+		inputSchema: z.object({ goalId: z.string().optional().describe("Specific goal ID (omit for all active goals)") })
+	}, async ({ goalId }) => handleGetGoalStatus({ ...goalId !== void 0 ? { goalId } : {} }, DATA_DIR$29));
+}
+//#endregion
+//#region src/mcp/tools/register-push-subscription.ts
+const DATA_DIR$28 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+const VALID_PROVIDERS = [
+	"gmail",
+	"microsoft-graph",
+	"slack"
+];
+async function handleRegisterPushSubscription(input, dataDir = DATA_DIR$28) {
+	try {
+		if (!VALID_PROVIDERS.includes(input.provider)) return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: `Unknown provider: ${input.provider}`
+			}, null, 2)
+		}] };
+		enforceRbac(dataDir, "register_push_subscription");
+		const providerData = {};
+		if (input.gmailTopicName) providerData["gmailTopicName"] = input.gmailTopicName;
+		if (input.microsoftClientState) providerData["microsoftClientState"] = input.microsoftClientState;
+		if (input.microsoftResource) providerData["microsoftResource"] = input.microsoftResource;
+		if (input.slackTeamId) providerData["slackTeamId"] = input.slackTeamId;
+		if (input.slackChannelId) providerData["slackChannelId"] = input.slackChannelId;
+		const sub = await register(dataDir, input.provider, input.slug, {
+			webhookUrl: input.webhookUrl,
+			providerData
+		});
+		const warning = input.webhookUrl.includes("localhost") ? "Warning: webhookUrl contains 'localhost' — providers cannot reach local endpoints. Use a tunnel (e.g. ngrok http 3847) for development." : void 0;
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				subscriptionId: sub.id,
+				provider: sub.provider,
+				slug: sub.slug,
+				status: sub.status,
+				expiresAt: sub.expiresAt,
+				createdAt: sub.createdAt,
+				...warning ? { warning } : {}
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerRegisterPushSubscription(server) {
+	server.registerTool("register_push_subscription", {
+		title: "Register Push Subscription",
+		description: `Register a real-time push subscription for a customer (Gmail Pub/Sub, MS Graph webhook, or Slack Events).
+
+Instead of polling every 30 minutes, the provider will push new events to dxcrm within seconds.
+
+RBAC: admin only
+
+Args:
+  provider: "gmail" | "microsoft-graph" | "slack"
+  slug: Customer slug to receive events for
+  webhookUrl: Public HTTPS URL where the provider will POST events (e.g. https://yourserver.com/webhooks/gmail)
+  gmailTopicName: (Gmail only) Cloud Pub/Sub topic name (e.g. projects/my-project/topics/gmail-push)
+  microsoftClientState: (MS Graph only) Secret for HMAC verification
+  microsoftResource: (MS Graph only) Resource path (e.g. /me/mailFolders/Inbox/messages)
+  slackTeamId: (Slack only) Workspace/team ID (e.g. T12345)
+  slackChannelId: (Slack only) Optional specific channel to monitor
+
+Returns: { subscriptionId, provider, slug, status, expiresAt, createdAt, warning? }`,
+		inputSchema: z.object({
+			provider: z.enum([
+				"gmail",
+				"microsoft-graph",
+				"slack"
+			]).describe("Push provider"),
+			slug: z.string().describe("Customer slug"),
+			webhookUrl: z.string().describe("Public HTTPS URL for provider callbacks"),
+			gmailTopicName: z.string().optional().describe("Gmail: Cloud Pub/Sub topic name"),
+			microsoftClientState: z.string().optional().describe("MS Graph: secret for verification"),
+			microsoftResource: z.string().optional().describe("MS Graph: resource path"),
+			slackTeamId: z.string().optional().describe("Slack: workspace team ID"),
+			slackChannelId: z.string().optional().describe("Slack: optional channel ID")
+		})
+	}, async ({ provider, slug, webhookUrl, gmailTopicName, microsoftClientState, microsoftResource, slackTeamId, slackChannelId }) => handleRegisterPushSubscription({
+		provider,
+		slug,
+		webhookUrl,
+		...gmailTopicName !== void 0 ? { gmailTopicName } : {},
+		...microsoftClientState !== void 0 ? { microsoftClientState } : {},
+		...microsoftResource !== void 0 ? { microsoftResource } : {},
+		...slackTeamId !== void 0 ? { slackTeamId } : {},
+		...slackChannelId !== void 0 ? { slackChannelId } : {}
+	}, DATA_DIR$28));
+}
+//#endregion
+//#region src/mcp/tools/get-push-status.ts
+const DATA_DIR$27 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetPushStatus(input, dataDir = DATA_DIR$27) {
+	try {
+		let subs = await readSubscriptions(dataDir);
+		if (input.slug) subs = subs.filter((s) => s.slug === input.slug);
+		if (input.provider) subs = subs.filter((s) => s.provider === input.provider);
+		const now = Date.now();
+		const RENEWAL_THRESHOLD_MS = 1440 * 60 * 1e3;
+		const subscriptions = subs.map((s) => {
+			const expiresInHours = s.expiresAt ? Math.round((new Date(s.expiresAt).getTime() - now) / (3600 * 1e3)) : null;
+			const needsRenewal = s.expiresAt !== null && new Date(s.expiresAt).getTime() - now < RENEWAL_THRESHOLD_MS;
+			return {
+				id: s.id,
+				provider: s.provider,
+				slug: s.slug,
+				status: s.status,
+				expiresAt: s.expiresAt,
+				expiresInHours,
+				needsRenewal,
+				lastEventAt: s.lastEventAt,
+				eventsProcessed: s.eventsProcessed,
+				webhookUrl: s.webhookUrl
+			};
+		});
+		const countByStatus = (status) => subs.filter((s) => s.status === status).length;
+		const summary = {
+			total: subs.length,
+			active: countByStatus("active"),
+			expiringSoon: subscriptions.filter((s) => s.needsRenewal && s.status === "active").length,
+			expired: countByStatus("expired")
+		};
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				subscriptions,
+				summary
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetPushStatus(server) {
+	server.registerTool("get_push_status", {
+		title: "Get Push Status",
+		description: `Get the status of all active push subscriptions (Gmail Pub/Sub, MS Graph, Slack Events).
+
+Shows which customers have real-time push enabled, when subscriptions expire, and how many events have been processed.
+
+RBAC: any
+
+Args:
+  slug: (optional) Filter by customer slug
+  provider: (optional) Filter by provider — "gmail" | "microsoft-graph" | "slack"
+
+Returns: { subscriptions: [{ id, provider, slug, status, expiresAt, expiresInHours, needsRenewal, lastEventAt, eventsProcessed }], summary: { total, active, expiringSoon, expired } }`,
+		inputSchema: z.object({
+			slug: z.string().optional().describe("Filter by customer slug"),
+			provider: z.enum([
+				"gmail",
+				"microsoft-graph",
+				"slack"
+			]).optional().describe("Filter by provider")
+		})
+	}, async ({ slug, provider }) => handleGetPushStatus({
+		...slug !== void 0 ? { slug } : {},
+		...provider !== void 0 ? { provider } : {}
+	}, DATA_DIR$27));
+}
+//#endregion
+//#region src/core/org-intelligence.ts
+function buildStakeholderMap(dataDir, slug, today, dealName) {
+	const graph = readGraph(dataDir, slug);
+	const stakeholders = getStakeholders(graph);
+	const health = readHealth(dataDir, slug);
+	const champIds = new Set(stakeholders.champions.map((n) => n.id));
+	const buyerIds = new Set(stakeholders.economicBuyers.map((n) => n.id));
+	const blockerIds = new Set(stakeholders.blockers.map((n) => n.id));
+	const healthByContactId = new Map((health?.contacts ?? []).map((c) => [c.contactId, c]));
+	const people = graph.nodes.filter((n) => n.type === "person").map((node) => {
+		const contactHealth = healthByContactId.get(node.id);
+		let role = "unknown";
+		if (champIds.has(node.id)) role = "champion";
+		else if (buyerIds.has(node.id)) role = "economic_buyer";
+		else if (blockerIds.has(node.id)) role = "blocker";
+		const edges = graph.edges.filter((e) => e.from === node.id);
+		const contactStrength = edges.length > 0 ? Math.round(Math.max(...edges.map((e) => e.weight)) * 100) / 100 : .5;
+		const profile = {
+			name: node.label,
+			role,
+			healthScore: contactHealth?.score ?? 50,
+			daysSinceContact: contactHealth?.daysSinceContact ?? 999,
+			contactStrength,
+			riskFlags: contactHealth?.riskFlags ?? []
+		};
+		if (node.properties.email) profile.email = node.properties.email;
+		return profile;
+	});
+	const riskAssessment = buildRiskAssessment(people, stakeholders.missingRoles, []);
+	const recommendation = deriveRecommendation(people, stakeholders.missingRoles);
+	return {
+		slug,
+		...dealName ? { dealName } : {},
+		updatedAt: (/* @__PURE__ */ new Date(`${today}T00:00:00Z`)).toISOString(),
+		people,
+		missingRoles: stakeholders.missingRoles,
+		riskAssessment,
+		recommendation
+	};
+}
+function buildRiskAssessment(people, missingRoles, signals = []) {
+	const risks = [];
+	if (missingRoles.some((r) => r.role === "champion")) risks.push("No champion identified — deal lacks an internal advocate.");
+	if (missingRoles.some((r) => r.role === "economic_buyer")) risks.push("Economic buyer unknown — decision authority not confirmed.");
+	const coldPeople = people.filter((p) => p.riskFlags.includes("NO_CONTACT_30D"));
+	if (coldPeople.length > 0) risks.push(`Cold contacts (30d+ silence): ${coldPeople.map((p) => p.name).join(", ")}.`);
+	const lowHealth = people.filter((p) => p.healthScore < 40);
+	if (lowHealth.length > 0) risks.push(`Low health score (<40): ${lowHealth.map((p) => p.name).join(", ")}.`);
+	const negativeSignals = signals.filter((s) => s.impact === "negative");
+	for (const sig of negativeSignals.slice(0, 2)) risks.push(`External signal: ${sig.summary}`);
+	return risks.length > 0 ? risks.join(" ") : "No critical risks detected.";
+}
+function deriveRecommendation(people, missingRoles) {
+	const critical = missingRoles.find((r) => r.urgency === "critical");
+	if (critical) return critical.suggestion;
+	const coldPeople = people.filter((p) => p.riskFlags.includes("NO_CONTACT_30D"));
+	if (coldPeople.length > 0) return `Re-engage ${coldPeople.map((p) => p.name).join(", ")} — no contact in 30+ days.`;
+	const important = missingRoles.find((r) => r.urgency === "important");
+	if (important) return important.suggestion;
+	return `Relationship health avg ${people.length > 0 ? Math.round(people.reduce((s, p) => s + p.healthScore, 0) / people.length) : 0}/100. Maintain regular contact cadence.`;
+}
+//#endregion
+//#region src/mcp/tools/get-org-intelligence.ts
+const DATA_DIR$26 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetOrgIntelligence(input, dataDir = DATA_DIR$26) {
+	try {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const map = buildStakeholderMap(dataDir, input.slug, today, input.dealName);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(map, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetOrgIntelligence(server) {
+	server.registerTool("get_org_intelligence", {
+		title: "Get Org Intelligence",
+		description: `Build a stakeholder map for a customer: champions, economic buyers, blockers, health scores, risk flags, and a prioritised recommendation.
+
+Returns: { slug, updatedAt, people: [{ name, email, role, healthScore, daysSinceContact, contactStrength, riskFlags }], missingRoles, riskAssessment, recommendation }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			dealName: z.string().optional().describe("Optional deal name to scope the analysis")
+		})
+	}, async ({ slug, dealName }) => handleGetOrgIntelligence(dealName ? {
+		slug,
+		dealName
+	} : { slug }));
+}
+//#endregion
+//#region src/agents/deal-room.ts
+async function buildDealRoom(dataDir, slug, dealName, today) {
+	const [pipelineDeals, simInput] = await Promise.all([readPipeline(dataDir, slug).catch(() => []), buildSimulationInput(dataDir, "quarter", today).catch(() => ({
+		deals: [],
+		externalSignals: [],
+		iterations: 1e3,
+		horizon: "quarter",
+		today
+	}))]);
+	const stakeholders = buildStakeholderMap(dataDir, slug, today, dealName);
+	const health = readHealth(dataDir, slug);
+	const simResult = runSimulation({
+		...simInput,
+		iterations: 1e3
+	});
+	const todayDate = new Date(today);
+	const dealHealth = pipelineDeals.filter((d) => d.stage !== "won" && d.stage !== "lost").map((deal) => {
+		const updatedDate = deal.updated ? new Date(deal.updated) : todayDate;
+		const daysSinceLastActivity = Math.floor((todayDate.getTime() - updatedDate.getTime()) / 864e5);
+		const daysToClose = deal.close_date ? Math.floor((new Date(deal.close_date).getTime() - todayDate.getTime()) / 864e5) : void 0;
+		const scored = scoreDeal(deal, {
+			daysSinceLastActivity,
+			daysInCurrentStage: daysSinceLastActivity,
+			...daysToClose !== void 0 ? { daysToClose } : {},
+			...deal.probability !== void 0 ? { probability: deal.probability } : {}
+		});
+		return {
+			deal: deal.name,
+			stage: deal.stage,
+			score: scored.score,
+			grade: scored.grade,
+			warnings: scored.warnings
+		};
+	});
+	const firstActiveDeal = pipelineDeals.find((d) => d.stage !== "won" && d.stage !== "lost");
+	let recommendedPlaybook = null;
+	if (firstActiveDeal) {
+		const championEmail = stakeholders.people.find((p) => p.role === "champion")?.email;
+		const daysSinceContact = ((championEmail ? health?.contacts.find((c) => c.email === championEmail || c.contactId === `person:${championEmail}`) : void 0) ?? health?.contacts?.[0])?.daysSinceContact ?? 999;
+		const dealSnapshot = {
+			slug,
+			name: firstActiveDeal.name,
+			stage: firstActiveDeal.stage,
+			value: firstActiveDeal.value ?? 0,
+			probability: firstActiveDeal.probability ?? 50,
+			healthScore: health?.overallHealth ?? 50,
+			daysSinceContact,
+			championPresent: stakeholders.people.some((p) => p.role === "champion")
+		};
+		recommendedPlaybook = matchPlaybooks(listPlaybooks(dataDir, slug), dealSnapshot, daysSinceContact)[0] ?? null;
+	}
+	const riskScore = computeRiskScore(stakeholders.missingRoles, dealHealth, health?.overallHealth ?? 100);
+	const topPriorities = buildTopPriorities(stakeholders, dealHealth);
+	const executiveSummary = buildExecutiveSummary(slug, dealName, stakeholders, health?.overallHealth ?? 100, simResult, riskScore);
+	return {
+		slug,
+		dealName,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		stakeholders,
+		relationshipHealth: health?.contacts ?? [],
+		dealHealth,
+		revenueSimulation: {
+			p50: simResult.p50,
+			p10: simResult.p10,
+			p90: simResult.p90,
+			expected: simResult.expected,
+			atRiskRevenue: simResult.atRiskRevenue
+		},
+		recommendedPlaybook,
+		executiveSummary,
+		topPriorities,
+		riskScore
+	};
+}
+function computeRiskScore(missingRoles, dealHealth, overallHealth) {
+	let risk = 0;
+	for (const mr of missingRoles) risk += mr.urgency === "critical" ? 25 : 10;
+	const avgDealScore = dealHealth.length > 0 ? dealHealth.reduce((s, d) => s + d.score, 0) / dealHealth.length : 100;
+	risk += Math.round((100 - avgDealScore) * .3);
+	risk += Math.round((100 - overallHealth) * .2);
+	return Math.min(100, Math.max(0, risk));
+}
+function buildTopPriorities(stakeholders, dealHealth) {
+	const priorities = [];
+	for (const mr of stakeholders.missingRoles) if (mr.urgency === "critical") priorities.push(mr.suggestion);
+	const coldPeople = stakeholders.people.filter((p) => p.riskFlags.includes("NO_CONTACT_30D"));
+	if (coldPeople.length > 0) priorities.push(`Re-engage ${coldPeople.map((p) => p.name).join(", ")} — silent 30+ days.`);
+	const atRiskDeals = dealHealth.filter((d) => d.score < 50);
+	const showCount = Math.min(3, atRiskDeals.length);
+	for (const d of atRiskDeals.slice(0, showCount)) priorities.push(`Rescue deal "${d.deal}" (health ${d.score}/100): ${d.warnings[0] ?? "at risk"}`);
+	if (atRiskDeals.length > showCount) priorities.push(`+${atRiskDeals.length - showCount} more at-risk deal(s) need attention.`);
+	for (const mr of stakeholders.missingRoles) if (mr.urgency === "important") priorities.push(mr.suggestion);
+	if (priorities.length === 0) priorities.push("Maintain current momentum — schedule next check-in.");
+	return priorities;
+}
+function buildExecutiveSummary(slug, dealName, stakeholders, overallHealth, sim, riskScore) {
+	const champCount = stakeholders.people.filter((p) => p.role === "champion").length;
+	const missingCritical = stakeholders.missingRoles.filter((r) => r.urgency === "critical").length;
+	const parts = [];
+	parts.push(`${slug}/${dealName}: relationship health ${overallHealth}/100, ${champCount} champion(s) identified.`);
+	if (sim.p50 > 0) parts.push(`Pipeline P50 forecast: €${(sim.p50 / 1e3).toFixed(1)}k.`);
+	if (missingCritical > 0) parts.push(`Critical gaps: ${missingCritical} key role(s) unidentified — risk score ${riskScore}/100.`);
+	else parts.push(`Overall risk score: ${riskScore}/100.`);
+	return parts.join(" ");
+}
+//#endregion
+//#region src/mcp/tools/open-deal-room.ts
+const DATA_DIR$25 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleOpenDealRoom(input, dataDir = DATA_DIR$25) {
+	try {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const brief = await buildDealRoom(dataDir, input.slug, input.dealName, today);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(brief, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerOpenDealRoom(server) {
+	server.registerTool("open_deal_room", {
+		title: "Open Deal Room",
+		description: `Multi-agent deal brief: orchestrates relationship graph, health scores, deal health, revenue simulation, and playbook matching into a unified deal-room brief with executive summary, top priorities, and risk score (0–100).
+
+Returns: { slug, dealName, generatedAt, stakeholders, relationshipHealth, dealHealth, revenueSimulation, recommendedPlaybook, executiveSummary, topPriorities, riskScore }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			dealName: z.string().describe("Name of the deal to analyse")
+		})
+	}, async ({ slug, dealName }) => handleOpenDealRoom({
+		slug,
+		dealName
+	}));
+}
+//#endregion
+//#region src/mcp/tools/get-proactive-briefing.ts
+const DATA_DIR$24 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetProactiveBriefing(input, dataDir = DATA_DIR$24) {
+	try {
+		const briefing = await buildDailyBriefing(dataDir, input.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10));
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(briefing, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				success: false,
+				error: err.message
+			}, null, 2)
+		}] };
+	}
+}
+function registerGetProactiveBriefing(server) {
+	server.registerTool("get_proactive_briefing", {
+		title: "Get Proactive Briefing",
+		description: `Generate a proactive daily briefing: urgent alerts (relationship decay, deal risk, overdue close dates), pipeline forecast (P50/P90), and a single top-action recommendation.
+
+Returns: { date, generatedAt, urgent: string[], opportunities: string[], forecast: string, topAction: string }`,
+		inputSchema: z.object({ date: z.string().optional().describe("ISO date (YYYY-MM-DD). Defaults to today.") })
+	}, async ({ date }) => handleGetProactiveBriefing(date ? { date } : {}));
+}
+//#endregion
+//#region src/mcp/tools/list-email-templates.ts
+const DATA_DIR$23 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListEmailTemplates(input, dataDir = DATA_DIR$23) {
+	const summary = listTemplates(dataDir, input.category ? { category: input.category } : {}).map(({ body: _body, ...meta }) => meta);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(summary, null, 2)
+	}] };
+}
+function registerListEmailTemplates(server, dataDir = DATA_DIR$23) {
+	server.registerTool("list_email_templates", {
+		description: "List available email templates. Optionally filter by category (e.g. 'outreach', 'followup', 'support').",
+		inputSchema: z.object({ category: z.string().optional().describe("Filter by category") })
+	}, ({ category }) => handleListEmailTemplates(category ? { category } : {}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/get-email-template.ts
+const DATA_DIR$22 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetEmailTemplate(input, dataDir = DATA_DIR$22) {
+	const tmpl = getTemplate(dataDir, input.id);
+	if (!tmpl) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Template '${input.id}' not found` })
+	}] };
+	const allVars = extractVariables(`${tmpl.subject}\n${tmpl.body}`);
+	const unique = [...new Set(allVars)];
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			...tmpl,
+			detectedVariables: unique
+		}, null, 2)
+	}] };
+}
+function registerGetEmailTemplate(server, dataDir = DATA_DIR$22) {
+	server.registerTool("get_email_template", {
+		description: "Get a specific email template by ID, including its body and detected variables.",
+		inputSchema: z.object({ id: z.string().describe("Template ID (e.g. 'enterprise-intro')") })
+	}, ({ id }) => handleGetEmailTemplate({ id }, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/draft-email.ts
+const DATA_DIR$21 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleDraftEmail(input, dataDir = DATA_DIR$21) {
+	const tmpl = getTemplate(dataDir, input.templateId);
+	if (!tmpl) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Template '${input.templateId}' not found` })
+	}] };
+	const vars = {
+		...await buildVariablesFromCustomer(dataDir, input.slug),
+		...input.overrides ?? {}
+	};
+	const subject = interpolate(tmpl.subject, vars);
+	const interpolatedBody = interpolate(tmpl.body, vars);
+	let effectiveTone = input.tone;
+	if (!effectiveTone) {
+		const { resolveTone, toneInstruction } = await import("./tone-Bdm5uaht.js");
+		const instr = toneInstruction(resolveTone(dataDir, input.slug));
+		if (instr) effectiveTone = instr;
+	}
+	let body = interpolatedBody;
+	let polished = false;
+	if (effectiveTone) try {
+		const { callLlm } = await import("./llm-DEjWcqmW.js");
+		const refined = await callLlm(`Rewrite the following email in a ${effectiveTone} tone. Keep the same language, preserve all names and facts, and do not invent details. Return ONLY the rewritten email body, no preamble.\n\n---\n${interpolatedBody}`);
+		if (refined && refined.trim()) {
+			const { labelAiContent } = await import("./compliance-CujOqAKk.js");
+			body = labelAiContent(refined.trim());
+			polished = true;
+		}
+	} catch {}
+	const to = (await readMainFacts(dataDir, input.slug).catch(() => null))?.email ?? "";
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			subject,
+			body,
+			to,
+			slug: input.slug,
+			templateId: input.templateId,
+			tone: effectiveTone ?? null,
+			polished,
+			resolvedVariables: vars
+		}, null, 2)
+	}] };
+}
+function registerDraftEmail(server, dataDir = DATA_DIR$21) {
+	server.registerTool("draft_email", {
+		description: `Draft a personalized email for a customer using a stored template.
+Variables are auto-filled from the customer's main_facts.md. Override any variable manually.
+Optionally pass a tone (e.g. "formal", "friendly", "concise") to LLM-polish the body —
+falls back to plain template-fill when no ANTHROPIC_API_KEY is configured.
+Returns: { subject, body, to, tone, polished, resolvedVariables } — does NOT send automatically.`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			templateId: z.string().describe("Template ID to use"),
+			overrides: z.record(z.string()).optional().describe("Override any template variable (e.g. {firstName: 'Alice'})"),
+			tone: z.string().optional().describe("Optional tone to LLM-polish the body (e.g. 'formal', 'friendly', 'concise')")
+		})
+	}, ({ slug, templateId, overrides, tone }) => handleDraftEmail({
+		slug,
+		templateId,
+		...overrides !== void 0 ? { overrides } : {},
+		...tone !== void 0 ? { tone } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/enroll-in-sequence.ts
+const DATA_DIR$20 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleEnrollInSequence(input, dataDir = DATA_DIR$20) {
+	const sequence = getSequence(dataDir, input.sequenceId);
+	if (!sequence) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Sequence '${input.sequenceId}' not found` })
+	}] };
+	const firstStep = sequence.steps[0];
+	if (!getTemplate(dataDir, firstStep.templateId)) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Template '${firstStep.templateId}' for step 0 not found` })
+	}] };
+	const enrollmentId = `enroll_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await writeEnrollment(dataDir, {
+		id: enrollmentId,
+		sequenceId: input.sequenceId,
+		slug: input.slug,
+		contactEmail: input.contactEmail,
+		enrolledAt: now,
+		status: "active",
+		currentStep: 0,
+		stepsCompleted: []
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			enrollmentId,
+			sequenceName: sequence.name,
+			totalSteps: sequence.steps.length
+		})
+	}] };
+}
+function registerEnrollInSequence(server, dataDir = DATA_DIR$20) {
+	server.registerTool("enroll_in_sequence", {
+		description: `Enroll a contact in an email sequence. Validates that the sequence and its first template exist.
+Returns: { enrollmentId, sequenceName, totalSteps }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			contactEmail: z.string().email().describe("Email address of the contact to enroll"),
+			sequenceId: z.string().describe("ID of the sequence to enroll in")
+		})
+	}, ({ slug, contactEmail, sequenceId }) => handleEnrollInSequence({
+		slug,
+		contactEmail,
+		sequenceId
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/list-sequence-enrollments.ts
+const DATA_DIR$19 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListSequenceEnrollments(input, dataDir = DATA_DIR$19) {
+	let enrollments = readEnrollments(dataDir);
+	if (input.slug !== void 0) enrollments = enrollments.filter((e) => e.slug === input.slug);
+	if (input.status !== void 0) enrollments = enrollments.filter((e) => e.status === input.status);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ enrollments }, null, 2)
+	}] };
+}
+function registerListSequenceEnrollments(server, dataDir = DATA_DIR$19) {
+	server.registerTool("list_sequence_enrollments", {
+		description: `List email sequence enrollments. Filter by customer slug or status.
+Returns: { enrollments: SequenceEnrollment[] }`,
+		inputSchema: z.object({
+			slug: z.string().optional().describe("Filter by customer slug"),
+			status: z.enum([
+				"active",
+				"paused",
+				"completed"
+			]).optional().describe("Filter by enrollment status")
+		})
+	}, ({ slug, status }) => handleListSequenceEnrollments({
+		...slug !== void 0 ? { slug } : {},
+		...status !== void 0 ? { status } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/unenroll-from-sequence.ts
+const DATA_DIR$18 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleUnenrollFromSequence(input, dataDir = DATA_DIR$18) {
+	if (!await updateEnrollment(dataDir, input.enrollmentId, { status: "paused" })) return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			success: false,
+			error: `Enrollment '${input.enrollmentId}' not found`
+		})
+	}] };
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ success: true })
+	}] };
+}
+function registerUnenrollFromSequence(server, dataDir = DATA_DIR$18) {
+	server.registerTool("unenroll_from_sequence", {
+		description: `Unenroll (pause) a contact from an email sequence. Sets status to "paused" (soft delete).
+Returns: { success: boolean }`,
+		inputSchema: z.object({ enrollmentId: z.string().describe("ID of the enrollment to pause") })
+	}, ({ enrollmentId }) => handleUnenrollFromSequence({ enrollmentId }, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/list-sequences.ts
+const DATA_DIR$17 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListSequences(_input, dataDir = DATA_DIR$17) {
+	const sequences = listSequences(dataDir);
+	const enrollments = readEnrollments(dataDir);
+	const result = sequences.map((seq) => ({
+		id: seq.id,
+		name: seq.name,
+		stepCount: seq.steps.length,
+		enrollmentCount: enrollments.filter((e) => e.sequenceId === seq.id).length
+	}));
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ sequences: result }, null, 2)
+	}] };
+}
+function registerListSequences(server, dataDir = DATA_DIR$17) {
+	server.registerTool("list_sequences", {
+		description: `List all email sequences with step count and enrollment count.
+Returns: { sequences: Array<{ id, name, stepCount, enrollmentCount }> }`,
+		inputSchema: z.object({})
+	}, () => handleListSequences({}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/generate-quote.ts
+const DATA_DIR$16 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGenerateQuote(input, dataDir = DATA_DIR$16) {
+	try {
+		const quote = await generateQuote(dataDir, input);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				quoteNumber: quote.quoteNumber,
+				htmlPath: quote.htmlPath,
+				total: quote.total,
+				subtotal: quote.subtotal,
+				vat: quote.vat,
+				vatPercent: quote.vatPercent,
+				currency: quote.currency,
+				validUntil: quote.validUntil,
+				status: quote.status
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: err.message })
+		}] };
+	}
+}
+function registerGenerateQuote(server, dataDir = DATA_DIR$16) {
+	server.registerTool("generate_quote", {
+		description: `Generate a professional HTML quote/offer for a customer deal.
+Calculates subtotal, VAT, and total. Saves JSON + HTML to .agentic/quotes/.
+Returns: { quoteNumber, htmlPath, total, currency, validUntil }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			dealName: z.string().describe("Name of the deal this quote is for"),
+			lineItems: z.array(z.object({
+				description: z.string(),
+				quantity: z.number().positive(),
+				unitPrice: z.number().min(0)
+			})).min(1).describe("Line items for the quote"),
+			vatPercent: z.number().min(0).max(100).optional().describe("VAT percentage (default 19)"),
+			validUntilDays: z.number().int().positive().optional().describe("Quote validity in days (default 30)"),
+			currency: z.string().optional().describe("Currency code (default EUR)")
+		})
+	}, ({ slug, dealName, lineItems, vatPercent, validUntilDays, currency }) => handleGenerateQuote({
+		slug,
+		dealName,
+		lineItems,
+		...vatPercent !== void 0 ? { vatPercent } : {},
+		...validUntilDays !== void 0 ? { validUntilDays } : {},
+		...currency !== void 0 ? { currency } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/get-quote-status.ts
+const DATA_DIR$15 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetQuoteStatus(input, dataDir = DATA_DIR$15) {
+	if (input.quoteNumber) {
+		const quote = readQuote(dataDir, input.quoteNumber);
+		if (!quote) return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: `Quote '${input.quoteNumber}' not found` })
+		}] };
+		return { content: [{
+			type: "text",
+			text: JSON.stringify(quote, null, 2)
+		}] };
+	}
+	const quotes = listQuotes(dataDir, input.slug);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ quotes }, null, 2)
+	}] };
+}
+function registerGetQuoteStatus(server, dataDir = DATA_DIR$15) {
+	server.registerTool("get_quote_status", {
+		description: `Get quote status and details. Filter by quoteNumber (single quote) or slug (all quotes for a customer).
+Returns quote with status: draft | sent | viewed | accepted | declined`,
+		inputSchema: z.object({
+			quoteNumber: z.string().optional().describe("Specific quote number (e.g. Q-2026-001)"),
+			slug: z.string().optional().describe("Customer slug to list all quotes for")
+		})
+	}, ({ quoteNumber, slug }) => handleGetQuoteStatus({
+		...quoteNumber !== void 0 ? { quoteNumber } : {},
+		...slug !== void 0 ? { slug } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/get-booking-link.ts
+const DATA_DIR$14 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+function loadCalendlyConfig(dataDir) {
+	const p = path.join(dataDir, ".agentic", "integrations", "calendly.yaml");
+	if (!fs.existsSync(p)) return {};
+	try {
+		return yaml.load(fs.readFileSync(p, "utf-8")) ?? {};
+	} catch {
+		return {};
+	}
+}
+function readCustomerFacts(dataDir, slug) {
+	const p = path.join(dataDir, "customers", slug, "main_facts.md");
+	if (!fs.existsSync(p)) return {};
+	const content = fs.readFileSync(p, "utf-8");
+	const nameMatch = /^name:\s*(.+)$/m.exec(content);
+	const emailMatch = /^email:\s*(.+)$/m.exec(content);
+	const name = nameMatch?.[1]?.trim();
+	const email = emailMatch?.[1]?.trim();
+	return {
+		...name ? { name } : {},
+		...email ? { email } : {}
+	};
+}
+async function handleGetBookingLink(input, dataDir = DATA_DIR$14) {
+	const config = loadCalendlyConfig(dataDir);
+	const apiKey = config.apiKey ?? process.env["CALENDLY_API_KEY"] ?? "";
+	if (!apiKey) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: "Calendly API key not configured. Set CALENDLY_API_KEY env var or configure .agentic/integrations/calendly.yaml" })
+	}] };
+	const eventTypeSlug = input.eventType ?? config.defaultEventType ?? "30min";
+	try {
+		const { getSchedulingLink, listEventTypes } = await import("./calendly-Bft_wwji.js");
+		const bookingUrl = await getSchedulingLink(apiKey, eventTypeSlug, input.prefillName ? readCustomerFacts(dataDir, input.slug) : void 0);
+		const eventType = (await listEventTypes(apiKey)).find((et) => et.slug === eventTypeSlug || et.name.toLowerCase().includes(eventTypeSlug.toLowerCase()));
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				bookingUrl,
+				eventType: eventType?.name ?? eventTypeSlug,
+				duration: eventType?.duration ?? 30,
+				slug: input.slug
+			}, null, 2)
+		}] };
+	} catch (err) {
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: err.message })
+		}] };
+	}
+}
+function registerGetBookingLink(server, dataDir = DATA_DIR$14) {
+	server.registerTool("get_booking_link", {
+		description: `Get a Calendly booking link for a customer. Optionally pre-fills the customer's name/email.
+Requires CALENDLY_API_KEY env var or .agentic/integrations/calendly.yaml config.
+Returns: { bookingUrl, eventType, duration }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			eventType: z.string().optional().describe("Calendly event type slug (e.g. '30min', '60min'). Uses default if not specified."),
+			prefillName: z.boolean().optional().describe("Pre-fill customer name and email in the booking link")
+		})
+	}, ({ slug, eventType, prefillName }) => handleGetBookingLink({
+		slug,
+		...eventType !== void 0 ? { eventType } : {},
+		...prefillName !== void 0 ? { prefillName } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/create-ticket.ts
+const DATA_DIR$13 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleCreateTicket(input, dataDir = DATA_DIR$13) {
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const rules = loadSlaRules(dataDir);
+	const priority = input.priority ?? "normal";
+	const id = nextTicketId(await readTickets(dataDir, input.slug));
+	const slaDue = calcSlaDue(today, priority, rules);
+	const ticket = {
+		id,
+		title: input.title,
+		status: "open",
+		priority,
+		...input.assignee ? { assignee: input.assignee } : {},
+		created: today,
+		slaDue,
+		...input.description ? { description: input.description } : {}
+	};
+	await upsertTicket(dataDir, input.slug, ticket);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ ticket }, null, 2)
+	}] };
+}
+function registerCreateTicket(server, dataDir = DATA_DIR$13) {
+	server.registerTool("create_ticket", {
+		description: `Create a support ticket for a customer. Auto-calculates SLA due date based on priority.
+Returns: { ticket } with id T-NNN, status=open, slaDue`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			title: z.string().min(1).describe("Ticket title"),
+			description: z.string().optional().describe("Detailed description"),
+			priority: z.enum([
+				"urgent",
+				"high",
+				"normal",
+				"low"
+			]).optional().describe("Priority (default: normal)"),
+			assignee: z.string().optional().describe("Assignee name or email")
+		})
+	}, ({ slug, title, description, priority, assignee }) => handleCreateTicket({
+		slug,
+		title,
+		...description !== void 0 ? { description } : {},
+		...priority !== void 0 ? { priority } : {},
+		...assignee !== void 0 ? { assignee } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/update-ticket.ts
+const DATA_DIR$12 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleUpdateTicket(input, dataDir = DATA_DIR$12) {
+	const ticket = (await readTickets(dataDir, input.slug)).find((t) => t.id === input.ticketId);
+	if (!ticket) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Ticket '${input.ticketId}' not found for customer '${input.slug}'` })
+	}] };
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const updated = {
+		...ticket,
+		...input.status ? { status: input.status } : {},
+		...input.assignee !== void 0 ? { assignee: input.assignee } : {},
+		...input.status === "resolved" && !ticket.resolved ? { resolved: today } : {}
+	};
+	await upsertTicket(dataDir, input.slug, updated);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ ticket: updated }, null, 2)
+	}] };
+}
+function registerUpdateTicket(server, dataDir = DATA_DIR$12) {
+	server.registerTool("update_ticket", {
+		description: `Update a ticket's status or assignee. Setting status=resolved auto-sets resolved date.
+Returns: { ticket }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			ticketId: z.string().describe("Ticket ID (e.g. T-001)"),
+			status: z.enum([
+				"open",
+				"in-progress",
+				"waiting",
+				"resolved",
+				"closed"
+			]).optional(),
+			assignee: z.string().optional().describe("New assignee")
+		})
+	}, ({ slug, ticketId, status, assignee }) => handleUpdateTicket({
+		slug,
+		ticketId,
+		...status !== void 0 ? { status } : {},
+		...assignee !== void 0 ? { assignee } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/list-tickets.ts
+const DATA_DIR$11 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListTickets(input, dataDir = DATA_DIR$11) {
+	const results = await listAllTickets(dataDir, {
+		...input.slug !== void 0 ? { slug: input.slug } : {},
+		...input.status !== void 0 ? { status: input.status } : {},
+		...input.priority !== void 0 ? { priority: input.priority } : {},
+		...input.assignee !== void 0 ? { assignee: input.assignee } : {}
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ tickets: results }, null, 2)
+	}] };
+}
+function registerListTickets(server, dataDir = DATA_DIR$11) {
+	server.registerTool("list_tickets", {
+		description: `List support tickets. Filter by customer, status, priority, or assignee. Sorted by priority then date.
+Returns: { tickets: Array<{ slug, ticket }> }`,
+		inputSchema: z.object({
+			slug: z.string().optional().describe("Filter by customer slug"),
+			status: z.enum([
+				"open",
+				"in-progress",
+				"waiting",
+				"resolved",
+				"closed"
+			]).optional(),
+			priority: z.enum([
+				"urgent",
+				"high",
+				"normal",
+				"low"
+			]).optional(),
+			assignee: z.string().optional().describe("Filter by assignee")
+		})
+	}, ({ slug, status, priority, assignee }) => handleListTickets({
+		...slug !== void 0 ? { slug } : {},
+		...status !== void 0 ? { status } : {},
+		...priority !== void 0 ? { priority } : {},
+		...assignee !== void 0 ? { assignee } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/close-ticket.ts
+const DATA_DIR$10 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleCloseTicket(input, dataDir = DATA_DIR$10) {
+	const ticket = (await readTickets(dataDir, input.slug)).find((t) => t.id === input.ticketId);
+	if (!ticket) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Ticket '${input.ticketId}' not found for '${input.slug}'` })
+	}] };
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const updated = {
+		...ticket,
+		status: "closed",
+		resolved: ticket.resolved ?? today
+	};
+	await upsertTicket(dataDir, input.slug, updated);
+	if (input.resolution) await appendInteraction(dataDir, input.slug, {
+		date: today,
+		type: "Note",
+		with: input.slug,
+		summary: `Ticket ${input.ticketId} closed: ${input.resolution}`,
+		nextSteps: [],
+		sourceRef: `ticket://${input.ticketId}/close`,
+		synced: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({ ticket: updated }, null, 2)
+	}] };
+}
+function registerCloseTicket(server, dataDir = DATA_DIR$10) {
+	server.registerTool("close_ticket", {
+		description: `Close a support ticket. Optionally logs the resolution as an interaction.
+Returns: { ticket } with status=closed`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			ticketId: z.string().describe("Ticket ID (e.g. T-001)"),
+			resolution: z.string().optional().describe("Resolution notes (logged as interaction)")
+		})
+	}, ({ slug, ticketId, resolution }) => handleCloseTicket({
+		slug,
+		ticketId,
+		...resolution !== void 0 ? { resolution } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/send-nps-survey.ts
+const DATA_DIR$9 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleSendNpsSurvey(input, dataDir = DATA_DIR$9) {
+	const survey = getSurvey(dataDir, input.surveyId);
+	if (!survey) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Survey '${input.surveyId}' not found` })
+	}] };
+	const serverUrl = input.serverUrl ?? process.env["DXCRM_SERVER_URL"] ?? "http://localhost:3456";
+	const token = generateSurveyToken(input.slug, input.contactEmail, input.surveyId);
+	const email = buildSurveyEmail(survey, serverUrl, token);
+	await savePendingSurvey(dataDir, input.surveyId, input.slug, input.contactEmail, token);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			token,
+			subject: email.subject,
+			body: email.body,
+			surveyUrl: `${serverUrl}/survey/respond?token=${token}`,
+			note: "Email draft ready. Use draft_email or Gmail to send."
+		}, null, 2)
+	}] };
+}
+function registerSendNpsSurvey(server, dataDir = DATA_DIR$9) {
+	server.registerTool("send_nps_survey", {
+		description: `Generate an NPS/CSAT survey email for a customer contact. Returns subject, HTML body, and a token-based response URL.
+Does NOT send automatically — returns draft for review.
+Returns: { token, subject, body, surveyUrl }`,
+		inputSchema: z.object({
+			slug: z.string().describe("Customer slug"),
+			contactEmail: z.string().email().describe("Contact email to send survey to"),
+			surveyId: z.string().describe("Survey definition ID from .agentic/surveys/"),
+			serverUrl: z.string().optional().describe("Server URL for response links (default: DXCRM_SERVER_URL env var or localhost:3456)")
+		})
+	}, ({ slug, contactEmail, surveyId, serverUrl }) => handleSendNpsSurvey({
+		slug,
+		contactEmail,
+		surveyId,
+		...serverUrl !== void 0 ? { serverUrl } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/get-survey-results.ts
+const DATA_DIR$8 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleGetSurveyResults(input, dataDir = DATA_DIR$8) {
+	const responses = loadSurveyResponses(dataDir, input.surveyId, input.slug);
+	const nps = calcNpsScore(responses);
+	const promoters = responses.filter((r) => r.score >= 9).length;
+	const passives = responses.filter((r) => r.score >= 7 && r.score <= 8).length;
+	const detractors = responses.filter((r) => r.score <= 6).length;
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			surveyId: input.surveyId,
+			...input.slug ? { slug: input.slug } : {},
+			totalResponses: responses.length,
+			npsScore: nps,
+			promoters,
+			passives,
+			detractors,
+			responses: responses.map((r) => ({
+				slug: r.slug,
+				email: r.contactEmail,
+				score: r.score,
+				...r.comment ? { comment: r.comment } : {},
+				respondedAt: r.respondedAt
+			}))
+		}, null, 2)
+	}] };
+}
+function registerGetSurveyResults(server, dataDir = DATA_DIR$8) {
+	server.registerTool("get_survey_results", {
+		description: `Get NPS/CSAT survey results with score breakdown. Calculates Net Promoter Score.
+Returns: { npsScore, totalResponses, promoters, passives, detractors, responses[] }`,
+		inputSchema: z.object({
+			surveyId: z.string().describe("Survey ID"),
+			slug: z.string().optional().describe("Filter results to a specific customer")
+		})
+	}, ({ surveyId, slug }) => handleGetSurveyResults({
+		surveyId,
+		...slug !== void 0 ? { slug } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/search-knowledge-base.ts
+const DATA_DIR$7 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleSearchKnowledgeBase(input, dataDir = DATA_DIR$7) {
+	const results = searchKbSimple(dataDir, input.query, { ...input.publicOnly ? { publicOnly: true } : {} });
+	const limited = (input.category ? results.filter((a) => a.category === input.category) : results).slice(0, input.limit ?? 10);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			query: input.query,
+			count: limited.length,
+			articles: limited.map((a) => ({
+				...getKbMetaForExport(a),
+				excerpt: a.body.slice(0, 300).trim()
+			}))
+		}, null, 2)
+	}] };
+}
+function registerSearchKnowledgeBase(server, dataDir = DATA_DIR$7) {
+	server.registerTool("search_knowledge_base", {
+		description: `Search the knowledge base for articles. Text search on title, body, and tags.
+Returns: { count, articles[] } with excerpts`,
+		inputSchema: z.object({
+			query: z.string().describe("Search query"),
+			category: z.string().optional().describe("Filter by category (e.g. 'troubleshooting', 'howto')"),
+			publicOnly: z.boolean().optional().describe("Only return public articles"),
+			limit: z.number().int().positive().optional().describe("Max results (default 10)")
+		})
+	}, ({ query, category, publicOnly, limit }) => handleSearchKnowledgeBase({
+		query,
+		...category !== void 0 ? { category } : {},
+		...publicOnly !== void 0 ? { publicOnly } : {},
+		...limit !== void 0 ? { limit } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/create-kb-article.ts
+const DATA_DIR$6 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleCreateKbArticle(input, dataDir = DATA_DIR$6) {
+	if (getKbArticle(dataDir, input.id)) return { content: [{
+		type: "text",
+		text: JSON.stringify({ error: `Article '${input.id}' already exists` })
+	}] };
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const article = {
+		id: input.id,
+		title: input.title,
+		body: input.body,
+		category: input.category ?? "general",
+		tags: input.tags ?? [],
+		public: input.public ?? false,
+		createdAt: now,
+		updatedAt: now,
+		...input.sourceTicketId ? { sourceTicketId: input.sourceTicketId } : {}
+	};
+	writeKbArticle(dataDir, article);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			id: article.id,
+			title: article.title,
+			category: article.category,
+			path: `.agentic/knowledge-base/${article.category}/${article.id}.md`
+		}, null, 2)
+	}] };
+}
+function registerCreateKbArticle(server, dataDir = DATA_DIR$6) {
+	server.registerTool("create_kb_article", {
+		description: `Create a new knowledge base article. Articles are stored as Markdown files in .agentic/knowledge-base/.
+Returns: { id, title, category, path }`,
+		inputSchema: z.object({
+			id: z.string().min(1).describe("Article ID (slug, e.g. 'troubleshoot-api-timeout')"),
+			title: z.string().min(1).describe("Article title"),
+			body: z.string().min(1).describe("Article body in Markdown"),
+			category: z.string().optional().describe("Category (default: 'general')"),
+			tags: z.array(z.string()).optional().describe("Tags for search"),
+			public: z.boolean().optional().describe("Make article publicly accessible (default: false)"),
+			sourceTicketId: z.string().optional().describe("Ticket ID this article was created from")
+		})
+	}, ({ id, title, body, category, tags, public: pub, sourceTicketId }) => handleCreateKbArticle({
+		id,
+		title,
+		body,
+		...category !== void 0 ? { category } : {},
+		...tags !== void 0 ? { tags } : {},
+		...pub !== void 0 ? { public: pub } : {},
+		...sourceTicketId !== void 0 ? { sourceTicketId } : {}
+	}, dataDir));
+}
+//#endregion
+//#region src/mcp/tools/backup-now.ts
+const DATA_DIR$5 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleBackupNow(input, dataDir = DATA_DIR$5) {
+	const zipPath = path.join(dataDir, `dxcrm-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}.zip`);
+	const manifest = await runBackup(zipPath, dataDir, { ...input.remote ? { remote: input.remote } : {} }).catch(() => null);
+	if (!manifest) return { content: [{
+		type: "text",
+		text: "Backup failed. Check disk space and permissions."
+	}] };
+	const sizeMb = fs.existsSync(zipPath) ? (fs.statSync(zipPath).size / 1024 / 1024).toFixed(1) : "?";
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			path: zipPath,
+			createdAt: manifest.createdAt,
+			customerCount: manifest.customerCount,
+			fileCount: manifest.fileCount,
+			sizeMb: `${sizeMb} MB`,
+			directories: manifest.directories,
+			verified: true,
+			...input.remote ? { uploadedTo: input.remote } : {},
+			...input.note ? { note: input.note } : {}
+		}, null, 2)
+	}] };
+}
+function registerBackupNow(server) {
+	server.registerTool("backup_now", {
+		description: "Trigger an immediate backup of all CRM data (customers/ + .agentic/). Returns backup path, size, and integrity status. Use before risky operations or on user request.",
+		inputSchema: z.object({
+			remote: z.string().optional().describe("Upload destination: s3://bucket/path/, rsync://user@host:/path/, or local directory"),
+			note: z.string().optional().describe("Optional note to tag this backup")
+		})
+	}, ({ remote, note }) => handleBackupNow({
+		...remote !== void 0 ? { remote } : {},
+		...note !== void 0 ? { note } : {}
+	}));
+}
+//#endregion
+//#region src/mcp/tools/list-backups.ts
+const DATA_DIR$4 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+async function handleListBackups(input, dataDir = DATA_DIR$4) {
+	const logEntries = readBackupLog(dataDir);
+	const fileEntries = listBackupsInDir(dataDir);
+	const entries = logEntries.length > 0 ? logEntries : fileEntries;
+	const limited = entries.slice(0, input.limit);
+	if (limited.length === 0) return { content: [{
+		type: "text",
+		text: "No backups found. Run backup_now to create one."
+	}] };
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			count: limited.length,
+			totalAvailable: entries.length,
+			backups: limited.map((e) => ({
+				filename: e.filename,
+				createdAt: e.createdAt,
+				sizeMb: e.sizeBytes > 0 ? `${(e.sizeBytes / 1024 / 1024).toFixed(1)} MB` : "unknown",
+				verified: e.verified,
+				encrypted: e.encrypted,
+				customerCount: e.customerCount,
+				fileCount: e.fileCount
+			}))
+		}, null, 2)
+	}] };
+}
+function registerListBackups(server) {
+	server.registerTool("list_backups", {
+		description: "List available CRM backups with metadata (date, size, verification status, customer count). Shows log-tracked backups first, falls back to directory scan.",
+		inputSchema: z.object({ limit: z.number().int().min(1).max(50).default(10).describe("Maximum number of backups to return") })
+	}, (input) => handleListBackups(input));
+}
+//#endregion
+//#region src/mcp/tools/trigger-sync.ts
+const DATA_DIR$3 = process.cwd();
+async function handleTriggerSync(input, dataDir = DATA_DIR$3) {
+	const auth = getGmailAuth();
+	if (!auth) return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			success: false,
+			error: "Gmail auth not configured. Run `dxcrm sync gmail --init` first."
+		})
+	}] };
+	const customersDir = path.join(dataDir, "customers");
+	if (!fs.existsSync(customersDir)) return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			success: true,
+			synced: 0,
+			skipped: 0,
+			customers: []
+		})
+	}] };
+	const slugs = input.slug ? [input.slug] : fs.readdirSync(customersDir).filter((s) => {
+		try {
+			return fs.statSync(path.join(customersDir, s)).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+	const sinceDate = input.since ? new Date(input.since) : /* @__PURE__ */ new Date(Date.now() - 1440 * 60 * 1e3);
+	const results = [];
+	const errors = [];
+	for (const slug of slugs) {
+		const sourcesPath = path.join(customersDir, slug, "sources.json");
+		if (!fs.existsSync(sourcesPath)) continue;
+		try {
+			const sources = JSON.parse(fs.readFileSync(sourcesPath, "utf-8"));
+			if (!sources.gmail?.enabled || !sources.gmail.query) continue;
+			const { syncGmail } = await import("./gmail-sync-DIaxInDT.js");
+			const result = await syncGmail({
+				slug,
+				dataDir,
+				auth,
+				query: sources.gmail.query,
+				since: sinceDate
+			});
+			updateSlugSyncState(dataDir, slug, { lastGmailSync: (/* @__PURE__ */ new Date()).toISOString() });
+			results.push({
+				slug,
+				...result
+			});
+		} catch (err) {
+			errors.push(`${slug}: ${err.message}`);
+		}
+	}
+	const total = results.reduce((acc, r) => ({
+		synced: acc.synced + r.synced,
+		skipped: acc.skipped + r.skipped
+	}), {
+		synced: 0,
+		skipped: 0
+	});
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			success: true,
+			...total,
+			customers: results,
+			errors
+		}, null, 2)
+	}] };
+}
+function registerTriggerSync(server) {
+	server.registerTool("trigger_sync", {
+		title: "Trigger Sync",
+		description: `Immediately trigger a Gmail sync for one or all customers.
+Use when you need fresh email data before answering a question.
+The background daemon syncs every 30 minutes automatically — this forces an immediate sync.
+
+Args:
+  slug: Customer slug to sync (leave empty to sync all customers)
+  since: ISO date string — only fetch emails since this date (default: last 24 hours)
+
+Returns: { success: boolean, synced: number, skipped: number, customers: [...], errors: [...] }`,
+		inputSchema: z.object({
+			slug: z.string().optional().describe("Customer slug to sync (empty = all customers)"),
+			since: z.string().optional().describe("Sync emails since this ISO date (default: last 24h)")
+		})
+	}, async ({ slug, since }) => {
+		const input = {};
+		if (slug !== void 0) input.slug = slug;
+		if (since !== void 0) input.since = since;
+		return handleTriggerSync(input);
+	});
+}
+//#endregion
+//#region src/mcp/tools/get-audit-log.ts
+const DATA_DIR$2 = process.cwd();
+async function handleGetAuditLog(input, dataDir = DATA_DIR$2) {
+	const entries = readAuditLog(dataDir);
+	const filterOpts = { limit: input.limit ?? 50 };
+	if (input.slug !== void 0) filterOpts.slug = input.slug;
+	if (input.actor !== void 0) filterOpts.actor = input.actor;
+	const filtered = filterAuditLog(entries, filterOpts);
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			total: entries.length,
+			returned: filtered.length,
+			entries: filtered
+		}, null, 2)
+	}] };
+}
+function registerGetAuditLog(server) {
+	server.registerTool("get_audit_log", {
+		title: "Get Audit Log",
+		description: `Read the CRM audit log — all write operations with timestamp, actor, tool, and customer.
+Use to answer "what changed recently?", "what did alice do?", or "show me all actions for acme-corp".
+
+Args:
+  slug: Filter by customer slug (optional)
+  actor: Filter by actor name (optional)
+  limit: Max entries to return (default: 50, most recent)
+
+Returns: { total: number, returned: number, entries: [{timestamp, actor, tool, slug, summary}] }`,
+		inputSchema: z.object({
+			slug: z.string().optional().describe("Filter by customer slug"),
+			actor: z.string().optional().describe("Filter by actor (user or system)"),
+			limit: z.number().int().min(1).max(500).optional().describe("Max entries (default 50)")
+		})
+	}, async ({ slug, actor, limit }) => {
+		const input = {};
+		if (slug !== void 0) input.slug = slug;
+		if (actor !== void 0) input.actor = actor;
+		if (limit !== void 0) input.limit = limit;
+		return handleGetAuditLog(input);
+	});
+}
+//#endregion
+//#region src/mcp/prompts.ts
+/**
+* CRM playbook prompts exposed via MCP `prompts/list` + `prompts/get`.
+* Each renders an actionable, tool-referencing instruction for the host LLM —
+* the agent-native equivalent of a Salesforce "playbook".
+*/
+const CRM_PROMPTS = [
+	{
+		name: "deal_risk_review",
+		title: "Assess deal risk",
+		description: "Evaluate the health and risk of a customer's open deals and recommend next steps.",
+		build: ({ slug }) => `Assess the deal risk for customer "${slug}".\n1. Call open_deal_room({ slug: "${slug}" }) for a consolidated brief, or get_customer_context + get_deal_health.\n2. Identify stalled deals, approaching close dates, and silent champions (get_relationship_health).\n3. Summarise the top risks and recommend concrete next actions. Do not invent data — cite what you read.`
+	},
+	{
+		name: "draft_follow_up",
+		title: "Draft a follow-up email",
+		description: "Draft a personalized follow-up email for a customer based on recent interactions.",
+		build: ({ slug }) => `Draft a follow-up email for customer "${slug}".\n1. Read recent context with get_customer_context({ slug: "${slug}" }).\n2. Use draft_email({ slug: "${slug}", templateId, tone: "friendly" }) with an appropriate template.\n3. Reference the latest interaction concretely; keep it concise. Return the draft for review — do not send.`
+	},
+	{
+		name: "account_brief",
+		title: "Create an account brief",
+		description: "Produce a concise executive brief for a customer account.",
+		build: ({ slug }) => `Create an executive account brief for "${slug}".\n1. get_customer_context({ slug: "${slug}" }) and get_org_intelligence({ slug: "${slug}" }).\n2. Summarise: who the stakeholders are (champions/buyers/blockers), open pipeline, health, and risks.\n3. End with the single most important next action.`
+	},
+	{
+		name: "pipeline_summary",
+		title: "Summarize the pipeline",
+		description: "Summarize pipeline and forecast, optionally focused on one customer.",
+		build: ({ slug }) => `Summarize the sales pipeline (focus customer: "${slug}").\n1. get_pipeline_forecast() for the weighted total and per-stage breakdown.\n2. simulate_revenue() for P10/P50/P90 if a probabilistic view helps.\n3. Highlight at-risk revenue and the deals that most move the forecast.`
+	}
+];
+function registerPrompts(server) {
+	for (const prompt of CRM_PROMPTS) server.registerPrompt(prompt.name, {
+		title: prompt.title,
+		description: prompt.description,
+		argsSchema: { slug: z.string().describe("Customer slug") }
+	}, ({ slug }) => ({ messages: [{
+		role: "user",
+		content: {
+			type: "text",
+			text: prompt.build({ slug })
+		}
+	}] }));
+}
+//#endregion
+//#region src/mcp/resources.ts
+const DATA_DIR$1 = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+/**
+* Read-only MCP Resources for CRM entities. Complements the action Tools:
+* agents can `resources/read` a customer briefing, pipeline or timeline by URI
+* instead of calling a tool.
+*/
+function registerResources(server, dataDir = DATA_DIR$1) {
+	server.registerResource("customers", "crm://customers", {
+		title: "Customers",
+		description: "List of all customer slugs",
+		mimeType: "application/json"
+	}, (uri) => ({ contents: [{
+		uri: uri.href,
+		mimeType: "application/json",
+		text: JSON.stringify(listCustomerSlugs(dataDir), null, 2)
+	}] }));
+	server.registerResource("customer", new ResourceTemplate("crm://customer/{slug}", { list: void 0 }), {
+		title: "Customer context",
+		description: "LLM-ready briefing (main facts, recent interactions, pipeline) for a customer",
+		mimeType: "text/markdown"
+	}, async (uri, variables) => {
+		const { buildContext } = await import("./context-builder-DlrRcqmJ.js");
+		const text = await buildContext(dataDir, String(variables["slug"]));
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "text/markdown",
+			text
+		}] };
+	});
+	server.registerResource("pipeline", new ResourceTemplate("crm://pipeline/{slug}", { list: void 0 }), {
+		title: "Pipeline",
+		description: "Open and closed deals for a customer",
+		mimeType: "application/json"
+	}, async (uri, variables) => {
+		const { readPipeline } = await import("./pipeline-writer-BqBrYrQc.js");
+		const deals = await readPipeline(dataDir, String(variables["slug"]));
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "application/json",
+			text: JSON.stringify(deals, null, 2)
+		}] };
+	});
+	server.registerResource("timeline", new ResourceTemplate("crm://timeline/{slug}", { list: void 0 }), {
+		title: "Interaction timeline",
+		description: "Newest-first interaction history for a customer",
+		mimeType: "text/markdown"
+	}, async (uri, variables) => {
+		const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+		const text = await readInteractions(dataDir, String(variables["slug"]));
+		return { contents: [{
+			uri: uri.href,
+			mimeType: "text/markdown",
+			text
+		}] };
+	});
+}
+//#endregion
+//#region src/mcp/tools/custom-objects.ts
+const DATA_DIR = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+const FIELD_TYPES = [
+	"text",
+	"number",
+	"boolean",
+	"date",
+	"select"
+];
+function json(data) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(data, null, 2)
+	}] };
+}
+function handleDefineCustomObject(input, dataDir = DATA_DIR) {
+	enforceRbac(dataDir, "define_custom_object");
+	const objects = defineCustomObject(dataDir, {
+		name: input.name,
+		...input.label ? { label: input.label } : {},
+		fields: input.fields
+	});
+	return json({
+		defined: input.name,
+		objectCount: objects.length
+	});
+}
+function handleCreateRecord(input, dataDir = DATA_DIR) {
+	enforceRbac(dataDir, "create_record");
+	const res = createRecord(dataDir, input.object, input.values);
+	if (!res.ok) return json({ error: (res.errors ?? []).join("; ") });
+	import("./webhooks-7EpA05Qr.js").then(({ emitEvent }) => emitEvent(dataDir, "record.created", {
+		object: input.object,
+		record: res.record
+	}));
+	return json({ record: res.record });
+}
+function handleListRecords(input, dataDir = DATA_DIR) {
+	return json({
+		object: input.object,
+		records: listRecords(dataDir, input.object)
+	});
+}
+function handleListCustomObjects(dataDir = DATA_DIR) {
+	return json({ objects: loadCustomObjects(dataDir) });
+}
+function registerCustomObjectTools(server, dataDir = DATA_DIR) {
+	server.registerTool("define_custom_object", {
+		description: "Define a custom object (runtime entity type) with typed fields — no code migration. admin only.",
+		inputSchema: z.object({
+			name: z.string().describe("Object name (e.g. contract)"),
+			label: z.string().optional(),
+			fields: z.array(z.object({
+				name: z.string(),
+				type: z.enum(FIELD_TYPES),
+				label: z.string().optional(),
+				options: z.array(z.string()).optional()
+			})).describe("Field definitions")
+		})
+	}, ({ name, label, fields }) => handleDefineCustomObject({
+		name,
+		...label ? { label } : {},
+		fields
+	}, dataDir));
+	server.registerTool("create_record", {
+		description: "Create a record of a custom object. Values are validated against the schema. rep+.",
+		inputSchema: z.object({
+			object: z.string().describe("Custom object name"),
+			values: z.record(z.string()).describe("Field values (key=value)")
+		})
+	}, ({ object, values }) => handleCreateRecord({
+		object,
+		values
+	}, dataDir));
+	server.registerTool("list_records", {
+		description: "List records of a custom object.",
+		inputSchema: z.object({ object: z.string().describe("Custom object name") })
+	}, ({ object }) => handleListRecords({ object }, dataDir));
+	server.registerTool("list_custom_objects", {
+		description: "List all defined custom objects and their field schemas.",
+		inputSchema: z.object({})
+	}, () => handleListCustomObjects(dataDir));
+}
+//#endregion
+//#region src/mcp/server.ts
+function surveyThankYouPage(score, comment) {
+	return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Thank you</title>
+<style>body{font-family:sans-serif;max-width:480px;margin:80px auto;text-align:center;padding:0 20px}
+h1{font-size:2.5em;margin-bottom:.3em}p{color:#555;font-size:1.1em}</style></head>
+<body><h1>${score >= 9 ? "🎉" : score >= 7 ? "🙂" : "🙏"}</h1><h2>Thank you for your feedback!</h2>
+<p>You rated us <strong>${score}/10</strong>.${comment ? `<br>Your comment: <em>"${String(comment).slice(0, 200).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")}"</em>` : ""}</p>
+<p style="margin-top:40px;color:#aaa;font-size:.85em">Powered by DatasynxOpenCRM</p>
+</body></html>`;
+}
+function createMcpServer() {
+	const server = new McpServer({
+		name: "datasynx-opencrm",
+		version: "0.1.0"
+	});
+	registerGetCapabilities(server);
+	registerGetActiveSession(server);
+	registerGetCustomerContext(server);
+	registerSearchCustomerKnowledge(server);
+	registerListCustomers(server);
+	registerLogInteraction(server);
+	registerUpdateDeal(server);
+	registerExportCustomer(server);
+	registerUpdateCustomerFacts(server);
+	registerGetDealHealth(server);
+	registerGetPipelineForecast(server);
+	registerSummarizeMeeting(server);
+	registerGetPipelineStages(server);
+	registerGetMarketIntelligence(server);
+	registerGetRelationshipGraph(server);
+	registerGetRelationshipHealth(server);
+	registerRunDealAgent(server);
+	registerApproveAgentAction(server);
+	registerSimulateRevenue(server);
+	registerGetPlaybook(server);
+	registerCreatePlaybook(server);
+	registerListPlaybooks(server);
+	registerDistillPlaybook(server);
+	registerPursueGoal(server);
+	registerGetGoalStatus(server);
+	registerRegisterPushSubscription(server);
+	registerGetPushStatus(server);
+	registerGetOrgIntelligence(server);
+	registerOpenDealRoom(server);
+	registerGetProactiveBriefing(server);
+	registerListEmailTemplates(server);
+	registerGetEmailTemplate(server);
+	registerDraftEmail(server);
+	registerEnrollInSequence(server);
+	registerListSequenceEnrollments(server);
+	registerUnenrollFromSequence(server);
+	registerListSequences(server);
+	registerGenerateQuote(server);
+	registerGetQuoteStatus(server);
+	registerGetBookingLink(server);
+	registerCreateTicket(server);
+	registerUpdateTicket(server);
+	registerListTickets(server);
+	registerCloseTicket(server);
+	registerSendNpsSurvey(server);
+	registerGetSurveyResults(server);
+	registerSearchKnowledgeBase(server);
+	registerCreateKbArticle(server);
+	registerBackupNow(server);
+	registerListBackups(server);
+	registerTriggerSync(server);
+	registerGetAuditLog(server);
+	registerCustomObjectTools(server);
+	registerPrompts(server);
+	registerResources(server);
+	return server;
+}
+async function startStdio() {
+	await initOAuthFromDisk(process.cwd());
+	const server = createMcpServer();
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	console.error("DatasynxOpenCRM MCP Server running via stdio");
+}
+async function startHttp(port = 3847) {
+	await initOAuthFromDisk(process.cwd());
+	const { default: express } = await import("express");
+	const app = express();
+	app.use(express.json());
+	const server = createMcpServer();
+	const dataDir = process.cwd();
+	app.get("/.well-known/oauth-protected-resource", (req, res) => {
+		const base = `${req.protocol}://${req.get("host") ?? "localhost"}`;
+		res.json(protectedResourceMetadata(`${base}/mcp`));
+	});
+	app.post("/mcp", async (req, res) => {
+		if (isAuthRequired(dataDir)) {
+			const auth = verifyBearer(req.headers["authorization"], dataDir);
+			if (!auth.ok) {
+				const base = `${req.protocol}://${req.get("host") ?? "localhost"}`;
+				res.status(401).set("WWW-Authenticate", wwwAuthenticateHeader(`${base}/.well-known/oauth-protected-resource`)).json({ error: "unauthorized" });
+				return;
+			}
+			if (auth.actor) process.env["DXCRM_ACTOR"] = auth.actor;
+		}
+		const transport = new StreamableHTTPServerTransport({ enableJsonResponse: true });
+		transport.onclose = () => {};
+		res.on("close", () => {
+			transport.close();
+		});
+		await server.connect(transport);
+		await transport.handleRequest(req, res, req.body);
+	});
+	app.get("/health", (_req, res) => {
+		res.json({
+			status: "ok",
+			server: "datasynx-opencrm",
+			version: "0.1.0"
+		});
+	});
+	app.get("/sessions", async (_req, res) => {
+		try {
+			const { readAllSessions } = await import("./session-mWHA71Lw.js");
+			const sessions = readAllSessions(dataDir);
+			res.json({ sessions });
+		} catch {
+			res.json({ sessions: [] });
+		}
+	});
+	app.post("/webhooks/gmail", async (req, res) => {
+		const token = process.env["GMAIL_PUBSUB_TOKEN"] ?? "";
+		if (!verifyGmailPubSubSignature(req.headers["authorization"], token)) {
+			res.status(401).json({ error: "unauthorized" });
+			return;
+		}
+		const payload = decodeGmailPubSubPayload(req.body);
+		if (!payload) {
+			res.status(400).json({ error: "invalid_payload" });
+			return;
+		}
+		const result = await handleGmailPushEvent(dataDir, payload, "").catch(() => ({
+			processed: 0,
+			slug: null
+		}));
+		res.json({
+			ok: true,
+			processed: result.processed
+		});
+	});
+	app.all("/webhooks/microsoft", async (req, res) => {
+		const validation = handleMicrosoftValidationRequest(req.query);
+		if (validation.isValidation) {
+			res.setHeader("content-type", "text/plain");
+			res.status(200).send(validation.token);
+			return;
+		}
+		const clientState = process.env["MS_GRAPH_CLIENT_STATE"] ?? "";
+		const body = req.body;
+		if (!verifyMicrosoftGraphSignature(body, clientState)) {
+			res.status(401).json({ error: "unauthorized" });
+			return;
+		}
+		const result = await handleMicrosoftPushEvent(dataDir, body.value ?? [], "").catch(() => ({
+			processed: 0,
+			skipped: 0
+		}));
+		res.json({
+			ok: true,
+			...result
+		});
+	});
+	app.post("/webhooks/slack", express.text({ type: "*/*" }), async (req, res) => {
+		const rawBody = req.body;
+		const signingSecret = process.env["SLACK_SIGNING_SECRET"] ?? "";
+		if (!verifySlackSignature(rawBody, req.headers, signingSecret)) {
+			res.status(401).json({ error: "unauthorized" });
+			return;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(rawBody);
+		} catch {
+			res.status(400).json({ error: "invalid_json" });
+			return;
+		}
+		const verification = handleSlackUrlVerification(parsed);
+		if (verification.isVerification) {
+			res.json({ challenge: verification.challenge });
+			return;
+		}
+		if (!parsed.event) {
+			res.json({
+				ok: true,
+				processed: 0
+			});
+			return;
+		}
+		const botToken = process.env["SLACK_BOT_TOKEN"] ?? "";
+		const result = await handleSlackPushEvent(dataDir, parsed.event, botToken, { ...parsed.team_id !== void 0 ? { teamId: parsed.team_id } : {} }).catch(() => ({
+			processed: 0,
+			skipped: 1
+		}));
+		res.json({
+			ok: true,
+			...result
+		});
+	});
+	app.get("/survey/respond", async (req, res) => {
+		const { token, score, comment } = req.query;
+		if (!token) {
+			res.status(400).send("<h2>Invalid survey link.</h2>");
+			return;
+		}
+		if (comment === "true") {
+			res.setHeader("content-type", "text/html");
+			res.send(`<!DOCTYPE html><html><head><meta charset="utf-8"><title>Survey Comment</title>
+<style>body{font-family:sans-serif;max-width:520px;margin:60px auto;padding:0 20px}
+textarea{width:100%;padding:10px;font-size:1em;border:1px solid #ccc;border-radius:4px}
+input[type=number]{width:80px;padding:8px;font-size:1em}
+button{margin-top:12px;padding:12px 28px;background:#1a1a2e;color:#fff;border:none;border-radius:4px;font-size:1em;cursor:pointer}</style></head>
+<body><h2>Leave a comment</h2>
+<form method="POST" action="/survey/respond">
+<input type="hidden" name="token" value="${String(token).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;")}">
+<label>Your score (0–10):<br><input type="number" name="score" min="0" max="10" required></label><br><br>
+<label>Comment (optional):<br><textarea name="comment" rows="5" placeholder="What can we improve?"></textarea></label><br>
+<button type="submit">Submit</button>
+</form></body></html>`);
+			return;
+		}
+		const numScore = score !== void 0 ? parseInt(score, 10) : NaN;
+		if (isNaN(numScore) || numScore < 0 || numScore > 10) {
+			res.status(400).send("<h2>Invalid score. Please use the link from your email.</h2>");
+			return;
+		}
+		const { recordSurveyResponse } = await import("./survey-engine-C06hcQt3.js");
+		await recordSurveyResponse(dataDir, token, numScore).catch(() => null);
+		res.setHeader("content-type", "text/html");
+		res.send(surveyThankYouPage(numScore));
+	});
+	app.post("/survey/respond", express.urlencoded({ extended: false }), async (req, res) => {
+		const { token, score, comment: commentText } = req.body;
+		if (!token) {
+			res.status(400).send("<h2>Invalid survey link.</h2>");
+			return;
+		}
+		const numScore = score !== void 0 ? parseInt(score, 10) : NaN;
+		if (isNaN(numScore) || numScore < 0 || numScore > 10) {
+			res.status(400).send("<h2>Invalid score. Please go back and enter a number between 0 and 10.</h2>");
+			return;
+		}
+		const { recordSurveyResponse } = await import("./survey-engine-C06hcQt3.js");
+		await recordSurveyResponse(dataDir, token, numScore, commentText || void 0).catch(() => null);
+		res.setHeader("content-type", "text/html");
+		res.send(surveyThankYouPage(numScore, commentText));
+	});
+	app.listen(port, () => {
+		console.error(`DatasynxOpenCRM MCP Server running on http://0.0.0.0:${port}/mcp`);
+	});
+}
+if ((process.env["DXCRM_MCP_MODE"] ?? "stdio") === "http") startHttp(parseInt(process.env["DXCRM_MCP_PORT"] ?? "3847", 10)).catch((err) => {
+	console.error("MCP Server fatal error:", err.message);
+	process.exit(1);
+});
+else startStdio().catch((err) => {
+	console.error("MCP Server fatal error:", err.message);
+	process.exit(1);
+});
+//#endregion
+export { startHttp, startStdio };
+
+//# sourceMappingURL=server-Dyva03K8.js.map