@datasynx/agentic-crm 0.1.0

package/dist/cli.js

@@ -0,0 +1,4396 @@
+#!/usr/bin/env node
+import { a as writeMainFacts, i as readMainFacts, n as ensureCustomerDir, o as MainFactsSchema, r as listCustomerSlugs } from "./customer-dir-DIylZ8Q6.js";
+import { a as warning, i as success, n as error, r as info, t as bold } from "./colors-BG07TZQz.js";
+import { n as getSession } from "./session-store-CEa39Dxs.js";
+import { i as sessionCommand, r as readAllSessions } from "./session-B9AilxOE.js";
+import { a as searchKbSimple, i as listKbArticles, n as getKbArticle, o as writeKbArticle, s as CAPABILITIES_TEXT, t as deleteKbArticle } from "./knowledge-base-D0Fh40kc.js";
+import { a as restoreCommand, t as backupCommand } from "./backup-CeMk9z86.js";
+import { n as readSyncState } from "./sync-state-ChaLbamC.js";
+import { n as readUnmatched } from "./unmatched-transcripts-BsH5bhkU.js";
+import { t as AgentConfigSchema } from "./agent-config-zPvcqu07.js";
+import { 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 { i as canWrite, o as getRbacConfig, u as setActorRole } from "./rbac-CTIktZaC.js";
+import { t as withJsonFile } from "./file-lock-B_zi7NQl.js";
+import { d as deletePipelineStage, f as getPipelineStages, m as setPipelineStage, p as resetToDefaults } from "./revenue-simulation-Bqf2DLVB.js";
+import { d as pursueGoal, h as updateGoalProgress, i as getActiveGoals, n as cancelGoal } from "./goal-engine-KpBftn4V.js";
+import { a as revoke, i as renewExpiringSubscriptions, n as readSubscriptions, r as register } from "./push-manager-CdqIIkuh.js";
+import { a as writeEnrollment, d as getTemplate, f as listTemplates, l as interpolate, n as listSequences, o as writeSequence, p as writeTemplate, r as readEnrollments, s as buildVariablesFromCustomer, t as getSequence, u as deleteTemplate } from "./sequence-store-DaaWr0Os.js";
+import { r as runSequenceCycle } from "./sequence-engine-J1lTW_in.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 { a as listSurveys, d as writeSurvey, i as getSurvey, l as savePendingSurvey, n as calcNpsScore, o as loadSurveyResponses, r as generateSurveyToken } from "./survey-engine-DBjCYqCv.js";
+import { Command } from "commander";
+import path from "path";
+import fs from "fs";
+import slugify from "slug";
+import matter from "gray-matter";
+import Table from "cli-table3";
+import os from "os";
+import { execSync, spawn } from "child_process";
+import { createHash } from "crypto";
+//#region src/commands/create.ts
+async function createCustomer(opts) {
+	const id = slugify(opts.name, { lower: true });
+	const dataDir = opts.dataDir ?? process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	await ensureCustomerDir(dataDir, id);
+	const dir = path.join(dataDir, "customers", id);
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	await writeMainFacts(dataDir, id, {
+		name: opts.name,
+		domain: opts.domain,
+		email: opts.email,
+		relationship_stage: "prospect",
+		tags: [],
+		currency: "EUR",
+		created: today,
+		updated: today
+	});
+	const interactionsPath = path.join(dir, "interactions.md");
+	if (!fs.existsSync(interactionsPath)) fs.writeFileSync(interactionsPath, `# Interactions — ${opts.name}\n\n`);
+	const pipelinePath = path.join(dir, "pipeline.md");
+	if (!fs.existsSync(pipelinePath)) fs.writeFileSync(pipelinePath, `# Pipeline — ${opts.name}\n\n| Deal | Stage | Value | Currency | Probability | Close Date | Updated | Notes |\n|---|---|---|---|---|---|---|---|\n`);
+	const sourcesPath = path.join(dir, "sources.json");
+	if (!fs.existsSync(sourcesPath)) {
+		const sources = {
+			gmail: {
+				type: "gmail",
+				query: opts.domain ? `from:${opts.domain} OR to:${opts.domain}` : opts.email ? `from:${opts.email} OR to:${opts.email}` : "",
+				enabled: true
+			},
+			version: 1,
+			created: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		fs.writeFileSync(sourcesPath, JSON.stringify(sources, null, 2));
+	}
+	return {
+		id,
+		dir
+	};
+}
+const createCommand = new Command("create").argument("<name>", "Customer name").option("--domain <domain>", "Primary domain (for Gmail sync)").option("--email <email>", "Primary contact email").action(async (name, opts) => {
+	try {
+		const { id, dir } = await createCustomer({
+			name,
+			...opts
+		});
+		console.log(success(`✓ Created customer: ${bold(id)}`));
+		console.log(`  Dir: ${dir}`);
+		console.log(`  Files: main_facts.md, interactions.md, pipeline.md, sources.json`);
+	} catch (err) {
+		console.error(error(`✗ ${err.message}`));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/ui/table.ts
+function renderCustomerTable(customers) {
+	const table = new Table({
+		head: [
+			"Slug",
+			"Name",
+			"Stage",
+			"Industry",
+			"Tags",
+			"Updated"
+		],
+		style: { head: ["cyan"] },
+		colWidths: [
+			20,
+			25,
+			15,
+			15,
+			20,
+			12
+		],
+		wordWrap: true
+	});
+	for (const { slug, facts } of customers) table.push([
+		slug,
+		facts.name,
+		facts.relationship_stage,
+		facts.industry ?? "—",
+		facts.tags.join(", ") || "—",
+		facts.updated
+	]);
+	return table.toString();
+}
+//#endregion
+//#region src/commands/list.ts
+const listCommand = new Command("list").option("--filter <query>", "Filter by name or slug").action(async (opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const slugs = listCustomerSlugs(dataDir);
+	if (slugs.length === 0) {
+		console.log("No customers yet. Run: dxcrm create \"Customer Name\"");
+		return;
+	}
+	const customers = [];
+	for (const slug of slugs) try {
+		const facts = await readMainFacts(dataDir, slug);
+		if (opts.filter) {
+			const q = opts.filter.toLowerCase();
+			if (!facts.name.toLowerCase().includes(q) && !slug.includes(q) && !(facts.relationship_stage ?? "").toLowerCase().includes(q)) continue;
+		}
+		customers.push({
+			slug,
+			facts
+		});
+	} catch {}
+	if (customers.length === 0) {
+		console.log(opts.filter ? `No customers matching "${opts.filter}"` : "No customers yet.");
+		return;
+	}
+	console.log(renderCustomerTable(customers));
+});
+//#endregion
+//#region src/commands/validate.ts
+const RECOVERABLE_DEFAULTS = {
+	tags: [],
+	currency: "EUR"
+};
+function applyFix(factsPath, content, data) {
+	const fixed = [];
+	const patched = { ...data };
+	for (const [field, defaultValue] of Object.entries(RECOVERABLE_DEFAULTS)) if (patched[field] === void 0 || patched[field] === null) {
+		patched[field] = defaultValue;
+		fixed.push(`${field} → ${JSON.stringify(defaultValue)}`);
+	}
+	if (patched["updated"] === void 0 && patched["created"]) {
+		patched["updated"] = patched["created"];
+		fixed.push(`updated → ${String(patched["created"])}`);
+	}
+	if (fixed.length === 0) return null;
+	const parsed = matter(content);
+	const newContent = matter.stringify(parsed.content, patched);
+	fs.writeFileSync(factsPath, newContent);
+	return {
+		fixed,
+		content: newContent
+	};
+}
+async function runValidate(opts, dataDir) {
+	const customersDir = path.join(dataDir, "customers");
+	if (!fs.existsSync(customersDir)) {
+		console.log(warning("⚠ No customers directory found."));
+		return;
+	}
+	const slugs = listCustomerSlugs(dataDir);
+	let errorCount = 0;
+	let fixedCount = 0;
+	for (const slug of slugs) {
+		const factsPath = path.join(customersDir, slug, "main_facts.md");
+		const interactionsPath = path.join(customersDir, slug, "interactions.md");
+		if (!fs.existsSync(factsPath)) {
+			console.log(error(`✗ ${slug}: missing main_facts.md`));
+			errorCount++;
+			continue;
+		}
+		try {
+			let content = fs.readFileSync(factsPath, "utf-8");
+			const { data } = matter(content);
+			if (opts.fix) {
+				const result = applyFix(factsPath, content, data);
+				if (result) {
+					content = result.content;
+					fixedCount++;
+					console.log(info(`⚙ ${slug}: fixed ${result.fixed.join(", ")}`));
+				}
+			}
+			const { data: refetchedData } = matter(content);
+			MainFactsSchema.parse(refetchedData);
+			if (!fs.existsSync(interactionsPath)) console.log(warning(`⚠ ${slug}: missing interactions.md`));
+			else console.log(success(`✓ ${slug}`));
+		} catch (err) {
+			console.log(error(`✗ ${slug}: ${err.message}`));
+			errorCount++;
+		}
+	}
+	if (opts.fix && fixedCount > 0) console.log(info(`\n⚙ Fixed ${fixedCount} customer(s).`));
+	if (errorCount > 0) {
+		console.error(error(`\n${errorCount} error(s) found.`));
+		process.exit(1);
+	} else console.log(success("\n✓ All customers valid."));
+}
+const validateCommand = new Command("validate").option("--fix", "Auto-fix recoverable issues").action(async (opts) => {
+	await runValidate(opts, process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+});
+//#endregion
+//#region src/commands/guide.ts
+const guideCommand = new Command("guide").description("Full CRM documentation in terminal").action(() => {
+	console.log(CAPABILITIES_TEXT);
+});
+const mcpCommand = new Command("mcp");
+mcpCommand.command("docs").action(() => {
+	console.log(CAPABILITIES_TEXT);
+});
+mcpCommand.command("token").description("Mint a bearer token for the HTTP MCP server (printed once)").requiredOption("--actor <actor>", "Actor/user the token authenticates as").option("--role <role>", "RBAC role: admin | manager | rep", "rep").option("--label <label>", "Optional label (e.g. device name)").action(async (opts) => {
+	const role = [
+		"admin",
+		"manager",
+		"rep"
+	].includes(opts.role) ? opts.role : "rep";
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const { createMcpToken } = await import("./auth-CyFuu9X_.js");
+	const token = createMcpToken(dataDir, opts.actor, role, opts.label);
+	console.log(info("MCP bearer token (store it now — it is not shown again):"));
+	console.log(token);
+	console.log(info(`actor=${opts.actor} role=${role} — HTTP /mcp now requires this token.`));
+});
+mcpCommand.command("start").description("Start MCP server (stdio by default)").option("--http", "Use HTTP transport instead of stdio").option("--port <port>", "HTTP port (default 3847)", "3847").action(async (opts) => {
+	if (opts.http) {
+		const port = parseInt(opts.port, 10);
+		console.error(info(`Starting MCP server in HTTP mode on port ${port}...`));
+		const { startHttp } = await import("./server-Dyva03K8.js");
+		await startHttp(port);
+	} else {
+		const { startStdio } = await import("./server-Dyva03K8.js");
+		await startStdio();
+	}
+});
+const TOOL_COUNT = 56;
+/** Claude Code: CLAUDE.md in CRM dataDir */
+function buildClaudeMd(dataDir) {
+	return `# DatasynxOpenCRM v2 — Agent Instructions (${TOOL_COUNT} MCP Tools)
+
+## Proactive — Act Without Being Asked
+At the start of every session, before the user says anything:
+1. \`get_proactive_briefing()\` — today's urgent items, forecast, top action
+2. \`get_goal_status()\` — if active goals exist, show progress
+
+## Before Every Deal Conversation
+Use \`open_deal_room({ slug, dealName })\` — not \`get_customer_context()\`.
+It combines graph, health, revenue simulation, playbook, and org intelligence in one call (~3–5s).
+
+## Standard Workflow
+| Trigger | Tool |
+|---|---|
+| Customer mentioned | \`get_customer_context(slug)\` or \`open_deal_room(slug, dealName)\` |
+| After call/meeting/email | \`log_interaction(slug, type, summary, nextSteps)\` |
+| Deal stage changes | \`update_deal(slug, dealName, { stage, probability, value })\` |
+| Historical question | \`search_customer_knowledge(slug, query)\` |
+| "What should I do today?" | \`get_proactive_briefing()\` |
+| "Close €X this quarter" | \`pursue_goal(goal, deadline)\` |
+
+## Autonomy Patterns
+
+**User says "Look at Acme Corp":**
+1. \`open_deal_room({ slug: "acme-corp", dealName: "<active deal>" })\`
+2. Summarize in 3 bullets, recommend 1 action
+
+**User says "What do I need to do today?":**
+1. \`get_proactive_briefing()\`
+2. \`get_goal_status()\` if goals are active
+3. Reply with prioritized actions
+
+**User says "Deal is stalled":**
+1. \`run_deal_agent({ slug, dealName, autonomyLevel: "suggest" })\`
+2. Present the plan, ask for approval before acting
+
+## All ${TOOL_COUNT} MCP Tools
+
+### Foundation
+- \`get_capabilities()\` — complete tool reference with schemas
+- \`get_active_session()\` — which customer is currently open
+- \`get_customer_context(slug?)\` — full briefing, triggers background Gmail sync
+- \`search_customer_knowledge(slug, query)\` — semantic vector search across emails + transcripts
+- \`list_customers(filter?)\` — all customers with health score and last touchpoint
+- \`log_interaction(slug, type, summary, nextSteps?)\` — write to CRM; auto-updates graph + health
+- \`update_deal(slug, dealName, fields)\` — pipeline stage, value, probability, close date
+- \`export_customer(slug, format?)\` — export as JSON or Markdown ZIP
+- \`update_customer_facts(slug, fields)\` — name, domain, email, primary_contact, tags
+- \`get_deal_health(slug)\` — health score A–F with warnings per deal
+- \`get_pipeline_forecast()\` — weighted pipeline total and deal list
+- \`summarize_meeting(transcript)\` — LLM meeting analysis → structured notes
+- \`get_pipeline_stages()\` — configured stages with default probabilities
+- \`get_market_intelligence(slug)\` — competitor mentions and market context
+
+### Graph & Relationship (D11/D12)
+- \`get_relationship_graph(slug)\` — stakeholder graph: champions, blockers, economic buyers, warm intro paths
+- \`get_relationship_health(slug)\` — contact health scores A–F, decay detection, risk flags
+
+### Autonomous Deal Agent (D13)
+- \`run_deal_agent({ slug, dealName, autonomyLevel })\` — AI deal analysis + action plan; autonomyLevel: "observe" | "suggest" | "act"
+- \`approve_agent_action({ actionId, approved })\` — approve or reject a queued agent action
+
+### Revenue Intelligence (D14/D18)
+- \`simulate_revenue({ horizon })\` — Monte Carlo P10/P50/P90 forecast over full pipeline
+- \`get_org_intelligence({ slug, dealName })\` — stakeholder map, missing roles, external signals (funding, news)
+
+### Playbooks (D15)
+- \`get_playbook({ slug, situation })\` — matching playbook for current deal situation
+- \`create_playbook({ name, trigger, content })\` — save a new playbook
+- \`list_playbooks()\` — all available playbooks
+- \`distill_playbook({ slug, dealName, outcome })\` — learn from a won/lost deal
+
+### Goals (D16)
+- \`pursue_goal({ goal, deadline, context? })\` — decompose a revenue goal into prioritized sub-actions
+- \`get_goal_status()\` — progress of all active goals
+
+### Push (D17)
+- \`register_push_subscription({ provider, webhookUrl })\` — gmail | microsoft-graph | slack real-time push
+- \`get_push_status()\` — active subscriptions and expiry dates
+
+### Intelligence Synthesis (D19/D20)
+- \`open_deal_room({ slug, dealName })\` — orchestrates 7 sub-tools; returns complete deal brief in one call
+- \`get_proactive_briefing({ date? })\` — AI-generated daily briefing: urgent items, opportunities, forecast
+
+### Email Templates (H2)
+- \`list_email_templates({ category? })\` — list templates; filter by category (outreach, followup, support)
+- \`get_email_template({ id })\` — get full template with auto-detected variables
+- \`draft_email({ slug, templateId, overrides? })\` — draft personalized email from template + customer facts
+
+### Email Sequences (H1)
+- \`enroll_in_sequence({ slug, contactEmail, sequenceId })\` — enroll contact in automated email sequence
+- \`list_sequence_enrollments({ slug?, status? })\` — list enrollments; filter by slug or status
+- \`unenroll_from_sequence({ enrollmentId })\` — pause an active enrollment
+- \`list_sequences()\` — all sequences with step count and enrollment count
+
+### Quotes & Invoices (H4)
+- \`generate_quote({ slug, dealName, lineItems, vatPercent?, validUntilDays? })\` — create HTML quote with auto-numbering Q-YYYY-NNN
+- \`get_quote_status({ quoteNumber?, slug? })\` — get quote or list all quotes for customer
+
+### Meeting Scheduler (H3)
+- \`get_booking_link({ slug, eventType?, prefillName? })\` — get Calendly booking URL, optionally pre-filled with customer name/email
+
+### Ticket Management (H6)
+- \`create_ticket({ slug, title, priority?, assignee? })\` — open support ticket with auto-SLA due date
+- \`update_ticket({ slug, ticketId, status?, assignee? })\` — update ticket status or assignee
+- \`list_tickets({ slug?, status?, priority?, assignee? })\` — list tickets sorted by priority
+- \`close_ticket({ slug, ticketId, resolution? })\` — close ticket and optionally log resolution
+
+### NPS/CSAT Surveys (H7)
+- \`send_nps_survey({ slug, contactEmail, surveyId, serverUrl? })\` — generate survey token and email body for NPS/CSAT survey
+- \`get_survey_results({ surveyId, slug? })\` — NPS score, promoters/passives/detractors, all responses
+
+### Knowledge Base (H8)
+- \`search_knowledge_base({ query, publicOnly? })\` — full-text search across KB articles
+- \`create_kb_article({ id, title, body, category?, tags?, public?, sourceTicketId? })\` — create or update KB article
+
+### Backup (Enterprise)
+- \`backup_now({ remote?, note? })\` — trigger immediate backup of customers/ + .agentic/ with manifest + integrity check
+- \`list_backups({ limit? })\` — list available backups with date, size, verification status, customer count
+
+### Sync & Audit (Enterprise)
+- \`trigger_sync({ slug?, since? })\` — force immediate Gmail sync for one or all customers (bypasses 30-min daemon cycle)
+- \`get_audit_log({ slug?, actor?, limit? })\` — read append-only audit log of all write operations
+
+### Custom Objects (Platform / metadata)
+- \`define_custom_object({ name, label?, fields })\` — define a runtime entity type with typed fields (no migration), admin
+- \`create_record({ object, values })\` — create a record of a custom object, validated against its schema, rep+
+- \`list_records({ object })\` — list records of a custom object
+- \`list_custom_objects()\` — list all defined custom objects and their schemas
+
+## Rules
+- Never discuss a customer without first loading their context
+- Always log interactions — calls, emails, Slack, demos, proposals
+- Never invent information — if uncertain, use search_customer_knowledge
+- Use open_deal_room before any deal conversation, not get_customer_context
+
+## Data Directory
+${dataDir}`.trim();
+}
+/** OpenClaw / Hermes: SOUL.md */
+function buildSoulMd(framework) {
+	return `# Identity
+I am a CRM-integrated AI assistant powered by DatasynxOpenCRM v2 (${TOOL_COUNT} MCP tools).
+My purpose is to help manage customer relationships proactively — acting before being asked.
+
+# Core Behaviors
+- **Proactive first.** At session start I call \`get_proactive_briefing()\` without being asked.
+- **Context before action.** Before any customer discussion: \`open_deal_room()\` or \`get_customer_context()\`.
+- **Log everything.** Every interaction — calls, emails, meetings, Slack — goes into the CRM via \`log_interaction()\`.
+- **Cite sources.** All customer information is cited: gmail://, file://, transcript://.
+- **Glass-box reasoning.** When using \`run_deal_agent()\`, I surface the trace so the user can inspect my reasoning.
+
+# Tool Hierarchy
+1. \`open_deal_room()\` — for deal conversations (combines 7 sub-tools)
+2. \`get_proactive_briefing()\` — for morning / session start
+3. \`get_customer_context()\` — for general customer questions
+4. \`run_deal_agent()\` — when a deal needs AI-driven analysis
+
+# Boundaries
+- I do not invent customer data. I search or sync first.
+- I do not skip logging — even quick Slack messages deserve a \`log_interaction()\`.
+- I do not act autonomously beyond "suggest" level without explicit human approval via \`approve_agent_action()\`.
+- I do not discuss a customer without context loaded.
+
+# Communication
+Direct. Action-oriented. Lead with the most important insight.
+Bullet points for next steps. End every deal summary with: "What do you want to do first?"
+
+# Framework
+${framework === "openclaw" ? "OpenClaw — tool prefix: datasynx_opencrm:" : "Hermes — skill: datasynx-crm"}`.trim();
+}
+/** Hermes SOUL.md is same as OpenClaw */
+const buildHermesSoulMd = buildSoulMd;
+/** Codex / OpenClaw / Antigravity: AGENTS.md in dataDir */
+function buildAgentsMd(dataDir) {
+	return `# DatasynxOpenCRM v2 — Agent Instructions (${TOOL_COUNT} MCP Tools)
+
+## Role
+You are a proactive CRM AI assistant. You act before being asked.
+At every session start: call \`get_proactive_briefing()\`.
+
+## Priority Tool Order
+1. \`open_deal_room(slug, dealName)\` — before any deal conversation
+2. \`get_proactive_briefing()\` — at session start, or when asked "what should I do?"
+3. \`get_customer_context(slug)\` — for general customer questions
+4. \`run_deal_agent(slug, dealName, "suggest")\` — when a deal is stalled
+
+## Core Workflow
+- Customer mentioned → \`get_customer_context(slug)\` immediately
+- Deal conversation → \`open_deal_room(slug, dealName)\` first
+- After interaction → \`log_interaction(slug, type, summary, nextSteps)\`
+- Deal stage change → \`update_deal(slug, dealName, { stage, probability })\`
+- Revenue goal → \`pursue_goal(goal, deadline)\`
+
+## Available Tools (${TOOL_COUNT})
+**Foundation:** get_capabilities · get_active_session · get_customer_context ·
+search_customer_knowledge · list_customers · log_interaction · update_deal ·
+export_customer · update_customer_facts · get_deal_health · get_pipeline_forecast ·
+summarize_meeting · get_pipeline_stages · get_market_intelligence
+
+**Graph & Health (D11/D12):** get_relationship_graph · get_relationship_health
+
+**Autonomous Agent (D13):** run_deal_agent · approve_agent_action
+
+**Revenue (D14/D18):** simulate_revenue · get_org_intelligence
+
+**Playbooks (D15):** get_playbook · create_playbook · list_playbooks · distill_playbook
+
+**Goals (D16):** pursue_goal · get_goal_status
+
+**Push (D17):** register_push_subscription · get_push_status
+
+**Synthesis (D19/D20):** open_deal_room · get_proactive_briefing
+
+**Email Templates (H2):** list_email_templates · get_email_template · draft_email
+
+**Email Sequences (H1):** enroll_in_sequence · list_sequence_enrollments · unenroll_from_sequence · list_sequences
+
+**Quotes (H4):** generate_quote · get_quote_status
+
+**Calendly (H3):** get_booking_link
+
+**Tickets (H6):** create_ticket · update_ticket · list_tickets · close_ticket
+
+**NPS/CSAT (H7):** send_nps_survey · get_survey_results
+
+**Knowledge Base (H8):** search_knowledge_base · create_kb_article
+
+**Backup (Enterprise):** backup_now · list_backups
+
+**Sync & Audit (Enterprise):** trigger_sync · get_audit_log
+
+**Custom Objects (Platform):** define_custom_object · create_record · list_records · list_custom_objects
+
+## Never
+- Discuss a customer without context loaded
+- Skip logging — every touchpoint matters
+- Invent information — use search_customer_knowledge first
+- Act autonomously beyond "suggest" without approve_agent_action
+
+## Data Location
+${dataDir}`.trim();
+}
+/** Hermes skills file (agentskills.io standard) */
+function buildHermesSkillMd() {
+	return `---
+name: datasynx-crm
+version: 2.0.0
+description: Proactive CRM workflow skill for DatasynxOpenCRM v2 (${TOOL_COUNT} MCP tools)
+triggers:
+  - "customer"
+  - "client"
+  - "deal"
+  - "pipeline"
+  - "sync"
+  - "briefing"
+  - "forecast"
+  - "goal"
+  - "stakeholder"
+  - "playbook"
+---
+
+# DatasynxOpenCRM v2 Skill
+
+## Session Start — Always
+Call \`get_proactive_briefing()\` at the start of every session without being asked.
+
+## Before a Deal Conversation
+Call \`open_deal_room({ slug, dealName })\` — returns graph, health, simulation, and playbook in one call.
+
+## When a Customer Is Mentioned
+Call \`get_customer_context(slug)\` before discussing anything.
+Never assume you know the current state.
+
+## After Every Interaction
+Call \`log_interaction()\` with:
+- type: Call | Meeting | Email | Note | Demo | Proposal
+- summary: 2–5 sentences
+- nextSteps: concrete actions as array
+
+## For a Stalled Deal
+\`run_deal_agent({ slug, dealName, autonomyLevel: "suggest" })\`
+Then use \`approve_agent_action()\` to confirm before acting.
+
+## For Revenue Goals
+\`pursue_goal({ goal: "Close €500k this quarter", deadline: "2026-09-30" })\`
+
+## For Historical Research
+\`search_customer_knowledge(slug, query)\` — searches emails AND transcripts.
+
+## Pipeline Updates
+After any deal discussion: \`update_deal(slug, dealName, { stage, probability, value })\`
+
+## Quick Reference
+\`list_customers()\` for overview · \`get_capabilities()\` for full schema`.trim();
+}
+/** Antigravity SKILL.md */
+function buildAgySkillMd() {
+	return `---
+name: datasynx-crm
+version: 2.0.0
+description: Proactive CRM workflow for DatasynxOpenCRM v2
+triggers:
+  - customer
+  - client
+  - deal
+  - pipeline
+  - briefing
+  - forecast
+  - goal
+---
+
+# DatasynxOpenCRM v2 Skill
+
+## Session Start
+Call \`get_proactive_briefing()\` first — urgent items, forecast, top action.
+
+## Deal Conversations
+\`open_deal_room({ slug, dealName })\` — graph + health + simulation + playbook in one call.
+
+## When a Customer Is Mentioned
+\`get_customer_context(slug)\` before discussing anything.
+
+## After Every Interaction
+\`log_interaction(slug, type, summary, nextSteps)\`
+
+## Stalled Deal
+\`run_deal_agent({ slug, dealName, autonomyLevel: "suggest" })\`
+
+## Revenue Goal
+\`pursue_goal({ goal, deadline })\`
+
+## Historical Research
+\`search_customer_knowledge(slug, query)\`
+
+## Pipeline
+\`update_deal(slug, dealName, { stage, value, probability })\`
+
+## Overview
+\`list_customers()\` for all customers · \`get_capabilities()\` for full reference`.trim();
+}
+/** Antigravity: global GEMINI.md (~/.gemini/GEMINI.md) — token budget: max 50 lines */
+function buildAgyGeminiMd(dataDir) {
+	return `# DatasynxOpenCRM v2 — Agent Context (${TOOL_COUNT} Tools)
+
+You have access to a local CRM via MCP tools (server: datasynx-opencrm).
+
+## Session Start — Always Do This First
+\`get_proactive_briefing()\` — urgent items, opportunities, forecast
+
+## Priority Tool Order
+1. \`open_deal_room(slug, dealName)\` — before deal conversations
+2. \`get_proactive_briefing()\` — at session start or "what should I do?"
+3. \`get_customer_context(slug)\` — for general customer questions
+
+## Core Workflow
+- Customer mentioned → \`get_customer_context(slug)\`
+- After interaction → \`log_interaction(slug, type, summary)\`
+- Deal change → \`update_deal(slug, dealName, fields)\`
+- Historical → \`search_customer_knowledge(slug, query)\`
+- Revenue goal → \`pursue_goal(goal, deadline)\`
+
+## Key v2 Tools
+get_proactive_briefing · open_deal_room · get_relationship_graph ·
+get_relationship_health · run_deal_agent · simulate_revenue ·
+get_org_intelligence · pursue_goal · get_goal_status · get_playbook
+
+## All Tools
+get_capabilities · get_active_session · get_customer_context ·
+search_customer_knowledge · list_customers · log_interaction · update_deal ·
+export_customer · update_customer_facts · get_deal_health · get_pipeline_forecast ·
+summarize_meeting · get_pipeline_stages · get_market_intelligence ·
+get_relationship_graph · get_relationship_health · run_deal_agent ·
+approve_agent_action · simulate_revenue · get_org_intelligence ·
+get_playbook · create_playbook · list_playbooks · distill_playbook ·
+pursue_goal · get_goal_status · register_push_subscription · get_push_status ·
+open_deal_room · get_proactive_briefing ·
+list_email_templates · get_email_template · draft_email ·
+enroll_in_sequence · list_sequence_enrollments · unenroll_from_sequence · list_sequences ·
+generate_quote · get_quote_status · get_booking_link ·
+create_ticket · update_ticket · list_tickets · close_ticket ·
+send_nps_survey · get_survey_results ·
+search_knowledge_base · create_kb_article ·
+backup_now · list_backups ·
+trigger_sync · get_audit_log ·
+define_custom_object · create_record · list_records · list_custom_objects
+
+## Data: ${dataDir}`.trim();
+}
+/** Grok Build: .grok/settings.json — project-level MCP config (array format) */
+function buildGrokSettingsJson(config) {
+	const entry = { mcpServers: [{
+		name: config.serverName,
+		transport: {
+			type: "stdio",
+			command: "node",
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		}
+	}] };
+	return JSON.stringify(entry, null, 2);
+}
+/** Cursor: .cursor/rules/datasynx-crm.mdc (MDC format with frontmatter) */
+function buildCursorRulesMdc(dataDir) {
+	return `---
+description: DatasynxOpenCRM v2 — CRM workflow rules (${TOOL_COUNT} tools)
+globs: ["**/*"]
+alwaysApply: true
+---
+
+# DatasynxOpenCRM v2 Rules
+
+You have access to a local CRM via MCP tools (datasynx-opencrm, ${TOOL_COUNT} tools).
+
+## Session Start
+Call \`get_proactive_briefing()\` at the start of every session.
+
+## Deal Conversations
+Call \`open_deal_room({ slug, dealName })\` before any deal discussion.
+
+## Mandatory Workflow
+- Customer mentioned → \`get_customer_context(slug)\` immediately
+- After call/meeting/email → \`log_interaction(slug, type, summary)\`
+- Historical question → \`search_customer_knowledge(slug, query)\`
+- Deal discussed → \`update_deal(slug, dealName, fields)\`
+- Revenue goal → \`pursue_goal({ goal, deadline })\`
+
+## Key v2 Tools
+open_deal_room · get_proactive_briefing · get_relationship_graph ·
+get_relationship_health · run_deal_agent · approve_agent_action ·
+simulate_revenue · get_org_intelligence · get_playbook · pursue_goal
+
+## All ${TOOL_COUNT} Tools
+get_capabilities · get_active_session · get_customer_context ·
+search_customer_knowledge · list_customers · log_interaction · update_deal ·
+export_customer · update_customer_facts · get_deal_health · get_pipeline_forecast ·
+summarize_meeting · get_pipeline_stages · get_market_intelligence ·
+get_relationship_graph · get_relationship_health · run_deal_agent ·
+approve_agent_action · simulate_revenue · get_org_intelligence ·
+get_playbook · create_playbook · list_playbooks · distill_playbook ·
+pursue_goal · get_goal_status · register_push_subscription · get_push_status ·
+open_deal_room · get_proactive_briefing ·
+list_email_templates · get_email_template · draft_email ·
+enroll_in_sequence · list_sequence_enrollments · unenroll_from_sequence · list_sequences ·
+generate_quote · get_quote_status · get_booking_link ·
+create_ticket · update_ticket · list_tickets · close_ticket ·
+send_nps_survey · get_survey_results ·
+search_knowledge_base · create_kb_article
+
+## Never
+- Discuss a customer without loading context first
+- Skip logging — every touchpoint matters
+- Invent information — sync or search first
+
+## Data: ${dataDir}`.trim();
+}
+//#endregion
+//#region src/setup/adapters/claude-code.ts
+const HOME$7 = os.homedir();
+const CLAUDE_JSON = path.join(HOME$7, ".claude.json");
+const CLAUDE_DIR = path.join(HOME$7, ".claude");
+var ClaudeCodeAdapter = class {
+	name = "Claude Code";
+	detect() {
+		try {
+			execSync("which claude", { stdio: "ignore" });
+			return true;
+		} catch {}
+		return fs.existsSync(CLAUDE_JSON) || fs.existsSync(CLAUDE_DIR);
+	}
+	isInstalled() {
+		if (!fs.existsSync(CLAUDE_JSON)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(CLAUDE_JSON, "utf-8"))["mcpServers"]?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		const harnessFiles = [];
+		this.writeMcpConfig(config);
+		this.writeGlobalSettings();
+		const claudeMdPath = path.join(config.dataDir, "CLAUDE.md");
+		fs.writeFileSync(claudeMdPath, buildClaudeMd(config.dataDir));
+		harnessFiles.push(claudeMdPath);
+		const projectSettingsDir = path.join(config.dataDir, ".claude");
+		fs.mkdirSync(projectSettingsDir, { recursive: true });
+		const allow = [
+			"mcp__datasynx-opencrm__get_capabilities",
+			"mcp__datasynx-opencrm__get_active_session",
+			"mcp__datasynx-opencrm__get_customer_context",
+			"mcp__datasynx-opencrm__search_customer_knowledge",
+			"mcp__datasynx-opencrm__list_customers",
+			"mcp__datasynx-opencrm__log_interaction",
+			"mcp__datasynx-opencrm__update_deal",
+			"mcp__datasynx-opencrm__export_customer"
+		];
+		const projectSettings = { permissions: { allow } };
+		const settingsPath = path.join(projectSettingsDir, "settings.json");
+		fs.writeFileSync(settingsPath, JSON.stringify(projectSettings, null, 2));
+		harnessFiles.push(settingsPath);
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: CLAUDE_JSON,
+			harnessFiles,
+			notes: `${allow.length} of ${TOOL_COUNT} MCP tools pre-allowed (common read/write); CLAUDE.md written to CRM root.`
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(CLAUDE_JSON)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(CLAUDE_JSON, "utf-8"));
+			const servers = json["mcpServers"];
+			if (servers) delete servers["datasynx-opencrm"];
+			fs.writeFileSync(CLAUDE_JSON, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+	writeMcpConfig(config) {
+		let json = {};
+		if (fs.existsSync(CLAUDE_JSON)) try {
+			json = JSON.parse(fs.readFileSync(CLAUDE_JSON, "utf-8"));
+		} catch {}
+		if (!json["mcpServers"]) json["mcpServers"] = {};
+		json["mcpServers"][config.serverName] = {
+			type: "stdio",
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		fs.mkdirSync(path.dirname(CLAUDE_JSON), { recursive: true });
+		fs.writeFileSync(CLAUDE_JSON, JSON.stringify(json, null, 2));
+	}
+	writeGlobalSettings() {
+		fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+		const settingsPath = path.join(CLAUDE_DIR, "settings.json");
+		let settings = {};
+		if (fs.existsSync(settingsPath)) try {
+			settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+		} catch {}
+		if (!settings["permissions"]) settings["permissions"] = {};
+		const perms = settings["permissions"];
+		if (!perms["allow"]) perms["allow"] = [];
+		const allow = perms["allow"];
+		const wildcard = "mcp__datasynx-opencrm__*";
+		if (!allow.includes(wildcard)) allow.push(wildcard);
+		fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+	}
+};
+//#endregion
+//#region src/setup/adapters/claude-desktop.ts
+function getDesktopConfigPath() {
+	switch (process.platform) {
+		case "darwin": return path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+		case "win32": return path.join(process.env["APPDATA"] ?? os.homedir(), "Claude", "claude_desktop_config.json");
+		default: return path.join(os.homedir(), ".config", "claude-desktop", "claude_desktop_config.json");
+	}
+}
+const DESKTOP_CONFIG = getDesktopConfigPath();
+var ClaudeDesktopAdapter = class {
+	name = "Claude Desktop";
+	detect() {
+		return fs.existsSync(DESKTOP_CONFIG) || fs.existsSync(path.dirname(DESKTOP_CONFIG));
+	}
+	isInstalled() {
+		if (!fs.existsSync(DESKTOP_CONFIG)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(DESKTOP_CONFIG, "utf-8"))["mcpServers"]?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(path.dirname(DESKTOP_CONFIG), { recursive: true });
+		let json = {};
+		if (fs.existsSync(DESKTOP_CONFIG)) try {
+			json = JSON.parse(fs.readFileSync(DESKTOP_CONFIG, "utf-8"));
+		} catch {}
+		if (!json["mcpServers"]) json["mcpServers"] = {};
+		json["mcpServers"][config.serverName] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		fs.writeFileSync(DESKTOP_CONFIG, JSON.stringify(json, null, 2));
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: DESKTOP_CONFIG,
+			harnessFiles: [],
+			notes: "Restart Claude Desktop to activate the MCP server. No harness files for Desktop app."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(DESKTOP_CONFIG)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(DESKTOP_CONFIG, "utf-8"));
+			const servers = json["mcpServers"];
+			if (servers) delete servers["datasynx-opencrm"];
+			fs.writeFileSync(DESKTOP_CONFIG, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/setup/adapters/codex.ts
+const CODEX_DIR = path.join(os.homedir(), ".codex");
+const CODEX_CONFIG = path.join(CODEX_DIR, "config.toml");
+var CodexAdapter = class {
+	name = "Codex";
+	detect() {
+		try {
+			execSync("which codex", { stdio: "ignore" });
+			return true;
+		} catch {}
+		return fs.existsSync(CODEX_DIR);
+	}
+	isInstalled() {
+		if (!fs.existsSync(CODEX_CONFIG)) return false;
+		return fs.readFileSync(CODEX_CONFIG, "utf-8").includes("[mcp_servers.datasynx-opencrm]");
+	}
+	async install(config) {
+		fs.mkdirSync(CODEX_DIR, { recursive: true });
+		const harnessFiles = [];
+		if (!this.isInstalled()) {
+			const block = [
+				``,
+				`[mcp_servers.${config.serverName}]`,
+				`command = ${JSON.stringify(process.execPath)}`,
+				`args = [${JSON.stringify(config.mcpServerPath)}]`,
+				`env = { DXCRM_DATA_DIR = ${JSON.stringify(config.dataDir)} }`,
+				`startup_timeout_sec = 30`,
+				`tool_timeout_sec = 120`,
+				`enabled = true`,
+				``
+			].join("\n");
+			fs.appendFileSync(CODEX_CONFIG, block, "utf-8");
+		}
+		const agentsPath = path.join(config.dataDir, "AGENTS.md");
+		if (!fs.existsSync(agentsPath)) {
+			fs.writeFileSync(agentsPath, buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath);
+		} else if (!fs.readFileSync(agentsPath, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(agentsPath, "\n\n---\n\n" + buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath + " (appended)");
+		}
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: CODEX_CONFIG,
+			harnessFiles,
+			notes: `startup_timeout_sec=30, tool_timeout_sec=120. AGENTS.md written to CRM root.`
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(CODEX_CONFIG)) return;
+		const cleaned = fs.readFileSync(CODEX_CONFIG, "utf-8").replace(/\n?\[mcp_servers\.datasynx-opencrm\][^\[]*/, "");
+		fs.writeFileSync(CODEX_CONFIG, cleaned);
+	}
+};
+//#endregion
+//#region src/setup/adapters/openclaw.ts
+const HOME$6 = os.homedir();
+const OPENCLAW_DIR = path.join(HOME$6, ".openclaw");
+const OPENCLAW_JSON = path.join(OPENCLAW_DIR, "openclaw.json");
+const OPENCLAW_WORKSPACE = path.join(OPENCLAW_DIR, "workspace");
+var OpenClawAdapter = class {
+	name = "OpenClaw";
+	detect() {
+		try {
+			execSync("which openclaw", { stdio: "ignore" });
+			return true;
+		} catch {}
+		return fs.existsSync(OPENCLAW_DIR) || fs.existsSync(OPENCLAW_JSON);
+	}
+	isInstalled() {
+		if (!fs.existsSync(OPENCLAW_JSON)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(OPENCLAW_JSON, "utf-8"))["mcpServers"]?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(OPENCLAW_DIR, { recursive: true });
+		fs.mkdirSync(OPENCLAW_WORKSPACE, { recursive: true });
+		const harnessFiles = [];
+		let json = {};
+		if (fs.existsSync(OPENCLAW_JSON)) try {
+			json = JSON.parse(fs.readFileSync(OPENCLAW_JSON, "utf-8"));
+		} catch {}
+		if (!json["mcpServers"]) json["mcpServers"] = {};
+		const servers = json["mcpServers"];
+		servers[config.serverName] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			transport: "stdio",
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		servers[`${config.serverName}-http`] = {
+			url: `http://localhost:${config.httpPort}/mcp`,
+			transport: "streamable-http",
+			enabled: false
+		};
+		fs.writeFileSync(OPENCLAW_JSON, JSON.stringify(json, null, 2));
+		const soulPath = path.join(OPENCLAW_WORKSPACE, "SOUL.md");
+		if (!fs.existsSync(soulPath)) {
+			fs.writeFileSync(soulPath, buildSoulMd("openclaw"));
+			harnessFiles.push(soulPath);
+		} else if (!fs.readFileSync(soulPath, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(soulPath, "\n\n---\n\n" + buildCrmSoulAppend());
+			harnessFiles.push(soulPath + " (appended)");
+		}
+		const agentsPath = path.join(OPENCLAW_WORKSPACE, "AGENTS.md");
+		if (!fs.existsSync(agentsPath)) {
+			fs.writeFileSync(agentsPath, buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath);
+		} else if (!fs.readFileSync(agentsPath, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(agentsPath, "\n\n---\n\n" + buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath + " (appended)");
+		}
+		const toolsPath = path.join(OPENCLAW_WORKSPACE, "TOOLS.md");
+		const toolsContent = buildOpenClawToolsMd();
+		if (!fs.existsSync(toolsPath)) fs.writeFileSync(toolsPath, toolsContent);
+		else if (!fs.readFileSync(toolsPath, "utf-8").includes("datasynx-opencrm")) fs.appendFileSync(toolsPath, "\n\n" + toolsContent);
+		harnessFiles.push(toolsPath);
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: OPENCLAW_JSON,
+			harnessFiles,
+			notes: "Config hot-reloaded by Gateway. SOUL.md + AGENTS.md + TOOLS.md written to workspace."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(OPENCLAW_JSON)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(OPENCLAW_JSON, "utf-8"));
+			const servers = json["mcpServers"];
+			if (servers) {
+				delete servers["datasynx-opencrm"];
+				delete servers["datasynx-opencrm-http"];
+			}
+			fs.writeFileSync(OPENCLAW_JSON, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+};
+function buildCrmSoulAppend() {
+	return `## CRM Integration
+I have access to DatasynxOpenCRM. I always load customer context before discussing customers.
+I log every interaction without being asked. I cite sources when referencing customer data.`;
+}
+function buildOpenClawToolsMd() {
+	return `## datasynx-opencrm MCP Tools
+- get_customer_context(slug) — load full customer briefing
+- search_customer_knowledge(slug, query) — search emails + transcripts
+- list_customers() — pipeline overview
+- log_interaction(slug, type, summary) — write to CRM
+- update_deal(slug, dealName, fields) — pipeline update
+- get_capabilities() — full reference`;
+}
+//#endregion
+//#region src/setup/adapters/hermes.ts
+const HOME$5 = os.homedir();
+const HERMES_HOME = process.env["HERMES_HOME"] ?? path.join(HOME$5, ".hermes");
+const HERMES_CONFIG = path.join(HERMES_HOME, "config.yaml");
+const HERMES_SOUL = path.join(HERMES_HOME, "SOUL.md");
+const HERMES_SKILLS = path.join(HERMES_HOME, "skills");
+var HermesAdapter = class {
+	name = "Hermes Agent";
+	detect() {
+		try {
+			execSync("which hermes", { stdio: "ignore" });
+			return true;
+		} catch {}
+		return fs.existsSync(HERMES_HOME) || fs.existsSync(HERMES_CONFIG);
+	}
+	isInstalled() {
+		if (!fs.existsSync(HERMES_CONFIG)) return false;
+		return fs.readFileSync(HERMES_CONFIG, "utf-8").includes("datasynx");
+	}
+	async install(config) {
+		fs.mkdirSync(HERMES_HOME, { recursive: true });
+		fs.mkdirSync(HERMES_SKILLS, { recursive: true });
+		const harnessFiles = [];
+		this.writeMcpConfig(config);
+		if (!fs.existsSync(HERMES_SOUL)) {
+			fs.writeFileSync(HERMES_SOUL, buildHermesSoulMd("hermes"));
+			harnessFiles.push(HERMES_SOUL);
+		} else if (!fs.readFileSync(HERMES_SOUL, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(HERMES_SOUL, "\n\n---\n\n## CRM Integration\nI have access to DatasynxOpenCRM MCP tools.\nI always load customer context before discussing customers.\nI log every interaction automatically via log_interaction().");
+			harnessFiles.push(HERMES_SOUL + " (appended)");
+		}
+		const skillPath = path.join(HERMES_SKILLS, "datasynx-crm.md");
+		fs.writeFileSync(skillPath, buildHermesSkillMd());
+		harnessFiles.push(skillPath);
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: HERMES_CONFIG,
+			harnessFiles,
+			notes: "SOUL.md updated (Slot #1 system prompt). Skill registered in ~/.hermes/skills/. Server name uses underscore: datasynx_opencrm."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(HERMES_CONFIG)) return;
+		const cleaned = fs.readFileSync(HERMES_CONFIG, "utf-8").replace(/\n  datasynx[_-]opencrm:[\s\S]*?(?=\n  \w|\n[a-z]|$)/, "");
+		fs.writeFileSync(HERMES_CONFIG, cleaned);
+		const skillPath = path.join(HERMES_SKILLS, "datasynx-crm.md");
+		if (fs.existsSync(skillPath)) fs.unlinkSync(skillPath);
+	}
+	writeMcpConfig(config) {
+		let content = fs.existsSync(HERMES_CONFIG) ? fs.readFileSync(HERMES_CONFIG, "utf-8") : "";
+		if (content.includes("datasynx")) return;
+		if (content.includes("mcp_servers:")) {
+			content = content.replace("mcp_servers:", [
+				"mcp_servers:",
+				"  datasynx_opencrm:",
+				`    command: ${JSON.stringify(process.execPath)}`,
+				`    args: [${JSON.stringify(config.mcpServerPath)}]`,
+				`    env:`,
+				`      DXCRM_DATA_DIR: ${JSON.stringify(config.dataDir)}`,
+				`    timeout: 120`,
+				`    connect_timeout: 30`,
+				`    enabled: true`,
+				`    tools:`,
+				`      include: [get_capabilities, get_active_session, get_customer_context, search_customer_knowledge, list_customers, log_interaction, update_deal, export_customer]`,
+				`      prompts: false`,
+				`      resources: false`
+			].join("\n"));
+			fs.writeFileSync(HERMES_CONFIG, content);
+		} else {
+			const mcpBlock = [
+				``,
+				`# DatasynxOpenCRM MCP Server (added by dxcrm init)`,
+				`mcp_servers:`,
+				`  datasynx_opencrm:`,
+				`    command: ${JSON.stringify(process.execPath)}`,
+				`    args: [${JSON.stringify(config.mcpServerPath)}]`,
+				`    env:`,
+				`      DXCRM_DATA_DIR: ${JSON.stringify(config.dataDir)}`,
+				`    timeout: 120`,
+				`    connect_timeout: 30`,
+				`    enabled: true`,
+				`    tools:`,
+				`      include:`,
+				`        - get_capabilities`,
+				`        - get_active_session`,
+				`        - get_customer_context`,
+				`        - search_customer_knowledge`,
+				`        - list_customers`,
+				`        - log_interaction`,
+				`        - update_deal`,
+				`        - export_customer`,
+				`      prompts: false`,
+				`      resources: false`,
+				``
+			].join("\n");
+			fs.appendFileSync(HERMES_CONFIG, mcpBlock);
+		}
+	}
+};
+//#endregion
+//#region src/setup/adapters/antigravity.ts
+const HOME$4 = os.homedir();
+const AGY_BIN_UNIX = path.join(HOME$4, ".local", "bin", "agy");
+const GEMINI_CONFIG_DIR = path.join(HOME$4, ".gemini", "config");
+const SHARED_MCP_CONFIG = path.join(GEMINI_CONFIG_DIR, "mcp_config.json");
+const AGY_DIR = path.join(HOME$4, ".gemini", "antigravity");
+const AGY_MCP_CONFIG = path.join(AGY_DIR, "mcp_config.json");
+const GEMINI_GLOBAL_MD = path.join(HOME$4, ".gemini", "GEMINI.md");
+const AGY_SKILLS_DIR = path.join(HOME$4, ".gemini", "antigravity-cli", "skills");
+var AntigravityAdapter = class {
+	name = "Antigravity CLI";
+	detect() {
+		try {
+			execSync("which agy", { stdio: "ignore" });
+			return true;
+		} catch {}
+		if (fs.existsSync(AGY_BIN_UNIX)) return true;
+		return fs.existsSync(path.join(HOME$4, ".gemini"));
+	}
+	isInstalled() {
+		for (const configPath of [SHARED_MCP_CONFIG, AGY_MCP_CONFIG]) {
+			if (!fs.existsSync(configPath)) continue;
+			try {
+				if (JSON.parse(fs.readFileSync(configPath, "utf-8"))?.mcpServers?.["datasynx-opencrm"]) return true;
+			} catch {}
+		}
+		return false;
+	}
+	async install(config) {
+		const harnessFiles = [];
+		fs.mkdirSync(GEMINI_CONFIG_DIR, { recursive: true });
+		this.writeMcpEntry(SHARED_MCP_CONFIG, config);
+		if (!fs.existsSync(GEMINI_GLOBAL_MD)) {
+			fs.mkdirSync(path.dirname(GEMINI_GLOBAL_MD), { recursive: true });
+			fs.writeFileSync(GEMINI_GLOBAL_MD, buildAgyGeminiMd(config.dataDir));
+			harnessFiles.push(GEMINI_GLOBAL_MD);
+		} else if (!fs.readFileSync(GEMINI_GLOBAL_MD, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(GEMINI_GLOBAL_MD, "\n\n---\n\n" + buildAgyGeminiMdAppend());
+			harnessFiles.push(GEMINI_GLOBAL_MD + " (appended)");
+		}
+		const agentsPath = path.join(config.dataDir, "AGENTS.md");
+		fs.mkdirSync(config.dataDir, { recursive: true });
+		if (!fs.existsSync(agentsPath)) {
+			fs.writeFileSync(agentsPath, buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath);
+		} else if (!fs.readFileSync(agentsPath, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(agentsPath, "\n\n---\n\n" + buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath + " (appended)");
+		}
+		const skillDir = path.join(AGY_SKILLS_DIR, "datasynx-crm");
+		fs.mkdirSync(skillDir, { recursive: true });
+		const skillPath = path.join(skillDir, "SKILL.md");
+		fs.writeFileSync(skillPath, buildAgySkillMd());
+		harnessFiles.push(skillPath);
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: SHARED_MCP_CONFIG,
+			harnessFiles,
+			notes: "Shared config (~/.gemini/config/mcp_config.json) covers both CLI and IDE. Skill registered. GEMINI.md updated."
+		};
+	}
+	async uninstall() {
+		for (const configPath of [SHARED_MCP_CONFIG, AGY_MCP_CONFIG]) {
+			if (!fs.existsSync(configPath)) continue;
+			try {
+				const json = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+				if (json.mcpServers) {
+					delete json.mcpServers["datasynx-opencrm"];
+					delete json.mcpServers["datasynx-opencrm-http"];
+				}
+				fs.writeFileSync(configPath, JSON.stringify(json, null, 2));
+			} catch {}
+		}
+		const skillDir = path.join(AGY_SKILLS_DIR, "datasynx-crm");
+		if (fs.existsSync(skillDir)) fs.rmSync(skillDir, { recursive: true });
+	}
+	writeMcpEntry(configPath, config) {
+		let json = { mcpServers: {} };
+		if (fs.existsSync(configPath)) try {
+			json = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+			if (!json.mcpServers) json.mcpServers = {};
+		} catch {}
+		json.mcpServers["datasynx-opencrm"] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		json.mcpServers["datasynx-opencrm-http"] = { serverUrl: `http://localhost:${config.httpPort}/mcp` };
+		fs.writeFileSync(configPath, JSON.stringify(json, null, 2));
+	}
+};
+function buildAgyGeminiMdAppend() {
+	return `## DatasynxOpenCRM
+CRM MCP tools available: get_customer_context, search_customer_knowledge,
+list_customers, log_interaction, update_deal. Always load context first.`;
+}
+//#endregion
+//#region src/setup/adapters/cursor.ts
+const HOME$3 = os.homedir();
+const CURSOR_DIR = path.join(HOME$3, ".cursor");
+const CURSOR_GLOBAL_MCP = path.join(CURSOR_DIR, "mcp.json");
+var CursorAdapter = class {
+	name = "Cursor";
+	detect() {
+		return fs.existsSync(CURSOR_DIR) || fs.existsSync(CURSOR_GLOBAL_MCP);
+	}
+	isInstalled() {
+		if (!fs.existsSync(CURSOR_GLOBAL_MCP)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(CURSOR_GLOBAL_MCP, "utf-8"))?.mcpServers?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(CURSOR_DIR, { recursive: true });
+		const harnessFiles = [];
+		let json = { mcpServers: {} };
+		if (fs.existsSync(CURSOR_GLOBAL_MCP)) try {
+			json = JSON.parse(fs.readFileSync(CURSOR_GLOBAL_MCP, "utf-8"));
+			if (!json.mcpServers) json.mcpServers = {};
+		} catch {}
+		json.mcpServers["datasynx-opencrm"] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		fs.writeFileSync(CURSOR_GLOBAL_MCP, JSON.stringify(json, null, 2));
+		const rulesDir = path.join(config.dataDir, ".cursor", "rules");
+		fs.mkdirSync(rulesDir, { recursive: true });
+		const rulesPath = path.join(rulesDir, "datasynx-crm.mdc");
+		if (!fs.existsSync(rulesPath)) {
+			fs.writeFileSync(rulesPath, buildCursorRulesMdc(config.dataDir));
+			harnessFiles.push(rulesPath);
+		}
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: CURSOR_GLOBAL_MCP,
+			harnessFiles,
+			notes: "Global MCP registered. CRM rules written to .cursor/rules/. Restart Cursor to activate."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(CURSOR_GLOBAL_MCP)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(CURSOR_GLOBAL_MCP, "utf-8"));
+			if (json.mcpServers) delete json.mcpServers["datasynx-opencrm"];
+			fs.writeFileSync(CURSOR_GLOBAL_MCP, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/setup/adapters/windsurf.ts
+const HOME$2 = os.homedir();
+const WINDSURF_DIR = path.join(HOME$2, ".codeium", "windsurf");
+const WINDSURF_CONFIG = path.join(WINDSURF_DIR, "mcp_config.json");
+var WindsurfAdapter = class {
+	name = "Windsurf";
+	detect() {
+		return fs.existsSync(WINDSURF_DIR) || fs.existsSync(WINDSURF_CONFIG);
+	}
+	isInstalled() {
+		if (!fs.existsSync(WINDSURF_CONFIG)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(WINDSURF_CONFIG, "utf-8"))?.mcpServers?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(WINDSURF_DIR, { recursive: true });
+		let json = { mcpServers: {} };
+		if (fs.existsSync(WINDSURF_CONFIG)) try {
+			json = JSON.parse(fs.readFileSync(WINDSURF_CONFIG, "utf-8"));
+			if (!json.mcpServers) json.mcpServers = {};
+		} catch {}
+		json.mcpServers["datasynx-opencrm"] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		fs.writeFileSync(WINDSURF_CONFIG, JSON.stringify(json, null, 2));
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: WINDSURF_CONFIG,
+			harnessFiles: [],
+			notes: "No harness files for IDE-based tools. Restart Windsurf to activate."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(WINDSURF_CONFIG)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(WINDSURF_CONFIG, "utf-8"));
+			if (json.mcpServers) delete json.mcpServers["datasynx-opencrm"];
+			fs.writeFileSync(WINDSURF_CONFIG, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/setup/adapters/cline.ts
+const HOME$1 = os.homedir();
+const CLINE_DIR = path.join(HOME$1, ".cline");
+const CLINE_CONFIG = path.join(CLINE_DIR, "data", "settings", "cline_mcp_settings.json");
+var ClineAdapter = class {
+	name = "Cline";
+	detect() {
+		return fs.existsSync(CLINE_DIR) || fs.existsSync(CLINE_CONFIG);
+	}
+	isInstalled() {
+		if (!fs.existsSync(CLINE_CONFIG)) return false;
+		try {
+			return !!JSON.parse(fs.readFileSync(CLINE_CONFIG, "utf-8"))?.mcpServers?.["datasynx-opencrm"];
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(path.dirname(CLINE_CONFIG), { recursive: true });
+		let json = { mcpServers: {} };
+		if (fs.existsSync(CLINE_CONFIG)) try {
+			json = JSON.parse(fs.readFileSync(CLINE_CONFIG, "utf-8"));
+			if (!json.mcpServers) json.mcpServers = {};
+		} catch {}
+		json.mcpServers["datasynx-opencrm"] = {
+			command: process.execPath,
+			args: [config.mcpServerPath],
+			env: { DXCRM_DATA_DIR: config.dataDir }
+		};
+		fs.writeFileSync(CLINE_CONFIG, JSON.stringify(json, null, 2));
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: CLINE_CONFIG,
+			harnessFiles: [],
+			notes: "Cline requires absolute paths. No harness files for VSCode extensions."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(CLINE_CONFIG)) return;
+		try {
+			const json = JSON.parse(fs.readFileSync(CLINE_CONFIG, "utf-8"));
+			if (json.mcpServers) delete json.mcpServers["datasynx-opencrm"];
+			fs.writeFileSync(CLINE_CONFIG, JSON.stringify(json, null, 2));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/setup/adapters/grok.ts
+const HOME = os.homedir();
+const GROK_DIR = path.join(HOME, ".grok");
+const GROK_USER_SETTINGS = path.join(GROK_DIR, "user-settings.json");
+var GrokAdapter = class {
+	name = "Grok Build";
+	detect() {
+		try {
+			execSync("which grok", { stdio: "ignore" });
+			return true;
+		} catch {}
+		return fs.existsSync(GROK_DIR);
+	}
+	isInstalled() {
+		if (!fs.existsSync(GROK_USER_SETTINGS)) return false;
+		try {
+			return (JSON.parse(fs.readFileSync(GROK_USER_SETTINGS, "utf-8")).mcpServers ?? []).some((s) => s.name === "datasynx-opencrm");
+		} catch {
+			return false;
+		}
+	}
+	async install(config) {
+		fs.mkdirSync(GROK_DIR, { recursive: true });
+		const harnessFiles = [];
+		if (!this.isInstalled()) {
+			let settings = {};
+			if (fs.existsSync(GROK_USER_SETTINGS)) try {
+				settings = JSON.parse(fs.readFileSync(GROK_USER_SETTINGS, "utf-8"));
+			} catch {}
+			if (!settings.mcpServers) settings.mcpServers = [];
+			settings.mcpServers.push({
+				name: config.serverName,
+				transport: {
+					type: "stdio",
+					command: process.execPath,
+					args: [config.mcpServerPath],
+					env: { DXCRM_DATA_DIR: config.dataDir }
+				}
+			});
+			fs.writeFileSync(GROK_USER_SETTINGS, JSON.stringify(settings, null, 2));
+		}
+		const grokProjectDir = path.join(config.dataDir, ".grok");
+		fs.mkdirSync(grokProjectDir, { recursive: true });
+		const projectSettings = path.join(grokProjectDir, "settings.json");
+		fs.writeFileSync(projectSettings, buildGrokSettingsJson(config));
+		harnessFiles.push(projectSettings);
+		const agentsPath = path.join(config.dataDir, "AGENTS.md");
+		if (!fs.existsSync(agentsPath)) {
+			fs.writeFileSync(agentsPath, buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath);
+		} else if (!fs.readFileSync(agentsPath, "utf-8").includes("DatasynxOpenCRM")) {
+			fs.appendFileSync(agentsPath, "\n\n---\n\n" + buildAgentsMd(config.dataDir));
+			harnessFiles.push(agentsPath + " (appended)");
+		}
+		return {
+			framework: this.name,
+			success: true,
+			transport: "stdio",
+			configPath: GROK_USER_SETTINGS,
+			harnessFiles,
+			notes: "MCP registered in ~/.grok/user-settings.json (array format). Project config written to .grok/settings.json. AGENTS.md written — Grok Build reads it natively alongside CLAUDE.md."
+		};
+	}
+	async uninstall() {
+		if (!fs.existsSync(GROK_USER_SETTINGS)) return;
+		try {
+			const settings = JSON.parse(fs.readFileSync(GROK_USER_SETTINGS, "utf-8"));
+			if (settings.mcpServers) settings.mcpServers = settings.mcpServers.filter((s) => s.name !== "datasynx-opencrm");
+			fs.writeFileSync(GROK_USER_SETTINGS, JSON.stringify(settings, null, 2));
+		} catch {}
+	}
+};
+//#endregion
+//#region src/setup/framework-registry.ts
+const FRAMEWORK_ADAPTERS = [
+	new ClaudeCodeAdapter(),
+	new CodexAdapter(),
+	new GrokAdapter(),
+	new OpenClawAdapter(),
+	new HermesAdapter(),
+	new AntigravityAdapter(),
+	new CursorAdapter(),
+	new WindsurfAdapter(),
+	new ClineAdapter(),
+	new ClaudeDesktopAdapter()
+];
+async function installAllDetected(config) {
+	const results = [];
+	for (const adapter of FRAMEWORK_ADAPTERS) {
+		if (!adapter.detect()) continue;
+		try {
+			results.push(await adapter.install(config));
+		} catch (err) {
+			results.push({
+				framework: adapter.name,
+				success: false,
+				transport: "stdio",
+				configPath: "",
+				harnessFiles: [],
+				notes: err.message
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+//#region src/commands/init.ts
+const initCommand = new Command("init").description("Initialize CRM and configure AI frameworks").option("--team <url>", "Team mode: configure frameworks to connect to shared HTTP server at this URL (e.g. http://vm-ip:3847/mcp)").action(async (opts) => {
+	const dataDir = process.cwd();
+	const agenticDir = path.join(dataDir, ".agentic");
+	fs.mkdirSync(agenticDir, { recursive: true });
+	const configPath = path.join(agenticDir, "config.json");
+	if (!fs.existsSync(configPath)) fs.writeFileSync(configPath, JSON.stringify({
+		version: 1,
+		dataDir,
+		created: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2));
+	const home = os.homedir();
+	const transcriptPaths = [
+		path.join(home, "Downloads", "Fireflies"),
+		path.join(home, "Downloads", "Otter"),
+		path.join(home, "Documents", "Zoom"),
+		path.join(home, "Downloads", "Zoom")
+	].filter((p) => fs.existsSync(p));
+	const sourcesPath = path.join(agenticDir, "sources.json");
+	if (!fs.existsSync(sourcesPath)) {
+		const sources = {
+			gmail: {
+				type: "gmail",
+				query: "",
+				enabled: false
+			},
+			version: 1,
+			created: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		if (transcriptPaths.length > 0) sources.transcripts = {
+			type: "transcript",
+			paths: transcriptPaths,
+			extensions: [".txt", ".vtt"],
+			enabled: true
+		};
+		fs.writeFileSync(sourcesPath, JSON.stringify(sources, null, 2));
+	}
+	fs.mkdirSync(path.join(dataDir, "customers"), { recursive: true });
+	const schemaPath = path.join(agenticDir, "schema.json");
+	if (!fs.existsSync(schemaPath)) fs.writeFileSync(schemaPath, JSON.stringify({
+		version: 1,
+		description: "DatasynxOpenCRM validation schema for main_facts.md frontmatter",
+		main_facts: {
+			required: [
+				"name",
+				"relationship_stage",
+				"created",
+				"tags",
+				"currency"
+			],
+			properties: {
+				name: { type: "string" },
+				relationship_stage: {
+					type: "string",
+					enum: [
+						"lead",
+						"qualified",
+						"discovery",
+						"proposal",
+						"negotiation",
+						"active",
+						"churned",
+						"closed"
+					]
+				},
+				domain: { type: "string" },
+				email: {
+					type: "string",
+					format: "email"
+				},
+				created: {
+					type: "string",
+					format: "date"
+				},
+				updated: {
+					type: "string",
+					format: "date"
+				},
+				tags: {
+					type: "array",
+					items: { type: "string" }
+				},
+				currency: {
+					type: "string",
+					enum: [
+						"EUR",
+						"USD",
+						"GBP",
+						"CHF"
+					]
+				},
+				deal_value: {
+					type: "number",
+					minimum: 0
+				},
+				last_touchpoint: {
+					type: "string",
+					format: "date"
+				},
+				primary_contact: { type: "string" }
+			}
+		}
+	}, null, 2));
+	console.log(info("Detecting AI frameworks..."));
+	const mcpServerPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../dist/mcp.js");
+	if (opts.team) console.log(info(`Team mode: connecting frameworks to ${bold(opts.team)}`));
+	const results = await installAllDetected({
+		mcpServerPath,
+		dataDir,
+		httpPort: 3847,
+		serverName: "datasynx-opencrm",
+		...opts.team ? { httpUrl: opts.team } : {}
+	});
+	if (results.length === 0) console.log(info("  No AI frameworks detected. Configure manually: dxcrm guide --framework <name>"));
+	else for (const r of results) if (r.success) {
+		console.log(success(`  ✓ ${r.framework} — ${r.transport} transport`));
+		if (r.notes) console.log(`    ${r.notes}`);
+	} else console.log(error(`  ✗ ${r.framework} — ${r.notes ?? "failed"}`));
+	console.log(success(`\n✓ DatasynxOpenCRM initialized in ${bold(dataDir)}`));
+	if (opts.team) {
+		console.log(info(`  Team server: ${opts.team}`));
+		console.log(info(`  Set identity: export DXCRM_ACTOR=<your-name>`));
+	} else console.log(info(`  Next: dxcrm create "Your Customer Name"`));
+});
+//#endregion
+//#region src/commands/sync.ts
+const syncCommand = new Command("sync").argument("<slug>", "Customer slug to sync").description("Sync Gmail and transcripts for a customer").option("--since <date>", "Only sync emails/files after this date (YYYY-MM-DD)").option("--gmail", "Sync Gmail only").option("--transcripts", "Sync transcripts only").option("--provider <provider>", "Sync provider: gmail | microsoft | transcripts").action(async (slug, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const customerDir = path.join(dataDir, "customers", slug);
+	if (!fs.existsSync(customerDir)) {
+		console.error(error(`✗ Customer '${slug}' not found. Run 'dxcrm list' to see available customers.`));
+		process.exit(1);
+	}
+	const sourcesPath = path.join(customerDir, "sources.json");
+	if (!fs.existsSync(sourcesPath)) {
+		console.error(error(`✗ No sources.json found for '${slug}'.`));
+		process.exit(1);
+	}
+	const sources = JSON.parse(fs.readFileSync(sourcesPath, "utf-8"));
+	const since = opts.since ? new Date(opts.since) : /* @__PURE__ */ new Date(Date.now() - 720 * 60 * 60 * 1e3);
+	const provider = opts.provider;
+	const syncGmail = !opts.transcripts && provider !== "microsoft" && provider !== "transcripts" && provider !== "google-drive";
+	const syncMicrosoft = provider === "microsoft";
+	const syncTranscripts = !opts.gmail && provider !== "gmail" && provider !== "microsoft" && provider !== "google-drive";
+	const syncGoogleDrive = provider === "google-drive";
+	let totalSynced = 0;
+	if (syncGmail && sources.gmail?.enabled && sources.gmail.query) {
+		const tokenPath = path.join(dataDir, ".agentic", "gmail-token.json");
+		const credPath = path.join(dataDir, ".agentic", "gmail-credentials.json");
+		if (!fs.existsSync(tokenPath) || !fs.existsSync(credPath)) console.log(info("  Gmail: credentials not configured (run dxcrm sync --setup-gmail)"));
+		else try {
+			console.log(info(`  Syncing Gmail for ${bold(slug)}...`));
+			const { getGmailAuth } = await import("./gmail-auth-OComS92L.js");
+			const { syncGmail: doGmailSync } = await import("./gmail-sync-DIaxInDT.js");
+			const result = await doGmailSync({
+				slug,
+				dataDir,
+				auth: await getGmailAuth(credPath, tokenPath),
+				query: sources.gmail.query,
+				since
+			});
+			totalSynced += result.synced;
+			console.log(success(`  ✓ Gmail: +${result.synced} synced, ${result.skipped} skipped`));
+		} catch (err) {
+			console.error(error(`  ✗ Gmail sync failed: ${err.message}`));
+		}
+	} else if (syncGmail) console.log(info("  Gmail: not configured (add domain/email to sources.json)"));
+	if (syncMicrosoft) try {
+		console.log(info(`  Syncing Microsoft Outlook for ${bold(slug)}...`));
+		const { getMicrosoftToken } = await import("./microsoft-auth-B8_S45gh.js");
+		const token = await getMicrosoftToken(dataDir);
+		if (!token) console.log(info("  Microsoft: no token found (.agentic/microsoft-token.json)"));
+		else {
+			const { syncMicrosoft: doMsSync } = await import("./microsoft-sync-CpZVoSuq.js");
+			const emailResult = await doMsSync({
+				slug,
+				dataDir,
+				accessToken: token,
+				since
+			});
+			totalSynced += emailResult.synced;
+			console.log(success(`  ✓ Microsoft Email: +${emailResult.synced} synced, ${emailResult.skipped} skipped`));
+			const { syncMicrosoftCalendar } = await import("./microsoft-calendar-B6MMtUQK.js");
+			const calResult = await syncMicrosoftCalendar({
+				slug,
+				dataDir,
+				accessToken: token,
+				since
+			});
+			totalSynced += calResult.synced;
+			console.log(success(`  ✓ Microsoft Calendar: +${calResult.synced} synced, ${calResult.skipped} skipped`));
+		}
+	} catch (err) {
+		console.error(error(`  ✗ Microsoft sync failed: ${err.message}`));
+	}
+	if (syncTranscripts) {
+		const agenticSourcesPath = path.join(dataDir, ".agentic", "sources.json");
+		if (fs.existsSync(agenticSourcesPath)) try {
+			const agenticSources = JSON.parse(fs.readFileSync(agenticSourcesPath, "utf-8"));
+			if (agenticSources.transcripts?.enabled && agenticSources.transcripts.paths?.length) {
+				const { processTranscriptFile } = await import("./transcript-watcher-CL2QUygI.js");
+				const exts = agenticSources.transcripts.extensions ?? [".txt", ".vtt"];
+				let transcriptSynced = 0;
+				for (const watchPath of agenticSources.transcripts.paths) {
+					if (!fs.existsSync(watchPath)) continue;
+					const files = fs.readdirSync(watchPath).filter((f) => exts.some((ext) => f.endsWith(ext))).map((f) => path.join(watchPath, f));
+					for (const file of files) try {
+						await processTranscriptFile(file, slug, dataDir);
+						transcriptSynced++;
+					} catch {}
+				}
+				if (transcriptSynced > 0) {
+					totalSynced += transcriptSynced;
+					console.log(success(`  ✓ Transcripts: +${transcriptSynced} processed`));
+				} else console.log(info("  Transcripts: no new files"));
+			} else console.log(info("  Transcripts: not configured"));
+		} catch (err) {
+			console.error(error(`  ✗ Transcript sync failed: ${err.message}`));
+		}
+	}
+	if (syncGoogleDrive) {
+		const tokenPath = path.join(dataDir, ".agentic", "google-token.json");
+		if (!fs.existsSync(tokenPath)) console.log(info("  Google Drive: token not configured (.agentic/google-token.json)"));
+		else try {
+			const tokenData = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+			const accessToken = tokenData.accessToken ?? tokenData.access_token;
+			if (!accessToken) console.log(info("  Google Drive: accessToken not found in token file"));
+			else {
+				console.log(info(`  Syncing Google Drive for ${bold(slug)}...`));
+				const { syncGoogleDriveFiles } = await import("./google-drive-sync-DEPcqFca.js");
+				const result = await syncGoogleDriveFiles({
+					slug,
+					dataDir,
+					accessToken,
+					customerName: slug
+				});
+				totalSynced += result.synced;
+				if (result.errors.length > 0) for (const err of result.errors) console.error(error(`  ✗ Google Drive: ${err}`));
+				console.log(success(`  ✓ Google Drive: +${result.synced} synced, ${result.skipped} skipped`));
+			}
+		} catch (err) {
+			console.error(error(`  ✗ Google Drive sync failed: ${err.message}`));
+		}
+	}
+	if (totalSynced > 0) console.log(success(`\n✓ Sync complete: ${bold(String(totalSynced))} new interactions for ${bold(slug)}`));
+	else console.log(info(`\n✓ Sync complete: no new interactions for ${bold(slug)}`));
+});
+//#endregion
+//#region src/commands/daemon.ts
+function getPidFile$1() {
+	return path.join(process.cwd(), ".agentic", "daemon.pid");
+}
+const daemonCommand = new Command("daemon");
+daemonCommand.command("start").action(async () => {
+	const pidFile = getPidFile$1();
+	if (fs.existsSync(pidFile)) {
+		const pid = parseInt(fs.readFileSync(pidFile, "utf-8"), 10);
+		try {
+			process.kill(pid, 0);
+			console.log(info(`Daemon already running (PID ${pid})`));
+			return;
+		} catch {}
+	}
+	const workerPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../dist/daemon/worker.js");
+	const child = spawn(process.execPath, [workerPath], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.unref();
+	fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+	fs.writeFileSync(pidFile, String(child.pid));
+	console.log(success(`✓ Daemon started (PID ${child.pid})`));
+});
+daemonCommand.command("stop").action(() => {
+	const pidFile = getPidFile$1();
+	if (!fs.existsSync(pidFile)) {
+		console.log(info("Daemon not running."));
+		return;
+	}
+	const pid = parseInt(fs.readFileSync(pidFile, "utf-8"), 10);
+	try {
+		process.kill(pid, "SIGTERM");
+		fs.unlinkSync(pidFile);
+		console.log(success("✓ Daemon stopped."));
+	} catch (err) {
+		console.error(error(`✗ ${err.message}`));
+	}
+});
+daemonCommand.command("status").action(() => {
+	const pidFile = getPidFile$1();
+	if (!fs.existsSync(pidFile)) {
+		console.log(info("Daemon: not running."));
+		return;
+	}
+	const pid = parseInt(fs.readFileSync(pidFile, "utf-8"), 10);
+	try {
+		process.kill(pid, 0);
+		console.log(success(`Daemon: running (PID ${pid})`));
+	} catch {
+		console.log(info("Daemon: stopped (stale PID file)."));
+		fs.unlinkSync(pidFile);
+	}
+});
+//#endregion
+//#region src/commands/status.ts
+function formatAge(isoString) {
+	const diff = Date.now() - new Date(isoString).getTime();
+	const mins = Math.floor(diff / 6e4);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.floor(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+function checkDaemon(dataDir) {
+	const pidFile = path.join(dataDir, ".agentic", "daemon.pid");
+	if (!fs.existsSync(pidFile)) return { running: false };
+	try {
+		const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+		if (isNaN(pid)) return { running: false };
+		process.kill(pid, 0);
+		return {
+			running: true,
+			pid
+		};
+	} catch {
+		return { running: false };
+	}
+}
+async function fetchTeamSessions(serverUrl) {
+	try {
+		const res = await fetch(`${serverUrl.replace(/\/$/, "")}/sessions`, { signal: AbortSignal.timeout(3e3) });
+		if (!res.ok) return null;
+		return (await res.json()).sessions ?? null;
+	} catch {
+		return null;
+	}
+}
+async function runStatus(opts, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	if (opts.unmatched) {
+		const unmatched = readUnmatched(dir);
+		const sep = "─".repeat(37);
+		console.log(sep);
+		console.log(bold(" Unmatched Transcripts"));
+		console.log(sep);
+		if (unmatched.length === 0) console.log(info(" No unmatched transcripts."));
+		else for (const entry of unmatched) console.log(` ${entry.filePath}  ${entry.reason}  ${entry.addedAt}`);
+		console.log(sep);
+		return;
+	}
+	const daemon = checkDaemon(dir);
+	const slugs = listCustomerSlugs(dir);
+	const syncState = readSyncState(dir);
+	const unmatched = readUnmatched(dir);
+	const sep = "─".repeat(37);
+	console.log(sep);
+	console.log(bold(" DatasynxOpenCRM Status"));
+	console.log(sep);
+	const daemonLine = daemon.running ? success(`running (PID ${daemon.pid})`) : error("not running");
+	console.log(` Daemon:     ${daemonLine}`);
+	console.log(` Customers:  ${slugs.length} active`);
+	const session = getSession() ?? readAllSessions(dir)[0] ?? null;
+	if (session) {
+		const ownerPart = session.owner ? ` [${session.owner}]` : "";
+		console.log(` Session:    ${session.customerName} (${session.customerSlug})${ownerPart}`);
+	} else console.log(` Session:    none`);
+	if (slugs.length > 0) {
+		console.log(` Syncs:`);
+		for (const slug of slugs) {
+			const state = syncState[slug];
+			const ageStr = state?.lastGmailSync ? `Gmail ${formatAge(state.lastGmailSync)}` : "no sync yet";
+			console.log(`   ${slug}:   ${ageStr}`);
+		}
+	}
+	const unmatchedCount = unmatched.length;
+	if (unmatchedCount > 0) console.log(` Unmatched:   ${unmatchedCount} Transcript${unmatchedCount !== 1 ? "s" : ""} (dxcrm status --unmatched)`);
+	else console.log(` Unmatched:   0 Transcripts`);
+	const serverUrl = opts.team ?? process.env["DXCRM_SERVER_URL"];
+	if (serverUrl) {
+		const teamSessions = await fetchTeamSessions(serverUrl);
+		if (teamSessions && teamSessions.length > 0) {
+			console.log(bold("\n Team overview:"));
+			for (const s of teamSessions) {
+				const ownerPart = s.owner ? `${s.owner}` : "anonymous";
+				console.log(info(`   ${ownerPart.padEnd(15)} → ${s.customerName} (${s.customerSlug})`));
+			}
+		} else if (teamSessions !== null) console.log(info(" Team: no active sessions"));
+		else console.log(info(` Team: server unreachable (${serverUrl})`));
+	}
+	console.log(sep);
+}
+const statusCommand = new Command("status").description("Show CRM status: daemon, sync state, customer counts").option("--unmatched", "Show unmatched transcript queue").option("--team <url>", "Show team sessions from HTTP server (or set DXCRM_SERVER_URL)").action((opts) => runStatus(opts, process.env["DXCRM_DATA_DIR"] ?? process.cwd()));
+//#endregion
+//#region src/commands/agent.ts
+function agentsDir(dataDir) {
+	return path.join(dataDir, ".agentic", "agents");
+}
+function agentConfigPath(dataDir, slug) {
+	return path.join(agentsDir(dataDir), `${slug}.agent.json`);
+}
+async function runAgentSpawn(slug, opts, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const customerDir = path.join(dir, "customers", slug);
+	if (!fs.existsSync(customerDir)) {
+		console.error(error(`✗ Customer '${slug}' not found. Run 'dxcrm list' to see available customers.`));
+		process.exit(1);
+	}
+	const channel = opts.channel ?? "telegram";
+	const wakeOn = opts.wakeOnEmail ? ["email"] : ["email"];
+	const config = AgentConfigSchema.parse({
+		slug,
+		channel,
+		wakeOn,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		lastWake: null,
+		...opts.chatId !== void 0 ? { telegramChatId: opts.chatId } : {}
+	});
+	fs.mkdirSync(agentsDir(dir), { recursive: true });
+	fs.writeFileSync(agentConfigPath(dir, slug), JSON.stringify(config, null, 2), "utf-8");
+	console.log(success(`✓ Agent spawned: ${bold(slug)}`));
+	console.log(info(`  Channel:  ${channel}`));
+	console.log(info(`  Wake on:  ${wakeOn.join(", ")}`));
+	console.log(info(`  Config:   .agentic/agents/${slug}.agent.json`));
+	if (channel === "telegram" && !process.env["TELEGRAM_BOT_TOKEN"]) console.log(info(`\n  Note: Set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID env vars to enable Telegram messages.`));
+}
+async function runAgentStatus(dataDir) {
+	const dir2 = agentsDir(dataDir ?? process.cwd());
+	if (!fs.existsSync(dir2)) {
+		console.log(info("No agents configured. Run: dxcrm agent spawn <slug> --channel telegram"));
+		return;
+	}
+	const files = fs.readdirSync(dir2).filter((f) => f.endsWith(".agent.json"));
+	if (files.length === 0) {
+		console.log(info("No agents configured."));
+		return;
+	}
+	console.log(bold(`\n Agents (${files.length})\n`));
+	for (const file of files) try {
+		const raw = JSON.parse(fs.readFileSync(path.join(dir2, file), "utf-8"));
+		const lastWake = raw.lastWake ? `last wake: ${new Date(raw.lastWake).toLocaleString()}` : "never woken";
+		console.log(info(`  ${bold(raw.slug)} — ${raw.channel} · ${raw.wakeOn.join("+")} · ${lastWake}`));
+	} catch {
+		console.log(info(`  ${file} (malformed)`));
+	}
+	console.log("");
+}
+async function runAgentRemove(slug, dataDir) {
+	const configPath = agentConfigPath(dataDir ?? process.cwd(), slug);
+	if (!fs.existsSync(configPath)) {
+		console.error(error(`✗ No agent config found for '${slug}'.`));
+		process.exit(1);
+	}
+	fs.unlinkSync(configPath);
+	console.log(success(`✓ Agent removed: ${slug}`));
+}
+const agentCommand = new Command("agent").description("Manage per-customer agents");
+agentCommand.command("spawn <slug>").description("Spawn a wake-triggered agent for a customer").option("--channel <channel>", "Notification channel (telegram)", "telegram").option("--wake-on-email", "Wake agent on new email (default: on)").option("--chat-id <chatId>", "Telegram chat ID override").action((slug, opts) => runAgentSpawn(slug, opts, process.env["DXCRM_DATA_DIR"]));
+agentCommand.command("status").description("Show all configured agents").action(() => runAgentStatus(process.env["DXCRM_DATA_DIR"]));
+agentCommand.command("remove <slug>").description("Remove agent config for a customer").action((slug) => runAgentRemove(slug, process.env["DXCRM_DATA_DIR"]));
+//#endregion
+//#region src/commands/import.ts
+/** Map a Salesforce StageName to opencrm's fixed pipeline stage enum. */
+function mapSalesforceStage(stageName) {
+	const s = (stageName ?? "").toLowerCase();
+	if (s.includes("won")) return "won";
+	if (s.includes("lost")) return "lost";
+	if (s.includes("negoti")) return "negotiation";
+	if (s.includes("propos") || s.includes("quote")) return "proposal";
+	if (s.includes("qualif")) return "qualified";
+	return "lead";
+}
+/** Map a Salesforce Case Status to opencrm's ticket status enum. */
+function mapCaseStatus(status) {
+	const s = (status ?? "").toLowerCase();
+	if (s.includes("closed")) return "closed";
+	if (s.includes("resolved")) return "resolved";
+	if (s.includes("escalat") || s.includes("wait") || s.includes("hold")) return "waiting";
+	if (s.includes("working") || s.includes("progress")) return "in-progress";
+	return "open";
+}
+/** Map a Salesforce Case Priority to opencrm's ticket priority enum. */
+function mapCasePriority(priority) {
+	const p = (priority ?? "").toLowerCase();
+	if (p.includes("urgent") || p.includes("critical")) return "urgent";
+	if (p.includes("high")) return "high";
+	if (p.includes("low")) return "low";
+	return "normal";
+}
+function hashRow(row) {
+	return createHash("sha256").update(JSON.stringify(row)).digest("hex").slice(0, 16);
+}
+function slugify$1(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+function parseCSV(content) {
+	const lines = content.trim().split("\n");
+	if (lines.length < 2) return [];
+	const headers = (lines[0] ?? "").split(",").map((h) => h.trim().replace(/^"|"$/g, ""));
+	return lines.slice(1).map((line) => {
+		const values = line.split(",").map((v) => v.trim().replace(/^"|"$/g, ""));
+		const row = {};
+		headers.forEach((h, i) => {
+			row[h] = values[i] ?? "";
+		});
+		return row;
+	});
+}
+const IMPORT_TARGET_FIELDS = [
+	"name",
+	"email",
+	"domain",
+	"notes",
+	"date",
+	"activityType",
+	"sourceId"
+];
+function ensureCustomer(dataDir, name, domain, email, dryRun) {
+	const slug = slugify$1(name || "unknown");
+	const customerDir = path.join(dataDir, "customers", slug);
+	const mainFactsPath = path.join(customerDir, "main_facts.md");
+	if (fs.existsSync(mainFactsPath)) return {
+		slug,
+		created: false
+	};
+	if (dryRun) return {
+		slug,
+		created: true
+	};
+	fs.mkdirSync(customerDir, { recursive: true });
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const frontmatter = [
+		"---",
+		`name: ${name}`,
+		domain ? `domain: ${domain}` : null,
+		email ? `email: ${email}` : null,
+		"relationship_stage: prospect",
+		`created: ${today}`,
+		`updated: ${today}`,
+		`last_touchpoint: ${today}`,
+		"tags: []",
+		"---"
+	].filter(Boolean).join("\n");
+	fs.writeFileSync(mainFactsPath, `${frontmatter}\n\n# Customer: ${name}\n`, "utf-8");
+	fs.writeFileSync(path.join(customerDir, "interactions.md"), `# Interactions — ${name}\n\n`, "utf-8");
+	fs.writeFileSync(path.join(customerDir, "pipeline.md"), `# Pipeline — ${name}\n\n`, "utf-8");
+	fs.writeFileSync(path.join(customerDir, "sources.json"), JSON.stringify({
+		gmail: {
+			query: domain ? `from:${domain} OR to:${domain}` : email ? `from:${email} OR to:${email}` : "",
+			enabled: true
+		},
+		transcripts: {
+			paths: [],
+			extensions: [".txt", ".vtt"],
+			enabled: false
+		}
+	}, null, 2), "utf-8");
+	return {
+		slug,
+		created: true
+	};
+}
+function readCsvFromDirectory(dirPath, filename) {
+	const variants = [
+		filename,
+		filename.toLowerCase(),
+		filename.toUpperCase()
+	];
+	for (const name of variants) {
+		const p = path.join(dirPath, name);
+		if (fs.existsSync(p)) return fs.readFileSync(p, "utf-8");
+	}
+	const match = fs.readdirSync(dirPath).find((f) => f.toLowerCase() === filename.toLowerCase());
+	if (match) return fs.readFileSync(path.join(dirPath, match), "utf-8");
+	return null;
+}
+async function extractZip(zipPath) {
+	const AdmZip = (await import("adm-zip")).default;
+	const zip = new AdmZip(zipPath);
+	const tmpDir = `${zipPath}.extracted`;
+	fs.mkdirSync(tmpDir, { recursive: true });
+	zip.extractAllTo(tmpDir, true);
+	return tmpDir;
+}
+async function runSalesforceFileImport(sourcePath, opts, dir) {
+	const result = {
+		customersCreated: 0,
+		interactionsImported: 0,
+		skipped: 0,
+		errors: []
+	};
+	let dataDir = sourcePath;
+	let tmpDir = null;
+	if (sourcePath.endsWith(".zip")) {
+		tmpDir = await extractZip(sourcePath);
+		dataDir = tmpDir;
+	}
+	if (!fs.statSync(dataDir).isDirectory()) {
+		result.errors.push("Salesforce file import requires a directory or .zip file");
+		return result;
+	}
+	const accountsCsv = readCsvFromDirectory(dataDir, "Accounts.csv") ?? readCsvFromDirectory(dataDir, "accounts.csv");
+	const activitiesCsv = readCsvFromDirectory(dataDir, "Activities.csv") ?? readCsvFromDirectory(dataDir, "activities.csv") ?? readCsvFromDirectory(dataDir, "Tasks.csv") ?? readCsvFromDirectory(dataDir, "tasks.csv");
+	if (!accountsCsv) {
+		result.errors.push("Could not find Accounts.csv in Salesforce export");
+		if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+		return result;
+	}
+	const accounts = parseCSV(accountsCsv);
+	const activities = activitiesCsv ? parseCSV(activitiesCsv) : [];
+	if (opts.dryRun) {
+		console.log(info(`Dry run — ${accounts.length} accounts, ${activities.length} activities from Salesforce export`));
+		if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+		return result;
+	}
+	const slugMap = /* @__PURE__ */ new Map();
+	for (const row of accounts) {
+		const name = (row["Name"] ?? row["Account Name"] ?? "").trim();
+		if (!name) continue;
+		const domain = (row["Website"] ?? "").replace(/^https?:\/\//, "");
+		const email = row["Email"] ?? "";
+		try {
+			const { slug, created } = ensureCustomer(dir, name, domain, email, false);
+			if (row["Id"]) slugMap.set(row["Id"], slug);
+			slugMap.set(name.toLowerCase(), slug);
+			if (created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Account '${name}': ${err.message}`);
+		}
+	}
+	for (const row of activities) {
+		const accountId = row["AccountId"] ?? row["WhatId"] ?? "";
+		const slug = accountId ? slugMap.get(accountId) : void 0;
+		if (!slug) continue;
+		const id = row["Id"] ?? hashRow(row);
+		const sourceRef = `salesforce://row/${id}`;
+		const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = row["ActivityDate"] ?? row["CreatedDate"] ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const notes = (row["Description"] ?? row["Subject"] ?? "").slice(0, 500);
+		const t = (row["Type"] ?? "").toLowerCase();
+		const type = t.includes("call") ? "Call" : t.includes("email") ? "Email" : t.includes("meeting") ? "Meeting" : "Note";
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type,
+				with: slug,
+				summary: notes,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.interactionsImported++;
+		} catch (err) {
+			result.errors.push(`Activity ${id}: ${err.message}`);
+		}
+	}
+	if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+	return result;
+}
+async function runPipedriveFileImport(sourcePath, opts, dir) {
+	const result = {
+		customersCreated: 0,
+		interactionsImported: 0,
+		skipped: 0,
+		errors: []
+	};
+	let dataDir = sourcePath;
+	let tmpDir = null;
+	if (sourcePath.endsWith(".zip")) {
+		tmpDir = await extractZip(sourcePath);
+		dataDir = tmpDir;
+	}
+	if (!fs.statSync(dataDir).isDirectory()) {
+		result.errors.push("Pipedrive file import requires a directory or .zip file");
+		return result;
+	}
+	const orgsCsv = readCsvFromDirectory(dataDir, "organizations.csv") ?? readCsvFromDirectory(dataDir, "Organizations.csv");
+	const activitiesCsv = readCsvFromDirectory(dataDir, "activities.csv") ?? readCsvFromDirectory(dataDir, "Activities.csv");
+	if (!orgsCsv) {
+		result.errors.push("Could not find organizations.csv in Pipedrive export");
+		if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+		return result;
+	}
+	const orgs = parseCSV(orgsCsv);
+	const activities = activitiesCsv ? parseCSV(activitiesCsv) : [];
+	if (opts.dryRun) {
+		console.log(info(`Dry run — ${orgs.length} organizations, ${activities.length} activities from Pipedrive export`));
+		if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+		return result;
+	}
+	const slugMap = /* @__PURE__ */ new Map();
+	for (const row of orgs) {
+		const name = (row["name"] ?? row["Name"] ?? "").trim();
+		if (!name) continue;
+		const id = row["id"] ?? row["ID"] ?? "";
+		try {
+			const { slug, created } = ensureCustomer(dir, name, "", "", false);
+			if (id) slugMap.set(id, slug);
+			slugMap.set(name.toLowerCase(), slug);
+			if (created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Organization '${name}': ${err.message}`);
+		}
+	}
+	for (const row of activities) {
+		const orgId = row["org_id"] ?? row["organization_id"] ?? "";
+		const slug = orgId ? slugMap.get(orgId) : void 0;
+		if (!slug) continue;
+		const id = row["id"] ?? hashRow(row);
+		const sourceRef = `pipedrive://row/${id}`;
+		const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = row["due_date"] ?? row["add_time"]?.slice(0, 10) ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const notes = (row["note"] ?? row["subject"] ?? "").slice(0, 500);
+		const t = (row["type"] ?? "").toLowerCase();
+		const type = t === "call" ? "Call" : t === "email" ? "Email" : t === "meeting" ? "Meeting" : "Note";
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type,
+				with: slug,
+				summary: notes,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.interactionsImported++;
+		} catch (err) {
+			result.errors.push(`Activity ${id}: ${err.message}`);
+		}
+	}
+	if (tmpDir) fs.rmSync(tmpDir, { recursive: true });
+	return result;
+}
+async function runImport(sourcePath, opts, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const result = {
+		customersCreated: 0,
+		interactionsImported: 0,
+		skipped: 0,
+		errors: []
+	};
+	if (opts.from === "salesforce" && opts.mode === "api") return runSalesforceApiImport(opts, dir);
+	if (opts.from === "pipedrive" && opts.mode === "api") return runPipedriveApiImport(opts, dir);
+	if (opts.from === "hubspot" && sourcePath && fs.existsSync(sourcePath) && fs.statSync(sourcePath).isDirectory()) {
+		const { runHubSpotCsvImport } = await import("./import-hubspot-BaK71U_K.js");
+		const r = await runHubSpotCsvImport(sourcePath, dir, {
+			...opts.dryRun ? { dryRun: true } : {},
+			...opts.resume ? { resume: true } : {},
+			ownerMap: opts.ownerMap ?? {}
+		});
+		if (r.customPropertiesSaved > 0) console.error(`[import] Custom properties saved: ${r.customPropertiesSaved}`);
+		if (r.ownersResolved > 0) console.error(`[import] Owners resolved: ${r.ownersResolved}`);
+		return {
+			customersCreated: r.companiesProcessed,
+			interactionsImported: r.engagementsImported + r.dealsImported + r.contactsImported,
+			skipped: 0,
+			errors: r.errors
+		};
+	}
+	if (opts.from === "salesforce" && sourcePath) return runSalesforceFileImport(sourcePath, opts, dir);
+	if (opts.from === "pipedrive" && sourcePath) return runPipedriveFileImport(sourcePath, opts, dir);
+	if (!fs.existsSync(sourcePath)) {
+		console.error(error(`✗ File not found: ${sourcePath}`));
+		process.exit(1);
+	}
+	const rows = parseCSV(fs.readFileSync(sourcePath, "utf-8"));
+	if (rows.length === 0) {
+		console.log(info("No rows found in CSV."));
+		return result;
+	}
+	const headers = Object.keys(rows[0]);
+	const { mapCsvFields } = await import("./llm-DEjWcqmW.js");
+	const mapping = await mapCsvFields(headers, [...IMPORT_TARGET_FIELDS]);
+	if (opts.dryRun) {
+		console.log(info(`Dry run — ${rows.length} rows, field mapping:`));
+		Object.entries(mapping).forEach(([k, v]) => v && console.log(info(`  ${k} ← "${v}"`)));
+		console.log(info(`\nWould create up to ${rows.length} customers and interaction entries.`));
+		return result;
+	}
+	const customerRows = rows.filter((r) => {
+		return (r[mapping.name ?? ""] ?? "").trim().length > 0;
+	});
+	const slugMap = /* @__PURE__ */ new Map();
+	for (const row of customerRows) {
+		const name = (row[mapping.name ?? ""] ?? "").trim();
+		if (!name) continue;
+		const domain = (row[mapping.domain ?? ""] ?? "").trim();
+		const email = (row[mapping.email ?? ""] ?? "").trim();
+		try {
+			const { slug, created } = ensureCustomer(dir, name, domain, email, opts.dryRun ?? false);
+			slugMap.set(name.toLowerCase(), slug);
+			if (created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Customer '${name}': ${err.message}`);
+		}
+	}
+	for (const row of rows) {
+		const activityType = (row[mapping["activityType"] ?? ""] ?? "").trim();
+		const notes = (row[mapping["notes"] ?? ""] ?? "").trim();
+		const activityDate = (row[mapping["date"] ?? ""] ?? "").trim();
+		const sourceIdVal = (row[mapping["sourceId"] ?? ""] ?? "").trim();
+		const name = (row[mapping["name"] ?? ""] ?? "").trim();
+		if (!notes && !activityType) continue;
+		const slug = slugMap.get(name.toLowerCase());
+		if (!slug) continue;
+		const rowHash = hashRow(row);
+		const prefix = opts.from === "hubspot" ? "hubspot" : "csv";
+		const sourceRef = sourceIdVal ? `${prefix}://activity/${sourceIdVal}` : `${prefix}://row/${rowHash}`;
+		const date = activityDate ? (() => {
+			try {
+				return new Date(activityDate).toISOString().slice(0, 10);
+			} catch {
+				return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+			}
+		})() : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const type = (() => {
+			const t = activityType.toLowerCase();
+			if (t.includes("call")) return "Call";
+			if (t.includes("meeting") || t.includes("demo")) return "Meeting";
+			if (t.includes("email")) return "Email";
+			if (t.includes("note")) return "Note";
+			return "Note";
+		})();
+		try {
+			const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+			if ((await readInteractions(dir, slug)).includes(sourceRef)) {
+				result.skipped++;
+				continue;
+			}
+			await appendInteraction(dir, slug, {
+				date,
+				type,
+				with: name,
+				summary: notes.slice(0, 500),
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.interactionsImported++;
+		} catch (err) {
+			result.errors.push(`Activity for '${name}': ${err.message}`);
+		}
+	}
+	return result;
+}
+async function runSalesforceApiImport(opts, dir) {
+	const result = {
+		customersCreated: 0,
+		interactionsImported: 0,
+		skipped: 0,
+		errors: []
+	};
+	const token = opts.token ?? process.env["SFDC_TOKEN"] ?? "";
+	const instanceUrl = opts.url ?? process.env["SFDC_URL"] ?? "";
+	if (!token || !instanceUrl) {
+		console.error(error("✗ Salesforce API mode requires --token and --url (or SFDC_TOKEN + SFDC_URL env vars)"));
+		process.exit(1);
+	}
+	const { fetchSalesforceContacts, fetchSalesforceTasks, fetchSalesforceOpportunities, fetchSalesforceLeads, fetchSalesforceEvents, fetchSalesforceCases, fetchSalesforceLineItems, fetchSalesforceNotes, fetchSalesforceCampaignMembers } = await import("./salesforce-client-rhZFa_p5.js");
+	let contacts;
+	let tasks;
+	let opportunities;
+	let leads;
+	let events;
+	let cases;
+	let lineItems;
+	let notes;
+	let campaignMembers;
+	try {
+		contacts = await fetchSalesforceContacts(instanceUrl, token);
+		tasks = await fetchSalesforceTasks(instanceUrl, token);
+		opportunities = await fetchSalesforceOpportunities(instanceUrl, token) ?? [];
+		leads = await fetchSalesforceLeads(instanceUrl, token) ?? [];
+		events = await fetchSalesforceEvents(instanceUrl, token) ?? [];
+		cases = await fetchSalesforceCases(instanceUrl, token) ?? [];
+		lineItems = await fetchSalesforceLineItems(instanceUrl, token) ?? [];
+		notes = await fetchSalesforceNotes(instanceUrl, token) ?? [];
+		campaignMembers = await fetchSalesforceCampaignMembers(instanceUrl, token) ?? [];
+	} catch (err) {
+		result.errors.push(`Salesforce API: ${err.message}`);
+		return result;
+	}
+	if (opts.dryRun) {
+		console.log(info(`Dry run — ${contacts.length} contacts, ${tasks.length} tasks, ${opportunities.length} opportunities, ${leads.length} leads, ${events.length} events, ${cases.length} cases from Salesforce`));
+		return result;
+	}
+	const slugMap = /* @__PURE__ */ new Map();
+	for (const contact of contacts) {
+		const name = contact.Name?.trim();
+		if (!name) continue;
+		const domain = contact.Account?.Website?.replace(/^https?:\/\//, "") ?? "";
+		const email = contact.Email ?? "";
+		try {
+			const { slug, created } = ensureCustomer(dir, name, domain, email, false);
+			slugMap.set(contact.Id, slug);
+			slugMap.set(name.toLowerCase(), slug);
+			if (created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Contact '${name}': ${err.message}`);
+		}
+	}
+	for (const task of tasks) {
+		const slug = task.WhoId ? slugMap.get(task.WhoId) : void 0;
+		if (!slug) continue;
+		const sourceRef = `salesforce://task/${task.Id}`;
+		const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = task.ActivityDate ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const notes = (task.Description ?? task.Subject ?? "").slice(0, 500);
+		const t = (task.Type ?? "").toLowerCase();
+		const type = t.includes("call") ? "Call" : t.includes("email") ? "Email" : t.includes("meeting") ? "Meeting" : "Note";
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type,
+				with: slug,
+				summary: notes,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.interactionsImported++;
+		} catch (err) {
+			result.errors.push(`Task ${task.Id}: ${err.message}`);
+		}
+	}
+	const { upsertDeal } = await import("./pipeline-writer-BqBrYrQc.js");
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const oppSlugById = /* @__PURE__ */ new Map();
+	for (const opp of opportunities) {
+		const accountName = opp.Account?.Name?.trim();
+		if (!opp.Name || !accountName) continue;
+		let slug = slugMap.get(accountName.toLowerCase());
+		if (!slug) {
+			const domain = opp.Account?.Website?.replace(/^https?:\/\//, "") ?? "";
+			try {
+				const r = ensureCustomer(dir, accountName, domain, "", false);
+				slug = r.slug;
+				slugMap.set(accountName.toLowerCase(), slug);
+				if (r.created) result.customersCreated++;
+			} catch (err) {
+				result.errors.push(`Opportunity '${opp.Name}': ${err.message}`);
+				continue;
+			}
+		}
+		oppSlugById.set(opp.Id, {
+			slug,
+			dealName: opp.Name
+		});
+		try {
+			await upsertDeal(dir, slug, {
+				name: opp.Name,
+				stage: mapSalesforceStage(opp.StageName),
+				currency: "EUR",
+				updated: today,
+				notes: `Imported from Salesforce (${opp.StageName ?? "unknown stage"})`,
+				...typeof opp.Amount === "number" ? { value: opp.Amount } : {},
+				...typeof opp.Probability === "number" ? { probability: opp.Probability } : {},
+				...opp.CloseDate ? { close_date: opp.CloseDate } : {}
+			});
+			result.dealsImported = (result.dealsImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`Opportunity '${opp.Name}': ${err.message}`);
+		}
+	}
+	const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+	for (const lead of leads) {
+		const name = lead.Company?.trim() || lead.Name?.trim();
+		if (!name) continue;
+		const domain = lead.Website?.replace(/^https?:\/\//, "") ?? lead.Email?.split("@")[1] ?? "";
+		let slug;
+		try {
+			const r = ensureCustomer(dir, name, domain, lead.Email ?? "", false);
+			slug = r.slug;
+			slugMap.set(name.toLowerCase(), slug);
+			if (r.created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Lead '${name}': ${err.message}`);
+			continue;
+		}
+		const sourceRef = `salesforce://lead/${lead.Id}`;
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const contactPart = lead.Title ? `${lead.Name}, ${lead.Title}` : lead.Name;
+		try {
+			await appendInteraction(dir, slug, {
+				date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+				type: "Note",
+				with: lead.Name,
+				summary: `Salesforce Lead imported (status: ${lead.Status ?? "n/a"}; contact: ${contactPart})`,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.leadsImported = (result.leadsImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`Lead ${lead.Id}: ${err.message}`);
+		}
+	}
+	for (const event of events) {
+		const slug = event.WhoId ? slugMap.get(event.WhoId) : event.WhatId ? slugMap.get(event.WhatId) : void 0;
+		if (!slug) {
+			result.skipped++;
+			continue;
+		}
+		const sourceRef = `salesforce://event/${event.Id}`;
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = (event.StartDateTime ?? event.ActivityDate ?? (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10);
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type: "Meeting",
+				with: slug,
+				subject: event.Subject ?? "Salesforce Event",
+				summary: (event.Description ?? event.Subject ?? "").slice(0, 500),
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.eventsImported = (result.eventsImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`Event ${event.Id}: ${err.message}`);
+		}
+	}
+	const { readTickets, upsertTicket, nextTicketId } = await import("./ticket-writer-CjqKeIRD.js");
+	const { calcSlaDue, loadSlaRules } = await import("./sla-engine-5IhTsBUR.js");
+	const slaRules = loadSlaRules(dir);
+	for (const c of cases) {
+		const accountName = c.Account?.Name?.trim();
+		if (!accountName) {
+			result.skipped++;
+			continue;
+		}
+		let slug = slugMap.get(accountName.toLowerCase());
+		if (!slug) try {
+			const r = ensureCustomer(dir, accountName, "", "", false);
+			slug = r.slug;
+			slugMap.set(accountName.toLowerCase(), slug);
+			if (r.created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Case '${c.Id}': ${err.message}`);
+			continue;
+		}
+		if (c.AccountId) slugMap.set(c.AccountId, slug);
+		if (c.ContactId) slugMap.set(c.ContactId, slug);
+		const caseRef = `salesforce://case/${c.Id}`;
+		const existingTickets = await readTickets(dir, slug);
+		if (existingTickets.some((t) => (t.description ?? "").includes(caseRef))) {
+			result.skipped++;
+			continue;
+		}
+		const created = (c.CreatedDate ?? (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10);
+		const status = mapCaseStatus(c.Status);
+		const priority = mapCasePriority(c.Priority);
+		const isDone = status === "closed" || status === "resolved";
+		try {
+			await upsertTicket(dir, slug, {
+				id: nextTicketId(existingTickets),
+				title: c.Subject ?? `Case ${c.CaseNumber ?? c.Id}`,
+				status,
+				priority,
+				created,
+				slaDue: calcSlaDue(created, priority, slaRules),
+				description: `${c.Description ?? ""}\n\n[${caseRef}]`.trim(),
+				...isDone ? { resolved: (c.ClosedDate ?? created).slice(0, 10) } : {}
+			});
+			result.casesImported = (result.casesImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`Case ${c.Id}: ${err.message}`);
+		}
+	}
+	if (lineItems.length > 0 && oppSlugById.size > 0) {
+		const { generateQuote, listQuotes } = await import("./quote-generator-OhSFsi3x.js");
+		const byOpp = /* @__PURE__ */ new Map();
+		for (const li of lineItems) {
+			if (!li.OpportunityId) continue;
+			const arr = byOpp.get(li.OpportunityId) ?? [];
+			arr.push(li);
+			byOpp.set(li.OpportunityId, arr);
+		}
+		for (const [oppId, items] of byOpp) {
+			const opp = oppSlugById.get(oppId);
+			if (!opp) continue;
+			if (listQuotes(dir, opp.slug).some((q) => q.dealName === opp.dealName)) {
+				result.skipped++;
+				continue;
+			}
+			const quoteLineItems = items.map((li) => {
+				const quantity = typeof li.Quantity === "number" && li.Quantity > 0 ? li.Quantity : 1;
+				const unitPrice = typeof li.UnitPrice === "number" ? li.UnitPrice : typeof li.TotalPrice === "number" ? li.TotalPrice / quantity : 0;
+				return {
+					description: li.Product2?.Name ?? li.Description ?? "Line item",
+					quantity,
+					unitPrice
+				};
+			});
+			try {
+				await generateQuote(dir, {
+					slug: opp.slug,
+					dealName: opp.dealName,
+					lineItems: quoteLineItems
+				});
+				result.quotesImported = (result.quotesImported ?? 0) + 1;
+			} catch (err) {
+				result.errors.push(`LineItems for '${opp.dealName}': ${err.message}`);
+			}
+		}
+	}
+	for (const note of notes) {
+		const slug = note.ParentId ? slugMap.get(note.ParentId) : void 0;
+		if (!slug) {
+			result.skipped++;
+			continue;
+		}
+		const sourceRef = `salesforce://note/${note.Id}`;
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = (note.CreatedDate ?? (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10);
+		const title = note.Title ?? "Salesforce Note";
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type: "Note",
+				with: slug,
+				subject: title,
+				summary: `${title}${note.Body ? `: ${note.Body}` : ""}`.slice(0, 500),
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.notesImported = (result.notesImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`Note ${note.Id}: ${err.message}`);
+		}
+	}
+	for (const cm of campaignMembers) {
+		const slug = cm.ContactId ? slugMap.get(cm.ContactId) : cm.LeadId ? slugMap.get(cm.LeadId) : void 0;
+		if (!slug) {
+			result.skipped++;
+			continue;
+		}
+		const sourceRef = `salesforce://campaignmember/${cm.Id}`;
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const campaignName = cm.Campaign?.Name ?? cm.CampaignId ?? "Unknown campaign";
+		try {
+			await appendInteraction(dir, slug, {
+				date: (cm.CreatedDate ?? (/* @__PURE__ */ new Date()).toISOString()).slice(0, 10),
+				type: "Note",
+				with: slug,
+				subject: `Campaign: ${campaignName}`,
+				summary: `Salesforce Campaign: ${campaignName} (status: ${cm.Status ?? "n/a"})`,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.campaignsImported = (result.campaignsImported ?? 0) + 1;
+		} catch (err) {
+			result.errors.push(`CampaignMember ${cm.Id}: ${err.message}`);
+		}
+	}
+	return result;
+}
+async function runPipedriveApiImport(opts, dir = process.cwd()) {
+	const result = {
+		customersCreated: 0,
+		interactionsImported: 0,
+		skipped: 0,
+		errors: []
+	};
+	const token = opts.token ?? process.env["PIPEDRIVE_TOKEN"] ?? "";
+	const instanceUrl = opts.url ?? process.env["PIPEDRIVE_URL"] ?? "";
+	if (!token || !instanceUrl) {
+		result.errors.push("Pipedrive API mode requires --token and --url (or PIPEDRIVE_TOKEN + PIPEDRIVE_URL env vars)");
+		return result;
+	}
+	const { fetchPipedrivePersons, fetchPipedriveActivities } = await import("./pipedrive-client-CdGKpH9b.js");
+	let persons;
+	let activities;
+	try {
+		[persons, activities] = await Promise.all([fetchPipedrivePersons(instanceUrl, token), fetchPipedriveActivities(instanceUrl, token)]);
+	} catch (err) {
+		result.errors.push(`Pipedrive API: ${err.message}`);
+		return result;
+	}
+	if (opts.dryRun) {
+		console.log(info(`Dry run — ${persons.length} persons, ${activities.length} activities from Pipedrive`));
+		return result;
+	}
+	const slugByPersonId = /* @__PURE__ */ new Map();
+	const slugByOrgId = /* @__PURE__ */ new Map();
+	for (const person of persons) {
+		const name = (person.org_name ?? person.name ?? "").trim();
+		if (!name) continue;
+		const email = person.primary_email ?? "";
+		try {
+			const { slug, created } = ensureCustomer(dir, name, "", email, false);
+			if (person.id) slugByPersonId.set(person.id, slug);
+			if (person.org_id?.value) slugByOrgId.set(person.org_id.value, slug);
+			if (created) result.customersCreated++;
+		} catch (err) {
+			result.errors.push(`Person '${name}': ${err.message}`);
+		}
+	}
+	for (const activity of activities) {
+		const slug = (activity.person_id && slugByPersonId.get(activity.person_id)) ?? (activity.org_id && slugByOrgId.get(activity.org_id)) ?? void 0;
+		if (!slug) continue;
+		const sourceRef = `pipedrive://activity/${activity.id}`;
+		const { readInteractions } = await import("./interactions-writer-dSPy1XfO.js");
+		if ((await readInteractions(dir, slug).catch(() => "")).includes(sourceRef)) {
+			result.skipped++;
+			continue;
+		}
+		const date = activity.due_date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const notes = (activity.note ?? activity.subject ?? "").slice(0, 500);
+		const t = (activity.type ?? "").toLowerCase();
+		const type = t === "call" ? "Call" : t === "email" ? "Email" : t === "meeting" ? "Meeting" : "Note";
+		try {
+			await appendInteraction(dir, slug, {
+				date,
+				type,
+				with: slug,
+				summary: `${activity.subject ?? type}: ${notes}`,
+				nextSteps: [],
+				sourceRef,
+				synced: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			result.interactionsImported++;
+		} catch (err) {
+			result.errors.push(`Activity ${activity.id}: ${err.message}`);
+		}
+	}
+	return result;
+}
+const importCommand = new Command("import").description("Import customers and interactions from HubSpot, Salesforce, Pipedrive, or CSV").argument("[path]", "Path to export file or directory").option("--from <source>", "Source CRM: hubspot | csv | salesforce | pipedrive", "csv").option("--dry-run", "Preview what would be imported without writing").option("--mode <mode>", "Import mode: file | api").option("--token <token>", "API token (Salesforce, Pipedrive, HubSpot)").option("--url <url>", "Instance URL (e.g. https://myco.salesforce.com)").option("--analyze", "Analyze export and show what would be imported (no write)").option("--resume", "Resume a previously interrupted import").option("--owner-map <mapping>", "Map HubSpot owner emails to reps: \"alice@hs.com=alice,bob@hs.com=bob\"").action(async (sourcePath, opts) => {
+	const dryRun = opts.dryRun ?? false;
+	const ownerMap = {};
+	if (opts.ownerMap) for (const pair of opts.ownerMap.split(",")) {
+		const [hs, rep] = pair.split("=");
+		if (hs && rep) ownerMap[hs.trim()] = rep.trim();
+	}
+	if (opts.analyze && opts.from === "hubspot" && sourcePath) {
+		const { analyzeHubSpotExport } = await import("./import-hubspot-BaK71U_K.js");
+		const analysis = await analyzeHubSpotExport(sourcePath);
+		console.log(bold("\nDatasynxOpenCRM — HubSpot Import Analysis"));
+		console.log("==========================================");
+		console.log(info(`Companies:      ${analysis.companiesFound}`));
+		console.log(info(`Contacts:       ${analysis.contactsFound} (${analysis.unmappedContacts} unmapped companies)`));
+		console.log(info(`Deals:          ${analysis.dealsFound}`));
+		console.log(info(`Engagements:    ${analysis.engagementsFound}`));
+		if (analysis.customPropertiesDetected.length > 0) {
+			console.log(info(`\nCustom Properties: ${analysis.customPropertiesDetected.length} detected`));
+			console.log(`  ${analysis.customPropertiesDetected.slice(0, 10).join(", ")}${analysis.customPropertiesDetected.length > 10 ? " ..." : ""}`);
+		}
+		if (analysis.ownersDetected.length > 0) {
+			console.log(info(`\nOwners detected: ${analysis.ownersDetected.join(", ")}`));
+			console.log(`  Use --owner-map "${analysis.ownersDetected.map((o) => `${o}=<rep>`).join(",")}"`);
+		}
+		if (analysis.unknownStages.length > 0) console.log(info(`\nUnknown stages (→ "qualified"): ${analysis.unknownStages.join(", ")}`));
+		console.log(info(`\nEstimated import time: ~${analysis.estimatedMinutes} min`));
+		console.log(info(`\nRun without --analyze to start import.`));
+		return;
+	}
+	if (!dryRun) console.log(info(`Importing from ${bold(opts.from)}: ${sourcePath}`));
+	const result = await runImport(sourcePath, {
+		from: opts.from,
+		...dryRun ? { dryRun: true } : {},
+		...opts.mode ? { mode: opts.mode } : {},
+		...opts.token ? { token: opts.token } : {},
+		...opts.url ? { url: opts.url } : {},
+		...opts.resume ? { resume: true } : {},
+		ownerMap
+	}, process.env["DXCRM_DATA_DIR"]);
+	if (!dryRun) {
+		console.log(success(`✓ Import complete:`));
+		console.log(info(`  Customers created:      ${result.customersCreated}`));
+		console.log(info(`  Interactions imported:  ${result.interactionsImported}`));
+		console.log(info(`  Skipped (duplicates):   ${result.skipped}`));
+		if (result.errors.length > 0) {
+			console.log(error(`  Errors (${result.errors.length}):`));
+			result.errors.slice(0, 5).forEach((e) => console.log(error(`    ${e}`)));
+		}
+	}
+});
+//#endregion
+//#region src/commands/server.ts
+function getPidFile(dataDir) {
+	return path.join(dataDir, ".agentic", "server.pid");
+}
+async function runServerStart(opts, dataDir) {
+	const port = parseInt(opts.port ?? "3847", 10);
+	const dir = opts.data ?? dataDir ?? process.cwd();
+	if (opts.data) process.env["DXCRM_DATA_DIR"] = opts.data;
+	const pidFile = getPidFile(dir);
+	if (fs.existsSync(pidFile)) {
+		const existing = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+		if (!isNaN(existing)) try {
+			process.kill(existing, 0);
+			console.log(info(`Server already running (PID ${existing})`));
+			return;
+		} catch {}
+	}
+	const serverEntry = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../../dist/mcp/server.js");
+	const env = {
+		...process.env,
+		DXCRM_MCP_MODE: "http",
+		DXCRM_MCP_PORT: String(port)
+	};
+	if (opts.data) env["DXCRM_DATA_DIR"] = opts.data;
+	const child = spawn(process.execPath, [serverEntry], {
+		detached: true,
+		stdio: "ignore",
+		env
+	});
+	child.unref();
+	fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+	fs.writeFileSync(pidFile, String(child.pid), "utf-8");
+	const hostname = os.hostname();
+	console.log(success(`DatasynxOpenCRM server running on http://0.0.0.0:${port}/mcp`));
+	console.log(info(`Data dir: ${dir}`));
+	console.log(info(`Add to your AI framework config: url: http://${hostname}:${port}/mcp`));
+}
+function runServerStatus(dataDir) {
+	const pidFile = getPidFile(process.env["DXCRM_DATA_DIR"] ?? dataDir ?? process.cwd());
+	if (!fs.existsSync(pidFile)) {
+		console.log(info("Server: not running."));
+		return;
+	}
+	const pid = parseInt(fs.readFileSync(pidFile, "utf-8").trim(), 10);
+	if (isNaN(pid)) {
+		console.log(info("Server: not running (invalid PID file)."));
+		return;
+	}
+	try {
+		process.kill(pid, 0);
+		console.log(success(`Server: running (PID ${pid})`));
+	} catch {
+		console.log(info("Server: not running (stale PID file)."));
+		try {
+			fs.unlinkSync(pidFile);
+		} catch {}
+	}
+}
+const serverCommand = new Command("server");
+serverCommand.command("start").description("Start the DatasynxOpenCRM HTTP MCP server").option("--port <port>", "HTTP port (default 3847)", "3847").option("--data <dir>", "Data directory (sets DXCRM_DATA_DIR)").action((opts) => runServerStart(opts));
+serverCommand.command("status").description("Check if the server is running").action(() => runServerStatus());
+//#endregion
+//#region src/commands/audit.ts
+const SEP = "─".repeat(70);
+async function runAudit(opts, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const limit = opts.limit ?? 20;
+	const entries = filterAuditLog(readAuditLog(dir), {
+		...opts.slug !== void 0 ? { slug: opts.slug } : {},
+		...opts.actor !== void 0 ? { actor: opts.actor } : {},
+		limit
+	});
+	console.log(SEP);
+	console.log(" DatasynxOpenCRM — Audit Trail");
+	if (opts.slug) console.log(` Customer: ${opts.slug}`);
+	if (opts.actor) console.log(` Actor:    ${opts.actor}`);
+	console.log(SEP);
+	if (entries.length === 0) {
+		console.log(" No audit entries found.");
+		console.log(SEP);
+		return;
+	}
+	for (const entry of entries) console.log(` ${entry.timestamp}  ${entry.actor.padEnd(12)}  ${entry.tool.padEnd(20)}  ${entry.slug.padEnd(20)}  ${entry.summary}`);
+	console.log(SEP);
+	console.log(` ${entries.length} entr${entries.length === 1 ? "y" : "ies"} shown`);
+	console.log(SEP);
+}
+const auditCommand = new Command("audit").description("Show CRM audit trail — who changed what and when").option("--slug <slug>", "Filter by customer slug").option("--actor <actor>", "Filter by actor").option("--limit <n>", "Number of entries to show (default: 20)", parseInt).option("--tail", "Show all new entries (simplified: shows current entries)").action((opts) => runAudit(opts, process.env["DXCRM_DATA_DIR"]));
+//#endregion
+//#region src/commands/rbac.ts
+const ROLES = [
+	"admin",
+	"manager",
+	"rep"
+];
+async function runRbacSet(actor, role, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	if (!ROLES.includes(role)) {
+		console.error(error(`✗ Invalid role '${role}'. Must be: ${ROLES.join(", ")}`));
+		process.exit(1);
+	}
+	setActorRole(dir, actor, role);
+	console.log(success(`✓ ${bold(actor)} → ${bold(role)}`));
+}
+async function runRbacShow(dataDir) {
+	const config = getRbacConfig(dataDir ?? process.cwd());
+	const entries = Object.entries(config.actors);
+	if (entries.length === 0) {
+		console.log(info("No RBAC roles configured. All actors default to 'rep'."));
+		return;
+	}
+	console.log(bold(`\n RBAC Roles\n`));
+	for (const [actor, role] of entries) console.log(info(`  ${bold(actor).padEnd(20)}  ${role}`));
+	if (config.default) console.log(info(`\n  Default: ${config.default}`));
+	console.log("");
+}
+async function runRbacCheck(actor, tool, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const { getRole } = await import("./rbac-C7c8tcES.js");
+	const role = getRole(dir, actor);
+	if (canWrite(role, tool)) console.log(success(`✓ ${actor} (${role}) CAN use '${tool}'`));
+	else console.log(error(`✗ ${actor} (${role}) CANNOT use '${tool}'`));
+}
+const rbacCommand = new Command("rbac").description("Manage role-based access control");
+rbacCommand.command("set <actor> <role>").description(`Assign role to actor (roles: ${ROLES.join(", ")})`).action((actor, role) => runRbacSet(actor, role, process.env["DXCRM_DATA_DIR"]));
+rbacCommand.command("show").alias("list").description("List all RBAC role assignments").action(() => runRbacShow(process.env["DXCRM_DATA_DIR"]));
+rbacCommand.command("check <actor> <tool>").description("Check if an actor can use a specific tool").action((actor, tool) => runRbacCheck(actor, tool, process.env["DXCRM_DATA_DIR"]));
+//#endregion
+//#region src/commands/gdpr.ts
+function erasuresPath(dataDir) {
+	return path.join(dataDir, ".agentic", "gdpr-erasures.json");
+}
+function readErasures(dataDir) {
+	const p = erasuresPath(dataDir);
+	if (!fs.existsSync(p)) return [];
+	try {
+		return JSON.parse(fs.readFileSync(p, "utf-8"));
+	} catch {
+		return [];
+	}
+}
+function appendErasure(dataDir, record) {
+	const p = erasuresPath(dataDir);
+	fs.mkdirSync(path.dirname(p), { recursive: true });
+	const existing = readErasures(dataDir);
+	existing.push(record);
+	fs.writeFileSync(p, JSON.stringify(existing, null, 2), "utf-8");
+}
+async function runGdprErase(slug, opts, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const customerDir = path.join(dir, "customers", slug);
+	if (!opts.confirm) {
+		console.log(info(`Dry run — would permanently erase: ${bold(slug)}`));
+		console.log(info(`  Directory: ${customerDir}`));
+		console.log(info(`  Audit log entry will be written to .agentic/audit.log`));
+		console.log(info(`  Erasure record will be added to .agentic/gdpr-erasures.json`));
+		console.log(info(`\n  To proceed: dxcrm gdpr erase ${slug} --confirm`));
+		return;
+	}
+	if (!fs.existsSync(customerDir)) console.warn(info(`  Customer '${slug}' directory not found — may already be erased.`));
+	else {
+		fs.rmSync(customerDir, {
+			recursive: true,
+			force: true
+		});
+		try {
+			const { dropCustomerTable } = await import("./lancedb-CCBbpulq.js");
+			await dropCustomerTable(dir, slug);
+		} catch {}
+	}
+	const globalQueuePath = path.join(dir, ".agentic", "agent-queue.json");
+	if (fs.existsSync(globalQueuePath)) await withJsonFile(globalQueuePath, (tasks) => (Array.isArray(tasks) ? tasks : []).filter((t) => t.slug !== slug));
+	const goalsPath = path.join(dir, ".agentic", "goals.json");
+	if (fs.existsSync(goalsPath)) {
+		const { readGoals, writeGoals } = await import("./goal-engine-CUZSpERI.js");
+		writeGoals(dir, readGoals(dir).map((g) => ({
+			...g,
+			decomposition: {
+				...g.decomposition,
+				subGoals: g.decomposition.subGoals.filter((sg) => sg.slug !== slug)
+			}
+		})));
+	}
+	const { readSubscriptions, writeSubscriptions } = await import("./push-manager-CowY-0IK.js");
+	const subs = await readSubscriptions(dir);
+	const remaining = subs.filter((s) => s.slug !== slug);
+	if (remaining.length !== subs.length) await writeSubscriptions(dir, remaining);
+	const actor = getActor();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	writeAuditEntry(dir, {
+		timestamp: now,
+		actor,
+		tool: "gdpr_erase",
+		slug,
+		summary: "Customer data permanently erased"
+	});
+	appendErasure(dir, {
+		slug,
+		erasedAt: now,
+		erasedBy: actor,
+		reason: "GDPR Art. 17 request"
+	});
+	console.log(success(`✓ Customer '${bold(slug)}' erased.`));
+	console.log(info(`  Deletion logged to .agentic/audit.log`));
+	console.log(info(`  Record added to .agentic/gdpr-erasures.json`));
+}
+async function runGdprListErasures(dataDir) {
+	const records = readErasures(dataDir ?? process.cwd());
+	if (records.length === 0) {
+		console.log(info("No erasures on record."));
+		return;
+	}
+	console.log(bold(`\n GDPR Erasures (${records.length})\n`));
+	for (const r of records) console.log(info(`  ${r.erasedAt}  ${r.erasedBy.padEnd(12)}  ${r.slug}  — ${r.reason}`));
+	console.log("");
+}
+const gdprCommand = new Command("gdpr").description("GDPR compliance tools");
+gdprCommand.command("erase <slug>").description("Permanently erase all data for a customer (Art. 17 right to erasure)").option("--confirm", "Confirm permanent deletion (required)").action((slug, opts) => runGdprErase(slug, opts, process.env["DXCRM_DATA_DIR"]));
+gdprCommand.command("list-erasures").description("Show history of GDPR erasures").action(() => runGdprListErasures(process.env["DXCRM_DATA_DIR"]));
+//#endregion
+//#region src/commands/security-report.ts
+const REPORT = `# DatasynxOpenCRM — Security Report
+
+Generated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+
+## 1. Data Storage
+
+- **Location**: Local filesystem only. All data lives in \`customers/\` and \`.agentic/\` directories on your infrastructure.
+- **External transmission**: None by default. Data is never sent to Datasynx servers.
+- **Cloud dependencies**: None for core functionality. Optional integrations (Gmail, Anthropic API) are explicitly configured.
+
+## 2. Authentication & Authorization
+
+- **Phase 3**: No authentication on HTTP MCP server. Restrict access via firewall or VPN (port 3847 should be on private network only).
+- **Phase 4 (RBAC)**: Role-based access control via \`.agentic/rbac.json\`. Roles: admin, manager, rep. Enforced per MCP tool call.
+- **Actor identity**: \`DXCRM_ACTOR\` environment variable. No cryptographic identity in Phase 3.
+
+## 3. Encryption
+
+- **At rest**: Not encrypted at application level. Use OS-level disk encryption (LUKS on Linux, FileVault on macOS).
+- **In transit**: HTTP (no TLS) in Phase 3. Use a reverse proxy (nginx + Let's Encrypt) or VPN for TLS.
+- **Recommendation**: Deploy behind Tailscale or WireGuard for team access.
+
+## 4. Audit Trail
+
+- **File**: \`.agentic/audit.log\` — append-only, one line per entry.
+- **Format**: \`timestamp | actor | tool | customer | summary\`
+- **Coverage**: All write operations (\`log_interaction\`, \`update_deal\`, \`gdpr_erase\`).
+- **Tamper evidence**: Phase 3: none. Phase 4+: hash chaining planned.
+- **Retention**: Indefinite (append-only, never deleted by the application).
+
+## 5. Network Calls
+
+The following external services are contacted when configured:
+
+| Service | When | Data sent |
+|---|---|---|
+| Gmail API | Gmail sync enabled + credentials configured | Email headers + snippets |
+| Anthropic API | \`ANTHROPIC_API_KEY\` set | Email/transcript content for summarization |
+| Telegram Bot API | Agent notifications enabled + token set | Customer slug + context excerpt (≤800 chars) |
+| Microsoft Graph | Microsoft sync configured | Email headers + snippets |
+
+**No telemetry, no analytics, no usage data is sent to Datasynx.**
+
+## 6. Data Residency
+
+DatasynxOpenCRM runs entirely on customer-controlled infrastructure. Data never leaves the deployment environment without explicit integration configuration.
+
+This makes EU data residency guarantees straightforward — a key differentiator vs cloud CRMs.
+
+## 7. GDPR Compliance
+
+- **Right to erasure (Art. 17)**: \`dxcrm gdpr erase <slug> --confirm\` permanently deletes all customer data.
+- **Erasure log**: \`.agentic/gdpr-erasures.json\` records what was deleted, when, and by whom.
+- **Audit trail**: Every write operation is attributed to an actor.
+- **Data portability (Art. 20)**: \`dxcrm export <slug>\` exports all data as JSON or Markdown.
+
+## 8. SOC 2 Readiness
+
+- **Audit log**: Available from Phase 3 (audit trail covers all write operations).
+- **SOC 2 Type 2**: Requires 6 months of consistent audit logs. Apply after Phase 4 completion.
+- **Security review questionnaire**: This document serves as the primary answer document.
+
+## 9. Dependencies (Key Packages)
+
+| Package | Purpose | Cloud dependency? |
+|---|---|---|
+| \`@modelcontextprotocol/sdk\` | MCP server | No |
+| \`@googleapis/gmail\`, \`@googleapis/calendar\` | Gmail/Calendar sync | Optional — only if configured |
+| \`@anthropic-ai/sdk\` | LLM summarization | Optional — only if API key set |
+| \`lancedb\` | Local vector search | No — embedded DB |
+| \`gray-matter\` | Markdown frontmatter | No |
+| \`commander\` | CLI framework | No |
+| \`zod\` | Schema validation | No |
+| \`cron\` | Background sync | No |
+
+## 10. Incident Response
+
+- **Data breach**: Filesystem-only — scope is limited to the deployment host.
+- **Revoke access**: Remove actor from \`.agentic/rbac.json\`, rotate \`DXCRM_ACTOR\` env var.
+- **Audit**: \`dxcrm audit --actor <actor>\` shows all actions by a specific user.
+`;
+async function runSecurityReport(opts, _dataDir) {
+	const report = REPORT;
+	if (opts.output) {
+		const outputPath = path.resolve(opts.output);
+		fs.writeFileSync(outputPath, report, "utf-8");
+		console.log(success(`✓ Security report written to: ${outputPath}`));
+	} else console.log(report);
+}
+const securityReportCommand = new Command("security-report").description("Generate security questionnaire answer document for enterprise reviews").option("--output <file>", "Write report to file instead of stdout").action((opts) => runSecurityReport(opts, process.env["DXCRM_DATA_DIR"]));
+//#endregion
+//#region src/commands/pipeline-stages.ts
+function printStagesTable(stages) {
+	console.log(bold("\n Pipeline Stages\n"));
+	console.log(info(`  ${"ID".padEnd(20)} ${"Label".padEnd(20)} ${"Order".padEnd(8)} ${"Prob%".padEnd(8)} ${"Final".padEnd(6)} Color`));
+	console.log(info(`  ${"─".repeat(72)}`));
+	for (const s of stages) {
+		const prob = s.probability !== void 0 ? String(s.probability) : "-";
+		const isFinal = s.isFinal ? "yes" : "no";
+		const color = s.color ?? "-";
+		console.log(info(`  ${s.id.padEnd(20)} ${s.label.padEnd(20)} ${String(s.order).padEnd(8)} ${prob.padEnd(8)} ${isFinal.padEnd(6)} ${color}`));
+	}
+	console.log("");
+}
+const stagesCommand = new Command("stages").description("Manage custom pipeline stages");
+stagesCommand.command("list").description("List all configured pipeline stages").action(() => {
+	printStagesTable(getPipelineStages(process.env["DXCRM_DATA_DIR"] ?? process.cwd()));
+});
+stagesCommand.command("set <id> <label>").description("Create or update a pipeline stage").option("--order <n>", "Sort order (number)", "1").option("--probability <n>", "Default win probability 0-100").option("--color <hex>", "Hex color code (e.g. #3B82F6)").option("--final", "Mark as final stage (won/lost)").action((id, label, opts) => {
+	setPipelineStage(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), {
+		id,
+		label,
+		order: parseInt(opts.order, 10),
+		...opts.probability !== void 0 ? { probability: parseInt(opts.probability, 10) } : {},
+		...opts.color ? { color: opts.color } : {},
+		...opts.final ? { isFinal: true } : {}
+	});
+	console.log(success(`✓ Stage '${id}' saved`));
+});
+stagesCommand.command("delete <id>").description("Delete a pipeline stage by ID").action((id) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	if (!getPipelineStages(dataDir).find((s) => s.id === id)) {
+		console.error(error(`✗ Stage '${id}' not found`));
+		process.exit(1);
+	}
+	deletePipelineStage(dataDir, id);
+	console.log(success(`✓ Stage '${id}' deleted`));
+});
+stagesCommand.command("reset").description("Reset pipeline stages to defaults").action(() => {
+	resetToDefaults(process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+	console.log(success("✓ Pipeline stages reset to defaults"));
+});
+//#endregion
+//#region src/core/plugin-registry.ts
+const _plugins = /* @__PURE__ */ new Map();
+function getPlugin(name) {
+	return _plugins.get(name);
+}
+function listPlugins() {
+	return Array.from(_plugins.values());
+}
+//#endregion
+//#region src/commands/plugin.ts
+const pluginCommand = new Command("plugin").description("Manage dxcrm plugins");
+pluginCommand.command("list").description("List all registered plugins").action(() => {
+	const plugins = listPlugins();
+	if (plugins.length === 0) {
+		console.log(info("No plugins registered."));
+		return;
+	}
+	console.log(bold(`\n dxcrm Plugins (${plugins.length})\n`));
+	for (const p of plugins) console.log(info(`  ${p.name.padEnd(20)} v${p.version}  ${p.description ?? ""}`));
+	console.log("");
+});
+pluginCommand.command("info <name>").description("Show info about a registered plugin").action((name) => {
+	const plugin = getPlugin(name);
+	if (!plugin) {
+		console.log(error(`Plugin '${name}' not found.`));
+		process.exit(1);
+	}
+	console.log(bold(`\n Plugin: ${plugin.name}\n`));
+	console.log(info(`  Version: ${plugin.version}`));
+	if (plugin.description) console.log(info(`  Description: ${plugin.description}`));
+	if (plugin.mcpTools?.length) console.log(info(`  MCP Tools: ${plugin.mcpTools.join(", ")}`));
+	console.log("");
+});
+//#endregion
+//#region src/commands/goal.ts
+async function runGoalSet(description, options) {
+	const goal = await pursueGoal(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), {
+		description,
+		deadline: options.deadline
+	});
+	console.log(success(`✓ Goal created: ${bold(goal.id)}`));
+	console.log(info(`  Description : ${goal.description}`));
+	console.log(info(`  Target      : €${goal.target.toLocaleString()}`));
+	console.log(info(`  Deadline    : ${goal.deadline}`));
+	console.log(info(`  Pipeline P50: €${goal.decomposition.currentPipeline.toLocaleString()}`));
+	console.log(info(`  Gap         : €${goal.decomposition.gap.toLocaleString()}`));
+	if (goal.decomposition.subGoals.length > 0) {
+		console.log(bold("\n  Action Plan:"));
+		for (const sg of goal.decomposition.subGoals) {
+			console.log(info(`  ${sg.priority}. ${sg.action}`));
+			console.log(info(`     → ${sg.nextStep}`));
+		}
+	}
+}
+async function runGoalStatus() {
+	const goals = getActiveGoals(process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+	if (goals.length === 0) {
+		console.log(info("No active goals. Use `dxcrm goal set` to create one."));
+		return;
+	}
+	console.log(bold(`\n Active Goals (${goals.length})\n`));
+	for (const g of goals) {
+		const bar = "█".repeat(Math.round(g.progress / 10)) + "░".repeat(10 - Math.round(g.progress / 10));
+		const deadlineMs = new Date(g.deadline).getTime() - Date.now();
+		const daysLeft = Math.max(0, Math.ceil(deadlineMs / 864e5));
+		console.log(bold(`  ${g.id}`));
+		console.log(info(`  ${g.description}`));
+		console.log(info(`  [${bar}] ${g.progress}%  |  €${g.target.toLocaleString()} by ${g.deadline} (${daysLeft}d left)`));
+		console.log("");
+	}
+}
+async function runGoalUpdate(goalId, options) {
+	const dir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const progress = parseInt(options.progress, 10);
+	if (isNaN(progress) || progress < 0 || progress > 100) {
+		console.error(error("✗ --progress must be a number 0–100"));
+		process.exit(1);
+	}
+	if (!await updateGoalProgress(dir, goalId, progress)) {
+		console.error(error(`✗ Goal '${goalId}' not found`));
+		process.exit(1);
+	}
+	console.log(success(`✓ Goal ${bold(goalId)} progress updated to ${bold(String(progress))}%`));
+}
+async function runGoalCancel(goalId) {
+	if (!await cancelGoal(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), goalId)) {
+		console.error(error(`✗ Goal '${goalId}' not found`));
+		process.exit(1);
+	}
+	console.log(success(`✓ Goal ${bold(goalId)} cancelled`));
+}
+const goalCommand = new Command("goal").description("Manage goals and action plans");
+goalCommand.command("set <description>").description("Set a new goal and get a decomposed action plan").requiredOption("--deadline <date>", "Target deadline (YYYY-MM-DD)").action((description, opts) => runGoalSet(description, opts));
+goalCommand.command("status").description("Show all active goals with progress").action(() => runGoalStatus());
+goalCommand.command("update <goalId>").description("Update goal progress percentage").requiredOption("--progress <n>", "Progress 0–100").action((goalId, opts) => runGoalUpdate(goalId, opts));
+goalCommand.command("cancel <goalId>").description("Cancel an active goal").action((goalId) => runGoalCancel(goalId));
+//#endregion
+//#region src/commands/push.ts
+async function runPushRegister(slug, options) {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const providerData = {};
+	if (options.topicName) providerData["gmailTopicName"] = options.topicName;
+	if (options.clientState) providerData["microsoftClientState"] = options.clientState;
+	if (options.resource) providerData["microsoftResource"] = options.resource;
+	if (options.teamId) providerData["slackTeamId"] = options.teamId;
+	if (options.channelId) providerData["slackChannelId"] = options.channelId;
+	const sub = await register(dataDir, options.provider, slug, {
+		webhookUrl: options.webhookUrl,
+		providerData
+	});
+	console.log(success(`✓ Push subscription registered: ${bold(sub.id)}`));
+	console.log(info(`  Provider  : ${sub.provider}`));
+	console.log(info(`  Slug      : ${sub.slug}`));
+	console.log(info(`  Webhook   : ${sub.webhookUrl}`));
+	console.log(info(`  Expires   : ${sub.expiresAt ?? "never"}`));
+	if (options.webhookUrl.includes("localhost")) {
+		console.log(info(`  ⚠ Warning: localhost URLs cannot be reached by external providers.`));
+		console.log(info(`            Use a tunnel: ngrok http 3847`));
+	}
+}
+async function runPushStatus(options) {
+	let subs = await readSubscriptions(process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+	if (options.slug) subs = subs.filter((s) => s.slug === options.slug);
+	if (options.provider) subs = subs.filter((s) => s.provider === options.provider);
+	if (subs.length === 0) {
+		console.log(info("No push subscriptions registered. Use `dxcrm push register` to add one."));
+		return;
+	}
+	const now = Date.now();
+	console.log(bold(`\n Push Subscriptions (${subs.length})\n`));
+	for (const s of subs) {
+		const expiresIn = s.expiresAt ? Math.round((new Date(s.expiresAt).getTime() - now) / (3600 * 1e3)) : null;
+		const expiryStr = expiresIn !== null ? `${expiresIn}h remaining` : "no expiry";
+		const needsRenewal = s.expiresAt !== null && new Date(s.expiresAt).getTime() - now < 1440 * 60 * 1e3;
+		console.log(bold(`  ${s.id}`));
+		console.log(info(`  ${s.provider} → ${s.slug} [${s.status}]`));
+		console.log(info(`  Events: ${s.eventsProcessed}  |  Expires: ${expiryStr}${needsRenewal ? " ⚠ RENEW SOON" : ""}`));
+		console.log(info(`  Last event: ${s.lastEventAt ?? "—"}`));
+		console.log("");
+	}
+}
+async function runPushRevoke(id) {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	try {
+		await revoke(dataDir, id);
+		console.log(success(`✓ Subscription ${bold(id)} revoked`));
+	} catch {
+		console.error(error(`✗ Subscription not found: ${id}`));
+		process.exit(1);
+	}
+}
+async function runPushRenew(options) {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	if (options.id) {
+		const sub = (await readSubscriptions(dataDir)).find((s) => s.id === options.id);
+		if (!sub) {
+			console.error(error(`✗ Subscription not found: ${options.id}`));
+			process.exit(1);
+		}
+		console.log(info(`  Renewal for ${sub.id} requires provider-specific logic.`));
+		console.log(info(`  Use the daemon's automatic renewal (daily 06:00) or re-register.`));
+		return;
+	}
+	const result = await renewExpiringSubscriptions(dataDir, async () => {
+		throw new Error("No default renew function — use provider-specific tooling");
+	}, 24);
+	console.log(info(`  Renewed: ${result.renewed.length}  |  Errors: ${result.errors.length}`));
+	if (result.renewed.length > 0) console.log(success(`✓ Renewed: ${result.renewed.join(", ")}`));
+	if (result.errors.length > 0) console.log(error(`✗ Errors: ${result.errors.join(", ")}`));
+}
+const pushCommand = new Command("push").description("Manage real-time push subscriptions (Gmail Pub/Sub, MS Graph, Slack Events)");
+pushCommand.command("register <slug>").description("Register a push subscription for a customer").requiredOption("--provider <provider>", "Provider: gmail | microsoft-graph | slack").requiredOption("--webhook-url <url>", "Public HTTPS URL for provider callbacks").option("--topic-name <topic>", "Gmail: Cloud Pub/Sub topic name").option("--client-state <secret>", "MS Graph: client state secret").option("--resource <path>", "MS Graph: resource path").option("--team-id <id>", "Slack: workspace team ID").option("--channel-id <id>", "Slack: optional channel ID").action(async (slug, opts) => {
+	await runPushRegister(slug, opts);
+});
+pushCommand.command("status").description("Show all push subscriptions").option("--slug <slug>", "Filter by customer slug").option("--provider <provider>", "Filter by provider").action(async (opts) => {
+	await runPushStatus(opts);
+});
+pushCommand.command("revoke <id>").description("Revoke a push subscription by ID").action(async (id) => {
+	await runPushRevoke(id);
+});
+pushCommand.command("renew").description("Renew expiring push subscriptions").option("--all", "Renew all expiring subscriptions").option("--id <id>", "Renew a specific subscription by ID").action(async (opts) => {
+	await runPushRenew(opts);
+});
+//#endregion
+//#region src/commands/attach.ts
+async function runAttach(slug, filePath, dataDir) {
+	const dir = dataDir ?? process.cwd();
+	const customerDir = path.join(dir, "customers", slug);
+	if (!fs.existsSync(customerDir)) {
+		const msg = `Customer '${slug}' not found.`;
+		console.error(error(msg));
+		return { error: msg };
+	}
+	if (!fs.existsSync(filePath)) {
+		const msg = `File not found: ${filePath}`;
+		console.error(error(msg));
+		return { error: msg };
+	}
+	const attachmentsDir = path.join(customerDir, "attachments");
+	fs.mkdirSync(attachmentsDir, { recursive: true });
+	const filename = path.basename(filePath);
+	const dest = path.join(attachmentsDir, filename);
+	if (fs.existsSync(dest)) {
+		const msg = `Attachment already exists: ${filename}`;
+		console.log(info(msg));
+		return { attached: dest };
+	}
+	fs.copyFileSync(filePath, dest);
+	console.log(success(`Attached ${bold(filename)} to ${bold(slug)}`));
+	return { attached: dest };
+}
+const attachCommand = new Command("attach").description("Attach a file to a customer (copies to customers/<slug>/attachments/)").argument("<slug>", "Customer slug").argument("<file>", "Path to the file to attach").action(async (slug, file) => {
+	await runAttach(slug, file, process.env["DXCRM_DATA_DIR"]);
+});
+//#endregion
+//#region src/commands/template.ts
+const templateCommand = new Command("template").description("Manage email templates");
+templateCommand.command("list").option("--category <category>", "Filter by category").action((opts) => {
+	const templates = listTemplates(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), opts.category ? { category: opts.category } : {});
+	if (templates.length === 0) {
+		console.log(info("No templates found."));
+		return;
+	}
+	for (const t of templates) console.log(`  ${bold(t.id)}  [${t.category}]  ${t.subject}`);
+});
+templateCommand.command("get <id>").action((id) => {
+	const tmpl = getTemplate(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), id);
+	if (!tmpl) {
+		console.error(error(`Template '${id}' not found`));
+		process.exit(1);
+	}
+	console.log(bold(`Subject: ${tmpl.subject}`));
+	console.log(`Category: ${tmpl.category}  Language: ${tmpl.language}`);
+	console.log(`Variables: ${tmpl.variables.join(", ") || "(none defined)"}`);
+	console.log("\n" + tmpl.body);
+});
+templateCommand.command("preview <id>").option("--slug <slug>", "Customer slug to preview with").action(async (id, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const tmpl = getTemplate(dataDir, id);
+	if (!tmpl) {
+		console.error(error(`Template '${id}' not found`));
+		process.exit(1);
+	}
+	const vars = opts.slug ? await buildVariablesFromCustomer(dataDir, opts.slug) : {};
+	console.log(bold(`Subject: ${interpolate(tmpl.subject, vars)}`));
+	console.log(interpolate(tmpl.body, vars));
+});
+templateCommand.command("create <id>").option("--category <category>", "Category", "general").option("--subject <subject>", "Subject line").action((id, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	if (getTemplate(dataDir, id)) {
+		console.error(error(`Template '${id}' already exists`));
+		process.exit(1);
+	}
+	writeTemplate(dataDir, {
+		id,
+		subject: opts.subject ?? `Subject for ${id}`,
+		category: opts.category,
+		variables: [],
+		language: "de",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		body: `Hi {{firstName}},\n\n[your message here]\n\nMit freundlichen Grüßen,\n{{senderName}}`
+	});
+	console.log(success(`✓ Template '${id}' created in category '${opts.category}'`));
+});
+templateCommand.command("delete <id>").action((id) => {
+	if (deleteTemplate(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), id)) console.log(success(`✓ Template '${id}' deleted`));
+	else {
+		console.error(error(`Template '${id}' not found`));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/sequence.ts
+const sequenceCommand = new Command("sequence").description("Manage email sequences");
+sequenceCommand.command("list").description("List all sequences").action(() => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const sequences = listSequences(dataDir);
+	const enrollments = readEnrollments(dataDir);
+	if (sequences.length === 0) {
+		console.log(info("No sequences found."));
+		return;
+	}
+	for (const seq of sequences) {
+		const count = enrollments.filter((e) => e.sequenceId === seq.id).length;
+		console.log(`  ${bold(seq.id)}  "${seq.name}"  ${seq.steps.length} steps  ${count} enrolled`);
+	}
+});
+sequenceCommand.command("create <id>").description("Create a new sequence skeleton").option("--name <name>", "Sequence display name").action((id, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	if (getSequence(dataDir, id)) {
+		console.error(error(`Sequence '${id}' already exists`));
+		process.exit(1);
+	}
+	const seq = {
+		id,
+		name: opts.name ?? id,
+		steps: [
+			{
+				day: 0,
+				templateId: "intro",
+				skipIfReplied: true
+			},
+			{
+				day: 3,
+				templateId: "followup-1",
+				skipIfReplied: true
+			},
+			{
+				day: 7,
+				templateId: "followup-2",
+				skipIfReplied: true
+			}
+		],
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeSequence(dataDir, seq);
+	console.log(success(`✓ Sequence '${id}' created with ${seq.steps.length} steps`));
+	console.log(info(`Edit .agentic/sequences/${id}.yaml to customize steps and templates`));
+});
+sequenceCommand.command("enroll <slug>").description("Enroll a customer contact in a sequence").requiredOption("--email <email>", "Contact email address").requiredOption("--sequence <id>", "Sequence ID").action(async (slug, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const seq = getSequence(dataDir, opts.sequence);
+	if (!seq) {
+		console.error(error(`Sequence '${opts.sequence}' not found`));
+		process.exit(1);
+	}
+	const enrollmentId = `enroll_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await writeEnrollment(dataDir, {
+		id: enrollmentId,
+		sequenceId: opts.sequence,
+		slug,
+		contactEmail: opts.email,
+		enrolledAt: now,
+		status: "active",
+		currentStep: 0,
+		stepsCompleted: []
+	});
+	console.log(success(`✓ Enrolled ${opts.email} in sequence '${seq.name}'`));
+	console.log(info(`Enrollment ID: ${enrollmentId}`));
+});
+sequenceCommand.command("status").description("Show enrollment status").option("--slug <slug>", "Filter by customer slug").action((opts) => {
+	let enrollments = readEnrollments(process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+	if (opts.slug) enrollments = enrollments.filter((e) => e.slug === opts.slug);
+	if (enrollments.length === 0) {
+		console.log(info("No enrollments found."));
+		return;
+	}
+	for (const e of enrollments) {
+		const stepInfo = `step ${e.currentStep}`;
+		const lastSent = e.lastSentAt ? ` last sent ${e.lastSentAt.slice(0, 10)}` : "";
+		console.log(`  ${bold(e.id)}  ${e.slug} <${e.contactEmail}>  seq:${e.sequenceId}  [${e.status}]  ${stepInfo}${lastSent}`);
+	}
+});
+sequenceCommand.command("run").description("Run the sequence cycle (send due emails)").option("--dry-run", "Show what would be sent without sending").action(async (opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	if (opts.dryRun) {
+		const enrollments = readEnrollments(dataDir).filter((e) => e.status === "active");
+		console.log(info(`Dry run — ${enrollments.length} active enrollments for ${today}`));
+		for (const e of enrollments) console.log(`  Would process: ${e.id} (${e.contactEmail}, step ${e.currentStep})`);
+		return;
+	}
+	const result = await runSequenceCycle(dataDir, today);
+	console.log(success(`✓ Cycle complete: ${result.sent} sent, ${result.completed} completed, ${result.errors.length} errors`));
+	if (result.errors.length > 0) for (const e of result.errors) console.error(error(`  Error: ${e}`));
+});
+//#endregion
+//#region src/commands/quote.ts
+const quoteCommand = new Command("quote").description("Manage customer quotes");
+quoteCommand.command("generate <slug>").description("Generate a quote for a customer").requiredOption("--deal <name>", "Deal name").option("--items <items>", "Line items: \"Description Qty Price,...\" (e.g. \"Consulting 1 5000,Support 12 500\")").option("--vat <percent>", "VAT percent", "19").option("--valid <days>", "Valid for N days", "30").action(async (slug, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const lineItems = (opts.items ?? "Service 1 1000").split(",").map((item) => item.trim()).filter(Boolean).map((item) => {
+		const parts = item.split(/\s+/);
+		const unitPrice = parseFloat(parts[parts.length - 1] ?? "0");
+		const quantity = parseFloat(parts[parts.length - 2] ?? "1");
+		return {
+			description: parts.slice(0, -2).join(" ") || item,
+			quantity,
+			unitPrice
+		};
+	});
+	try {
+		const quote = await generateQuote(dataDir, {
+			slug,
+			dealName: opts.deal,
+			lineItems,
+			vatPercent: parseFloat(opts.vat),
+			validUntilDays: parseInt(opts.valid, 10)
+		});
+		console.log(success(`✓ Quote ${bold(quote.quoteNumber)} generated`));
+		console.log(info(`  Total:     ${quote.total.toFixed(2)} ${quote.currency}`));
+		console.log(info(`  Valid until: ${quote.validUntil}`));
+		console.log(info(`  HTML: ${quote.htmlPath}`));
+	} catch (err) {
+		console.error(error(`Failed to generate quote: ${err.message}`));
+		process.exit(1);
+	}
+});
+quoteCommand.command("list").description("List quotes").option("--slug <slug>", "Filter by customer slug").action((opts) => {
+	const quotes = listQuotes(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), opts.slug);
+	if (quotes.length === 0) {
+		console.log(info("No quotes found."));
+		return;
+	}
+	for (const q of quotes) console.log(`  ${bold(q.quoteNumber)}  ${q.slug}  ${q.dealName}  ${q.total.toFixed(2)} ${q.currency}  [${q.status}]  ${q.validUntil}`);
+});
+quoteCommand.command("get <quoteNumber>").description("Show quote details").action((quoteNumber) => {
+	const quote = readQuote(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), quoteNumber);
+	if (!quote) {
+		console.error(error(`Quote '${quoteNumber}' not found`));
+		process.exit(1);
+	}
+	console.log(bold(`Quote: ${quote.quoteNumber}`));
+	console.log(`Customer: ${quote.slug}  Deal: ${quote.dealName}`);
+	console.log(`Status: ${quote.status}  Valid until: ${quote.validUntil}`);
+	console.log(`Subtotal: ${quote.subtotal.toFixed(2)}  VAT: ${quote.vat.toFixed(2)}  Total: ${quote.total.toFixed(2)} ${quote.currency}`);
+	for (const item of quote.lineItems) console.log(`  - ${item.description}: ${item.quantity} × ${item.unitPrice} = ${item.total}`);
+});
+//#endregion
+//#region src/commands/ticket.ts
+const ticketCommand = new Command("ticket").description("Manage support tickets");
+ticketCommand.command("list").description("List tickets").option("--slug <slug>", "Filter by customer slug").option("--status <status>", "Filter by status").option("--priority <priority>", "Filter by priority").action(async (opts) => {
+	const tickets = await listAllTickets(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), {
+		...opts.slug ? { slug: opts.slug } : {},
+		...opts.status ? { status: opts.status } : {},
+		...opts.priority ? { priority: opts.priority } : {}
+	});
+	if (tickets.length === 0) {
+		console.log(info("No tickets found."));
+		return;
+	}
+	for (const { slug, ticket: t } of tickets) {
+		const flag = t.slaDue && t.slaDue < (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) && t.status !== "resolved" && t.status !== "closed" ? " ⚠ SLA" : "";
+		console.log(`  ${bold(t.id)}  [${slug}]  ${t.title}  [${t.status}/${t.priority}]${t.assignee ? `  @${t.assignee}` : ""}${flag}`);
+	}
+});
+ticketCommand.command("create <slug>").description("Create a ticket for a customer").requiredOption("--title <title>", "Ticket title").option("--description <desc>", "Description").option("--priority <priority>", "Priority: urgent|high|normal|low", "normal").option("--assignee <name>", "Assignee").action(async (slug, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const rules = loadSlaRules(dataDir);
+	const priority = opts.priority ?? "normal";
+	const id = nextTicketId(await readTickets(dataDir, slug));
+	const ticket = {
+		id,
+		title: opts.title,
+		status: "open",
+		priority,
+		...opts.assignee ? { assignee: opts.assignee } : {},
+		created: today,
+		slaDue: calcSlaDue(today, priority, rules),
+		...opts.description ? { description: opts.description } : {}
+	};
+	await upsertTicket(dataDir, slug, ticket);
+	console.log(success(`✓ Ticket ${bold(id)} created for ${slug}`));
+	console.log(info(`  SLA due: ${ticket.slaDue}`));
+});
+ticketCommand.command("update <ticketId>").description("Update a ticket").requiredOption("--slug <slug>", "Customer slug").option("--status <status>", "New status").option("--assignee <name>", "New assignee").action(async (ticketId, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const ticket = (await readTickets(dataDir, opts.slug)).find((t) => t.id === ticketId);
+	if (!ticket) {
+		console.error(error(`Ticket '${ticketId}' not found`));
+		process.exit(1);
+	}
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const updated = {
+		...ticket,
+		...opts.status ? { status: opts.status } : {},
+		...opts.assignee !== void 0 ? { assignee: opts.assignee } : {},
+		...opts.status === "resolved" && !ticket.resolved ? { resolved: today } : {}
+	};
+	await upsertTicket(dataDir, opts.slug, updated);
+	console.log(success(`✓ Ticket ${bold(ticketId)} updated`));
+});
+ticketCommand.command("close <ticketId>").description("Close a ticket").requiredOption("--slug <slug>", "Customer slug").option("--resolution <text>", "Resolution notes").action(async (ticketId, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const ticket = (await readTickets(dataDir, opts.slug)).find((t) => t.id === ticketId);
+	if (!ticket) {
+		console.error(error(`Ticket '${ticketId}' not found`));
+		process.exit(1);
+	}
+	const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const updated = {
+		...ticket,
+		status: "closed",
+		resolved: ticket.resolved ?? today
+	};
+	await upsertTicket(dataDir, opts.slug, updated);
+	console.log(success(`✓ Ticket ${bold(ticketId)} closed`));
+});
+//#endregion
+//#region src/commands/survey.ts
+const surveyCommand = new Command("survey").description("Manage NPS/CSAT surveys");
+surveyCommand.command("list").description("List all survey definitions").action(() => {
+	const surveys = listSurveys(process.env["DXCRM_DATA_DIR"] ?? process.cwd());
+	if (surveys.length === 0) {
+		console.log(info("No surveys found."));
+		return;
+	}
+	for (const s of surveys) console.log(`  ${bold(s.id)}  [${s.type}]  ${s.question.slice(0, 60)}`);
+});
+surveyCommand.command("create <id>").description("Create a new survey definition").option("--type <type>", "Survey type: nps|csat|ces", "nps").option("--question <q>", "Survey question").action((id, opts) => {
+	writeSurvey(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), {
+		id,
+		type: opts.type ?? "nps",
+		question: opts.question ?? "How likely are you to recommend us? (0–10)",
+		scale: {
+			min: 0,
+			max: 10
+		},
+		includeComment: true,
+		commentPrompt: "What's the main reason for your score?",
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	console.log(success(`✓ Survey '${id}' created`));
+});
+surveyCommand.command("send <surveyId>").description("Generate survey token for a contact").requiredOption("--slug <slug>", "Customer slug").requiredOption("--email <email>", "Contact email").option("--server <url>", "Server URL", process.env["DXCRM_SERVER_URL"] ?? "http://localhost:3456").action(async (surveyId, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	if (!getSurvey(dataDir, surveyId)) {
+		console.error(error(`Survey '${surveyId}' not found`));
+		process.exit(1);
+	}
+	const token = generateSurveyToken(opts.slug, opts.email, surveyId);
+	await savePendingSurvey(dataDir, surveyId, opts.slug, opts.email, token);
+	console.log(success(`✓ Survey token generated`));
+	console.log(info(`  URL: ${opts.server}/survey/respond?token=${token}`));
+});
+surveyCommand.command("results <surveyId>").description("Show survey results and NPS score").option("--slug <slug>", "Filter by customer slug").action((surveyId, opts) => {
+	const responses = loadSurveyResponses(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), surveyId, opts.slug);
+	const nps = calcNpsScore(responses);
+	const promoters = responses.filter((r) => r.score >= 9).length;
+	const detractors = responses.filter((r) => r.score <= 6).length;
+	console.log(bold(`Survey: ${surveyId}`));
+	console.log(info(`Responses: ${responses.length}  NPS: ${nps}  Promoters: ${promoters}  Detractors: ${detractors}`));
+	for (const r of responses) console.log(`  ${r.slug} <${r.contactEmail}>  score=${r.score}${r.comment ? `  "${r.comment.slice(0, 80)}"` : ""}`);
+});
+//#endregion
+//#region src/commands/kb.ts
+const kbCommand = new Command("kb").description("Manage the knowledge base");
+kbCommand.command("list").description("List all KB articles").option("--category <cat>", "Filter by category").option("--public", "Show only public articles").action((opts) => {
+	const articles = listKbArticles(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), {
+		...opts.category ? { category: opts.category } : {},
+		...opts.public ? { publicOnly: true } : {}
+	});
+	if (articles.length === 0) {
+		console.log(info("No articles found."));
+		return;
+	}
+	for (const a of articles) {
+		const pub = a.public ? " [public]" : "";
+		console.log(`  ${bold(a.id)}  [${a.category}]  ${a.title}${pub}`);
+	}
+});
+kbCommand.command("get <id>").description("Get a KB article").action((id) => {
+	const article = getKbArticle(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), id);
+	if (!article) {
+		console.error(error(`Article '${id}' not found`));
+		process.exit(1);
+	}
+	console.log(bold(article.title));
+	console.log(`Category: ${article.category}  Tags: ${article.tags.join(", ") || "(none)"}`);
+	console.log("\n" + article.body);
+});
+kbCommand.command("search <query>").description("Search KB articles").option("--public", "Search only public articles").action((query, opts) => {
+	const results = searchKbSimple(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), query, opts.public ? { publicOnly: true } : {});
+	if (results.length === 0) {
+		console.log(info("No results."));
+		return;
+	}
+	for (const a of results) {
+		console.log(`  ${bold(a.id)}  ${a.title}`);
+		console.log(`    ${a.body.slice(0, 120).replace(/\n/g, " ")}...`);
+	}
+});
+kbCommand.command("create <id>").description("Create a KB article (opens editor-ready template)").requiredOption("--title <title>", "Article title").option("--category <cat>", "Category", "general").option("--ticket <id>", "Source ticket ID").action((id, opts) => {
+	const dataDir = process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	writeKbArticle(dataDir, {
+		id,
+		title: opts.title,
+		category: opts.category,
+		tags: [],
+		public: false,
+		createdAt: now,
+		updatedAt: now,
+		...opts.ticket ? { sourceTicketId: opts.ticket } : {},
+		body: `## Problem\n\n[Describe the problem]\n\n## Solution\n\n[Describe the solution]`
+	});
+	console.log(success(`✓ Article '${id}' created in category '${opts.category}'`));
+	console.log(info(`Edit: .agentic/knowledge-base/${opts.category}/${id}.md`));
+});
+kbCommand.command("delete <id>").description("Delete a KB article").action((id) => {
+	if (deleteKbArticle(process.env["DXCRM_DATA_DIR"] ?? process.cwd(), id)) console.log(success(`✓ Article '${id}' deleted`));
+	else {
+		console.error(error(`Article '${id}' not found`));
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/fields.ts
+const VALID_TYPES = [
+	"text",
+	"number",
+	"boolean",
+	"date",
+	"select"
+];
+function dataDir$16() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+function collect(value, prev) {
+	return [...prev, value];
+}
+/** Parse a `--field name:type[:opt1|opt2]` spec into a FieldDefinition. */
+function parseFieldSpec(spec) {
+	const [name, type, opts] = spec.split(":");
+	if (!name || !type || !VALID_TYPES.includes(type)) return null;
+	return {
+		name,
+		type,
+		...opts ? { options: opts.split("|").map((s) => s.trim()) } : {}
+	};
+}
+const fieldsCommand = new Command("fields").description("Manage custom fields (metadata-driven extensibility)");
+fieldsCommand.command("list").description("List defined custom fields").action(async () => {
+	const { loadFieldDefinitions } = await import("./custom-fields-CzNeD3_v.js");
+	const defs = loadFieldDefinitions(dataDir$16());
+	if (defs.length === 0) {
+		console.log(info("No custom fields defined. Add one with: dxcrm fields add <name> <type>"));
+		return;
+	}
+	for (const d of defs) {
+		const opts = d.options ? ` [${d.options.join(", ")}]` : "";
+		console.log(`${d.name} (${d.type})${opts}${d.label ? ` — ${d.label}` : ""}`);
+	}
+});
+fieldsCommand.command("add <name> <type>").description("Define a custom field (type: text|number|boolean|date|select)").option("--label <label>", "Human-readable label").option("--options <csv>", "Comma-separated options (for select)").action(async (name, type, opts) => {
+	if (!VALID_TYPES.includes(type)) {
+		console.error(error(`Invalid type '${type}'. Use one of: ${VALID_TYPES.join(", ")}`));
+		process.exitCode = 1;
+		return;
+	}
+	const { defineCustomField } = await import("./custom-fields-CzNeD3_v.js");
+	defineCustomField(dataDir$16(), {
+		name,
+		type,
+		...opts.label ? { label: opts.label } : {},
+		...opts.options ? { options: opts.options.split(",").map((s) => s.trim()) } : {}
+	});
+	console.log(success(`Custom field '${name}' (${type}) defined.`));
+});
+const objectCommand = new Command("object").description("Manage custom objects (runtime-defined entities, no-migration)");
+objectCommand.command("define <name>").description("Define a custom object with fields (--field name:type[:opt1|opt2])").option("--label <label>", "Human-readable label").option("--field <spec>", "Field spec, repeatable", collect, []).action(async (name, opts) => {
+	const fields = [];
+	for (const spec of opts.field) {
+		const f = parseFieldSpec(spec);
+		if (!f) {
+			console.error(error(`Invalid --field spec '${spec}' (use name:type[:a|b])`));
+			process.exitCode = 1;
+			return;
+		}
+		fields.push(f);
+	}
+	const { defineCustomObject } = await import("./custom-objects-CIFrmQ2V.js");
+	defineCustomObject(dataDir$16(), {
+		name,
+		...opts.label ? { label: opts.label } : {},
+		fields
+	});
+	console.log(success(`Custom object '${name}' defined with ${fields.length} field(s).`));
+});
+objectCommand.command("add <name>").description("Create a record (--set key=value, repeatable)").option("--set <kv>", "key=value, repeatable", collect, []).action(async (name, opts) => {
+	const values = {};
+	for (const kv of opts.set) {
+		const eq = kv.indexOf("=");
+		if (eq < 0) continue;
+		values[kv.slice(0, eq).trim()] = kv.slice(eq + 1).trim();
+	}
+	const { createRecord } = await import("./custom-objects-CIFrmQ2V.js");
+	const res = createRecord(dataDir$16(), name, values);
+	if (!res.ok) {
+		console.error(error(`Could not create record: ${(res.errors ?? []).join("; ")}`));
+		process.exitCode = 1;
+		return;
+	}
+	console.log(success(`Created ${name} record ${res.record.id}`));
+});
+objectCommand.command("list <name>").description("List records of a custom object").action(async (name) => {
+	const { listRecords } = await import("./custom-objects-CIFrmQ2V.js");
+	const records = listRecords(dataDir$16(), name);
+	if (records.length === 0) {
+		console.log(info(`No records for '${name}'.`));
+		return;
+	}
+	for (const r of records) console.log(`${r.id}  ${JSON.stringify(r.values)}`);
+});
+//#endregion
+//#region src/commands/webhook.ts
+function dataDir$15() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const webhookCommand = new Command("webhook").description("Manage outbound webhooks (event-driven integrations)");
+webhookCommand.command("add <url>").description("Subscribe a URL to events (--events record.created,deal.updated or '*')").option("--events <csv>", "Comma-separated event patterns", "*").option("--secret <secret>", "HMAC secret for X-DXCRM-Signature").action(async (url, opts) => {
+	const { addWebhook } = await import("./webhooks-7EpA05Qr.js");
+	const events = opts.events.split(",").map((s) => s.trim()).filter(Boolean);
+	const sub = addWebhook(dataDir$15(), url, events, opts.secret);
+	console.log(success(`Webhook ${sub.id} → ${url} [${events.join(", ")}]`));
+});
+webhookCommand.command("list").description("List webhook subscriptions").action(async () => {
+	const { loadWebhooks } = await import("./webhooks-7EpA05Qr.js");
+	const subs = loadWebhooks(dataDir$15());
+	if (subs.length === 0) {
+		console.log(info("No webhooks configured."));
+		return;
+	}
+	for (const s of subs) console.log(`${s.id}  ${s.url}  [${s.events.join(", ")}]`);
+});
+webhookCommand.command("remove <id>").description("Remove a webhook subscription").action(async (id) => {
+	const { removeWebhook } = await import("./webhooks-7EpA05Qr.js");
+	if (removeWebhook(dataDir$15(), id)) console.log(success(`Removed ${id}`));
+	else {
+		console.error(error(`Not found: ${id}`));
+		process.exitCode = 1;
+	}
+});
+webhookCommand.command("retry").description("Re-attempt failed webhook deliveries (replay store)").action(async () => {
+	const { retryFailures } = await import("./webhooks-7EpA05Qr.js");
+	const r = await retryFailures(dataDir$15());
+	console.log(info(`Retried ${r.retried}, still failing ${r.stillFailing}.`));
+});
+//#endregion
+//#region src/commands/segment.ts
+function dataDir$14() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const segmentCommand = new Command("segment").description("Manage customer segments (marketing lists)");
+segmentCommand.command("define <name>").description("Define a segment by criteria").option("--stage <stage>", "relationship_stage (prospect|active|churned|paused)").option("--tags <csv>", "Comma-separated tags (all must match)").option("--min-deal-value <n>", "Minimum deal value").option("--stale-days <n>", "Days since last update (staleness)").action(async (name, opts) => {
+	const criteria = {
+		...opts.stage ? { stage: opts.stage } : {},
+		...opts.tags ? { tags: opts.tags.split(",").map((s) => s.trim()) } : {},
+		...opts.minDealValue ? { minDealValue: Number(opts.minDealValue) } : {},
+		...opts.staleDays ? { staleDays: Number(opts.staleDays) } : {}
+	};
+	const { defineSegment } = await import("./segments-BqcD5HIl.js");
+	defineSegment(dataDir$14(), name, criteria);
+	console.log(success(`Segment '${name}' defined: ${JSON.stringify(criteria)}`));
+});
+segmentCommand.command("list").description("List defined segments").action(async () => {
+	const { loadSegments } = await import("./segments-BqcD5HIl.js");
+	const segs = loadSegments(dataDir$14());
+	if (segs.length === 0) {
+		console.log(info("No segments defined."));
+		return;
+	}
+	for (const s of segs) console.log(`${s.name}  ${JSON.stringify(s.criteria)}`);
+});
+segmentCommand.command("members <name>").description("List customers matching a segment").action(async (name) => {
+	const { loadSegments, evaluateSegment } = await import("./segments-BqcD5HIl.js");
+	const seg = loadSegments(dataDir$14()).find((s) => s.name === name);
+	if (!seg) {
+		console.error(error(`Segment not found: ${name}`));
+		process.exitCode = 1;
+		return;
+	}
+	const members = await evaluateSegment(dataDir$14(), seg.criteria);
+	console.log(info(`${members.length} member(s):`));
+	for (const slug of members) console.log(slug);
+});
+//#endregion
+//#region src/commands/identity.ts
+function dataDir$13() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const identityCommand = new Command("identity").description("Identity resolution / deduplication (CDP)");
+identityCommand.command("duplicates").description("Find clusters of likely-duplicate customers (by canonical domain)").action(async () => {
+	const { findDuplicateClusters } = await import("./identity-gyfWdrcX.js");
+	const clusters = await findDuplicateClusters(dataDir$13());
+	if (clusters.length === 0) {
+		console.log(info("No duplicate clusters found."));
+		return;
+	}
+	console.log(info(`${clusters.length} duplicate cluster(s):`));
+	for (const c of clusters) console.log(`${c.key}: ${c.slugs.join(", ")}`);
+});
+//#endregion
+//#region src/commands/metrics.ts
+function dataDir$12() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const metricsCommand = new Command("metrics").description("Command-center metrics from the audit trail").action(async () => {
+	const { computeAuditMetrics } = await import("./metrics-DH8wHvya.js");
+	const m = computeAuditMetrics(dataDir$12());
+	console.log(bold("Command Center"));
+	console.log(`Total operations:   ${m.totalOperations}`);
+	console.log(`Customers touched:  ${m.customersTouched}`);
+	console.log(`Automation rate:    ${(m.automationRate * 100).toFixed(0)}%`);
+	console.log(info("By tool:"));
+	for (const [tool, n] of Object.entries(m.byTool).sort((a, b) => b[1] - a[1])) console.log(`  ${tool}: ${n}`);
+	console.log(info("By actor:"));
+	for (const [actor, n] of Object.entries(m.byActor).sort((a, b) => b[1] - a[1])) console.log(`  ${actor}: ${n}`);
+});
+//#endregion
+//#region src/commands/usage.ts
+function dataDir$11() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const usageCommand = new Command("usage").description("LLM token usage & cost (per customer)").option("--slug <slug>", "Filter by customer").action(async (opts) => {
+	const { aggregateUsage } = await import("./usage-D0-TYJkw.js");
+	const agg = aggregateUsage(dataDir$11(), opts.slug ? { slug: opts.slug } : {});
+	console.log(bold("LLM Usage"));
+	console.log(`Calls:          ${agg.calls}`);
+	console.log(`Input tokens:   ${agg.totalInputTokens}`);
+	console.log(`Output tokens:  ${agg.totalOutputTokens}`);
+	console.log(`Cost (USD):     $${agg.totalCostUsd.toFixed(4)}`);
+	if (!opts.slug) {
+		console.log(info("By customer:"));
+		for (const [slug, b] of Object.entries(agg.bySlug).sort((a, b) => b[1].costUsd - a[1].costUsd)) console.log(`  ${slug}: $${b.costUsd.toFixed(4)} (${b.calls} calls)`);
+	}
+});
+//#endregion
+//#region src/commands/approvals.ts
+function dataDir$10() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const approvalsCommand = new Command("approvals").description("Human-in-the-loop approval queue");
+approvalsCommand.command("list").description("List approvals (default: pending)").option("--status <status>", "pending | approved | rejected", "pending").action(async (opts) => {
+	const { listApprovals } = await import("./approvals-DpjxGHFp.js");
+	const list = listApprovals(dataDir$10(), opts.status);
+	if (list.length === 0) {
+		console.log(info(`No ${opts.status} approvals.`));
+		return;
+	}
+	for (const a of list) console.log(`${a.id}  ${a.tool}  ${a.slug ?? "-"}  ${a.requestedAt}`);
+});
+approvalsCommand.command("approve <id>").description("Approve a pending action").action(async (id) => {
+	const { decideApproval } = await import("./approvals-DpjxGHFp.js");
+	if (decideApproval(dataDir$10(), id, "approved")) console.log(success(`Approved ${id}`));
+	else {
+		console.error(error(`Not found: ${id}`));
+		process.exitCode = 1;
+	}
+});
+approvalsCommand.command("reject <id>").description("Reject a pending action").action(async (id) => {
+	const { decideApproval } = await import("./approvals-DpjxGHFp.js");
+	if (decideApproval(dataDir$10(), id, "rejected")) console.log(success(`Rejected ${id}`));
+	else {
+		console.error(error(`Not found: ${id}`));
+		process.exitCode = 1;
+	}
+});
+const policyCommand = new Command("policy").description("Autonomy policy per tool/customer (auto|approve|block)");
+policyCommand.command("set <tool> <policy>").description("Set autonomy policy for a tool (optionally per --slug)").option("--slug <slug>", "Customer slug (per-customer override)").action(async (tool, policy, opts) => {
+	if (![
+		"auto",
+		"approve",
+		"block"
+	].includes(policy)) {
+		console.error(error("policy must be auto | approve | block"));
+		process.exitCode = 1;
+		return;
+	}
+	const { setPolicy } = await import("./approvals-DpjxGHFp.js");
+	setPolicy(dataDir$10(), tool, policy, opts.slug);
+	console.log(success(`Policy ${tool}${opts.slug ? `@${opts.slug}` : ""} = ${policy}`));
+});
+//#endregion
+//#region src/commands/hygiene.ts
+function dataDir$9() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const hygieneCommand = new Command("hygiene").description("Data-quality scanning");
+hygieneCommand.command("scan").description("Scan customers for data-quality issues (missing/malformed/duplicate)").action(async () => {
+	const { scanHygiene } = await import("./hygiene-DZqfYpFf.js");
+	const issues = await scanHygiene(dataDir$9());
+	if (issues.length === 0) {
+		console.log(success("✓ No data-quality issues found."));
+		return;
+	}
+	console.log(info(`${issues.length} issue(s):`));
+	for (const i of issues) {
+		const fix = i.suggestedFix ? `  → fix: ${i.suggestedFix}` : "";
+		console.log(`  [${i.type}] ${i.slug}: ${i.detail}${fix}`);
+	}
+});
+//#endregion
+//#region src/commands/memory.ts
+function dataDir$8() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const TYPES = [
+	"fact",
+	"preference",
+	"learning",
+	"instruction"
+];
+const memoryCommand = new Command("memory").description("Agent memories (per customer + global)");
+memoryCommand.command("add <text>").description("Add a memory (global unless --slug given)").option("--type <type>", "fact | preference | learning | instruction", "fact").option("--slug <slug>", "Customer slug (omit for global)").action(async (text, opts) => {
+	const type = TYPES.includes(opts.type) ? opts.type : "fact";
+	const { addMemory } = await import("./memory-Cy6-Tbyl.js");
+	const m = addMemory(dataDir$8(), {
+		scope: opts.slug ? "customer" : "global",
+		...opts.slug ? { slug: opts.slug } : {},
+		type,
+		text
+	});
+	console.log(success(`Memory ${m.id} stored (${m.scope}${opts.slug ? `:${opts.slug}` : ""}).`));
+});
+memoryCommand.command("list").description("List memories (global + customer if --slug)").option("--slug <slug>", "Customer slug").action(async (opts) => {
+	const { loadMemories } = await import("./memory-Cy6-Tbyl.js");
+	const mems = loadMemories(dataDir$8(), opts.slug);
+	if (mems.length === 0) {
+		console.log(info("No memories."));
+		return;
+	}
+	for (const m of mems) console.log(`[${m.scope}/${m.type}] ${m.text}`);
+});
+memoryCommand.command("search <query>").description("Search memories by relevance").option("--slug <slug>", "Customer slug").action(async (query, opts) => {
+	const { searchMemory } = await import("./memory-Cy6-Tbyl.js");
+	const hits = await searchMemory(dataDir$8(), query, opts.slug);
+	if (hits.length === 0) {
+		console.log(info("No matching memories."));
+		return;
+	}
+	for (const m of hits) console.log(`[${m.scope}/${m.type}] ${m.text}`);
+});
+//#endregion
+//#region src/commands/sop.ts
+function dataDir$7() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const sopCommand = new Command("sop").description("Standard Operating Procedures (global / per customer)");
+sopCommand.command("add <title>").description("Add an SOP (global unless --slug given)").option("--triggers <csv>", "Comma-separated trigger keywords", "").option("--body <text>", "SOP body / steps", "").option("--slug <slug>", "Customer slug (omit for global)").action(async (title, opts) => {
+	const { addSop } = await import("./sop-DkhVChGy.js");
+	const triggers = opts.triggers.split(",").map((s) => s.trim()).filter(Boolean);
+	const s = addSop(dataDir$7(), {
+		scope: opts.slug ? "customer" : "global",
+		...opts.slug ? { slug: opts.slug } : {},
+		title,
+		triggers,
+		body: opts.body
+	});
+	console.log(success(`SOP ${s.id} added (${s.scope}${opts.slug ? `:${opts.slug}` : ""}).`));
+});
+sopCommand.command("list").description("List SOPs (global + customer if --slug)").option("--slug <slug>", "Customer slug").action(async (opts) => {
+	const { loadSops } = await import("./sop-DkhVChGy.js");
+	const sops = loadSops(dataDir$7(), opts.slug);
+	if (sops.length === 0) {
+		console.log(info("No SOPs."));
+		return;
+	}
+	for (const s of sops) console.log(`[${s.scope}] ${s.title}  (${s.triggers.join(", ")})`);
+});
+sopCommand.command("find <query>").description("Find SOPs relevant to a task").option("--slug <slug>", "Customer slug").action(async (query, opts) => {
+	const { findSops } = await import("./sop-DkhVChGy.js");
+	const hits = await findSops(dataDir$7(), query, opts.slug);
+	if (hits.length === 0) {
+		console.log(info("No matching SOPs."));
+		return;
+	}
+	for (const s of hits) console.log(`[${s.scope}] ${s.title}`);
+});
+//#endregion
+//#region src/commands/tone.ts
+function dataDir$6() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const toneCommand = new Command("tone").description("Customer tonality profiles (per customer + global)");
+toneCommand.command("set").description("Set tone profile (global unless --slug given)").option("--formality <v>", "formal | casual | friendly").option("--language <v>", "Language code, e.g. de | en").option("--do <csv>", "Comma-separated phrases to prefer").option("--dont <csv>", "Comma-separated phrases to avoid").option("--slug <slug>", "Customer slug (omit for global)").action(async (opts) => {
+	const { setTone } = await import("./tone-Bdm5uaht.js");
+	setTone(dataDir$6(), {
+		...opts.formality ? { formality: opts.formality } : {},
+		...opts.language ? { language: opts.language } : {},
+		...opts.do ? { dos: opts.do.split(",").map((s) => s.trim()) } : {},
+		...opts.dont ? { donts: opts.dont.split(",").map((s) => s.trim()) } : {}
+	}, opts.slug);
+	console.log(success(`Tone profile saved (${opts.slug ? `customer:${opts.slug}` : "global"}).`));
+});
+toneCommand.command("show").description("Show the effective tone profile").option("--slug <slug>", "Customer slug").action(async (opts) => {
+	const { resolveTone, toneInstruction } = await import("./tone-Bdm5uaht.js");
+	const profile = resolveTone(dataDir$6(), opts.slug);
+	console.log(info(JSON.stringify(profile)));
+	console.log(`instruction: ${toneInstruction(profile) || "(none)"}`);
+});
+//#endregion
+//#region src/commands/autofill.ts
+const autofillCommand = new Command("autofill").description("Extract structured CRM fields from a transcript file").argument("<file>", "Path to transcript file").option("--slug <slug>", "Customer slug (for usage attribution)").action(async (file, opts) => {
+	if (!fs.existsSync(file)) {
+		console.error(error(`File not found: ${file}`));
+		process.exitCode = 1;
+		return;
+	}
+	const transcript = fs.readFileSync(file, "utf-8");
+	const { extractAutofill } = await import("./autofill-Di_-SP7t.js");
+	const result = await extractAutofill(transcript, opts.slug ? { slug: opts.slug } : {});
+	console.log(info("Extracted fields (review before applying):"));
+	console.log(JSON.stringify(result, null, 2));
+});
+//#endregion
+//#region src/commands/ask.ts
+function dataDir$5() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const askCommand = new Command("ask").description("Ask your CRM a natural-language question").argument("<question>", "The question").option("--slug <slug>", "Scope to a customer").action(async (question, opts) => {
+	const { askCrm } = await import("./ask-CID3jnuL.js");
+	const res = await askCrm(dataDir$5(), question, opts.slug);
+	if (res.answer) {
+		console.log(bold("Answer:"));
+		console.log(res.answer);
+	}
+	if (res.sources.length === 0) {
+		console.log(info("No relevant data found."));
+		return;
+	}
+	console.log(info("Sources:"));
+	res.sources.forEach((s, i) => console.log(`  [${i + 1}] ${s.text.slice(0, 120)}`));
+});
+//#endregion
+//#region src/commands/nba.ts
+function dataDir$4() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const nbaCommand = new Command("nba").description("Next-best-action recommendations for a customer").argument("<slug>", "Customer slug").action(async (slug) => {
+	const { nextBestAction } = await import("./nba-3wanmJ0U.js");
+	const actions = await nextBestAction(dataDir$4(), slug);
+	if (actions.length === 0) {
+		console.log(info("No recommendations."));
+		return;
+	}
+	for (const a of actions) console.log(`[${a.priority}] ${a.action} — ${a.reason}`);
+});
+//#endregion
+//#region src/commands/vault.ts
+function dataDir$3() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+/** Master key from the environment only — never a flag (avoids shell history). */
+function masterKey() {
+	const key = process.env["DXCRM_VAULT_KEY"];
+	if (!key) {
+		console.error(error("DXCRM_VAULT_KEY is not set. Export your vault master key first."));
+		process.exit(1);
+	}
+	return key;
+}
+/** Run a vault action, turning decryption/IO failures into a clean exit. */
+async function guard(fn) {
+	try {
+		await fn();
+	} catch (e) {
+		console.error(error(e.message));
+		process.exit(1);
+	}
+}
+const vaultCommand = new Command("vault").description("Local encrypted credential vault (AES-256-GCM)");
+vaultCommand.command("set <name> <value>").description("Store (or overwrite) a secret").action((name, value) => guard(async () => {
+	const { setSecret } = await import("./vault-C1D3zScD.js");
+	setSecret(dataDir$3(), masterKey(), name, value);
+	console.log(success(`Secret '${name}' stored.`));
+}));
+vaultCommand.command("get <name>").description("Retrieve a secret").action((name) => guard(async () => {
+	const { getSecret } = await import("./vault-C1D3zScD.js");
+	const value = getSecret(dataDir$3(), masterKey(), name);
+	if (value === void 0) {
+		console.log(info(`No secret named '${name}'.`));
+		return;
+	}
+	console.log(value);
+}));
+vaultCommand.command("list").description("List secret names (values stay encrypted)").action(() => guard(async () => {
+	const { listSecretKeys } = await import("./vault-C1D3zScD.js");
+	const names = listSecretKeys(dataDir$3(), masterKey());
+	if (names.length === 0) {
+		console.log(info("Vault is empty."));
+		return;
+	}
+	for (const n of names.sort()) console.log(n);
+}));
+vaultCommand.command("rm <name>").description("Remove a secret").action((name) => guard(async () => {
+	const { removeSecret } = await import("./vault-C1D3zScD.js");
+	const removed = removeSecret(dataDir$3(), masterKey(), name);
+	console.log(removed ? success(`Secret '${name}' removed.`) : info(`No secret named '${name}'.`));
+}));
+//#endregion
+//#region src/commands/churn.ts
+function dataDir$2() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+function paint(level, text) {
+	if (level === "high") return error(text);
+	if (level === "medium") return warning(text);
+	return success(text);
+}
+const churnCommand = new Command("churn").description("Churn early-warning (relationship-health based)");
+churnCommand.command("assess <slug>").description("Assess churn risk for one customer").action(async (slug) => {
+	const { assessChurn } = await import("./churn-C28IgnAj.js");
+	const r = assessChurn(dataDir$2(), slug);
+	console.log(paint(r.level, `${slug}: ${r.level.toUpperCase()} risk (${r.riskScore}/100)`));
+	for (const s of r.signals) console.log(`  • ${s}`);
+});
+churnCommand.command("scan").description("Rank all customers by churn risk (highest first)").action(async () => {
+	const { scanChurn } = await import("./churn-C28IgnAj.js");
+	const ranked = scanChurn(dataDir$2());
+	if (ranked.length === 0) {
+		console.log(info("No customers to assess."));
+		return;
+	}
+	for (const r of ranked) console.log(paint(r.level, `${r.riskScore.toString().padStart(3)}  ${r.level.padEnd(6)}  ${r.slug}`));
+});
+//#endregion
+//#region src/commands/leadscore.ts
+function dataDir$1() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const leadscoreCommand = new Command("leadscore").description("Predictive lead scoring (logistic regression on won/lost history)");
+leadscoreCommand.command("train").description("Train the model from won/lost history and persist it").action(async () => {
+	const { buildLeadModel, saveLeadModel } = await import("./lead-model-BCFzyktm.js");
+	const model = buildLeadModel(dataDir$1());
+	if (!model.sufficient) {
+		console.log(warning(`Not enough closed history to train (${model.trainedOn} deals, need ≥4 with both outcomes).`));
+		console.log(info("Predictions fall back to the deterministic heuristic until then."));
+		return;
+	}
+	saveLeadModel(dataDir$1(), model);
+	console.log(success(`Trained on ${model.trainedOn} closed deals. Model saved.`));
+});
+leadscoreCommand.command("predict <slug>").description("Score a customer's open deals with the trained model").action(async (slug) => {
+	const { loadLeadModel, buildLeadModel, predictWin } = await import("./lead-model-BCFzyktm.js");
+	const { readPipelineSync } = await import("./pipeline-writer-BqBrYrQc.js");
+	const model = loadLeadModel(dataDir$1()) ?? buildLeadModel(dataDir$1());
+	const open = readPipelineSync(dataDir$1(), slug).filter((d) => d.stage !== "won" && d.stage !== "lost");
+	if (open.length === 0) {
+		console.log(info(`No open deals for ${slug}.`));
+		return;
+	}
+	const source = model.sufficient ? "model" : "heuristic";
+	console.log(info(`Win-probability for ${slug} (${source}):`));
+	for (const d of open) {
+		const p = Math.round(predictWin(model, d) * 100);
+		console.log(`  ${String(p).padStart(3)}%  ${d.name} (${d.stage})`);
+	}
+});
+//#endregion
+//#region src/commands/enrich.ts
+function dataDir() {
+	return process.env["DXCRM_DATA_DIR"] ?? process.cwd();
+}
+const enrichCommand = new Command("enrich").description("Enrich a customer's facts (offline domain-from-email + plugins)").argument("<slug>", "Customer slug").option("--write", "Write newly-derived fields back to main_facts.md").action(async (slug, opts) => {
+	const { enrichCustomer } = await import("./enrichment-3XvgGDfB.js");
+	const res = await enrichCustomer(dataDir(), slug, { write: opts.write ?? false });
+	const applied = Object.entries(res.applied);
+	if (applied.length === 0) {
+		console.log(info(`Nothing new to enrich for ${slug}.`));
+		return;
+	}
+	for (const [k, v] of applied) console.log(`  ${k}: ${String(v)}`);
+	console.log(res.written ? success(`Applied ${applied.length} field(s) to ${slug}.`) : info(`Found ${applied.length} field(s) — re-run with --write to apply.`));
+});
+//#endregion
+//#region src/commands/coach.ts
+const coachCommand = new Command("coach").description("Conversation-intelligence: analyze a call transcript").argument("<file>", "Path to a speaker-labelled transcript (\"Rep: ...\" / \"Customer: ...\")").option("--rep <labels>", "Comma-separated speaker labels treated as the rep", "rep,sales,ae,me,agent").action(async (file, opts) => {
+	if (!fs.existsSync(file)) {
+		console.error(`Transcript not found: ${file}`);
+		process.exit(1);
+	}
+	const transcript = fs.readFileSync(file, "utf-8");
+	const { analyzeConversation } = await import("./conversation-intel-mm7Lhemh.js");
+	const a = analyzeConversation(transcript, opts.rep.split(",").map((s) => s.trim()).filter(Boolean));
+	console.log(success(`Conversation analysis (${a.turns} turns)`));
+	console.log(`  Talk ratio (rep):   ${Math.round(a.talkRatio * 100)}%`);
+	console.log(`  Questions asked:    ${a.questionsAsked}`);
+	console.log(`  Longest monologue:  ${a.longestMonologue} words`);
+	if (a.objections.length > 0) {
+		console.log(info("  Objections:"));
+		for (const o of a.objections) console.log(`    • ${o}`);
+	}
+	console.log(info("  Coaching:"));
+	for (const c of a.coaching) console.log(`    → ${c}`);
+});
+//#endregion
+//#region src/commands/compliance.ts
+const complianceCommand = new Command("compliance").description("Privacy/compliance posture (AI-Act Art. 50, local-LLM, PII, guardrails)");
+complianceCommand.command("status", { isDefault: true }).description("Show the active compliance configuration").action(async () => {
+	const { complianceConfig, aiDisclosure } = await import("./compliance-CujOqAKk.js");
+	const cfg = complianceConfig();
+	const onOff = (b) => b ? success("on") : warning("off");
+	console.log(info("Compliance posture"));
+	console.log(`  LLM provider:        ${cfg.provider}`);
+	if (cfg.local) {
+		console.log(`  Local endpoint:      ${cfg.local.baseUrl}`);
+		console.log(`  Local model:         ${cfg.local.model}`);
+		console.log(success("  → Customer data stays on-machine (data-residency moat)."));
+	}
+	console.log(`  AI-Act Art.50 label: ${onOff(cfg.aiDisclosure)}`);
+	console.log(`  PII masking:         ${onOff(cfg.piiMasking)}`);
+	console.log(`  Prompt guardrails:   ${onOff(cfg.guardrails)}`);
+	if (cfg.aiDisclosure) console.log(info(`  Disclosure: "${aiDisclosure()}"`));
+});
+//#endregion
+//#region src/cli.ts
+const program = new Command();
+program.name("dxcrm").description("DatasynxOpenCRM — local-first, MCP-native CRM").version("0.1.0").exitOverride();
+program.addCommand(initCommand);
+program.addCommand(createCommand);
+program.addCommand(listCommand);
+program.addCommand(validateCommand);
+program.addCommand(sessionCommand);
+program.addCommand(guideCommand);
+program.addCommand(mcpCommand);
+program.addCommand(syncCommand);
+program.addCommand(backupCommand);
+program.addCommand(restoreCommand);
+program.addCommand(daemonCommand);
+program.addCommand(statusCommand);
+program.addCommand(agentCommand);
+program.addCommand(importCommand);
+program.addCommand(serverCommand);
+program.addCommand(auditCommand);
+program.addCommand(rbacCommand);
+program.addCommand(gdprCommand);
+program.addCommand(securityReportCommand);
+program.addCommand(stagesCommand);
+program.addCommand(pluginCommand);
+program.addCommand(goalCommand);
+program.addCommand(pushCommand);
+program.addCommand(attachCommand);
+program.addCommand(templateCommand);
+program.addCommand(sequenceCommand);
+program.addCommand(quoteCommand);
+program.addCommand(ticketCommand);
+program.addCommand(surveyCommand);
+program.addCommand(kbCommand);
+program.addCommand(fieldsCommand);
+program.addCommand(objectCommand);
+program.addCommand(webhookCommand);
+program.addCommand(segmentCommand);
+program.addCommand(identityCommand);
+program.addCommand(metricsCommand);
+program.addCommand(usageCommand);
+program.addCommand(approvalsCommand);
+program.addCommand(policyCommand);
+program.addCommand(hygieneCommand);
+program.addCommand(memoryCommand);
+program.addCommand(sopCommand);
+program.addCommand(toneCommand);
+program.addCommand(autofillCommand);
+program.addCommand(askCommand);
+program.addCommand(nbaCommand);
+program.addCommand(vaultCommand);
+program.addCommand(churnCommand);
+program.addCommand(leadscoreCommand);
+program.addCommand(enrichCommand);
+program.addCommand(coachCommand);
+program.addCommand(complianceCommand);
+await program.parseAsync(process.argv);
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map