@operor/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2268 @@
+#!/usr/bin/env node
+import { t as applyLLMOverride } from "./llm-override-BIQl0V6H.js";
+import { Command } from "commander";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import * as clack from "@clack/prompts";
+import matter from "gray-matter";
+import { AIProvider } from "@operor/llm";
+import { catalogEntryToConfig, findSkillInCatalog, loadSkillCatalog } from "@operor/skills";
+import fs from "fs";
+import * as readline from "node:readline";
+import { createInterface } from "node:readline";
+import { access, cp, mkdir, readdir } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+//#region src/log-timestamps.ts
+/**
+* Global console override that prepends timestamps to all log output.
+* Format: [YYYY-MM-DD HH:mm:ss.SSS] — similar to NLog/structured logging.
+*
+* Import this file once at the entry point (index.ts) for automatic timestamps.
+*/
+const originalLog = console.log;
+const originalWarn = console.warn;
+const originalError = console.error;
+function timestamp() {
+	const now = /* @__PURE__ */ new Date();
+	return `[${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}.${String(now.getMilliseconds()).padStart(3, "0")}]`;
+}
+console.log = (...args) => originalLog(timestamp(), ...args);
+console.warn = (...args) => originalWarn(timestamp(), ...args);
+console.error = (...args) => originalError(timestamp(), ...args);
+
+//#endregion
+//#region src/config.ts
+const ENV_PATH = resolve(process.cwd(), ".env");
+function configExists() {
+	return existsSync(ENV_PATH);
+}
+function readConfig() {
+	if (!existsSync(ENV_PATH)) return {};
+	const content = readFileSync(ENV_PATH, "utf-8");
+	const config = {};
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		config[key] = trimmed.slice(eqIndex + 1).trim();
+	}
+	return config;
+}
+function writeConfig(config) {
+	const lines = [
+		"# Operor Configuration",
+		"# Generated by operor setup",
+		""
+	];
+	const sections = [
+		{
+			header: "LLM",
+			keys: [
+				"LLM_PROVIDER",
+				"LLM_API_KEY",
+				"LLM_MODEL",
+				"LLM_BASE_URL"
+			]
+		},
+		{
+			header: "Channel",
+			keys: ["CHANNEL"]
+		},
+		{
+			header: "Telegram",
+			keys: ["TELEGRAM_BOT_TOKEN"]
+		},
+		{
+			header: "Skills",
+			keys: ["SKILLS_ENABLED"]
+		},
+		{
+			header: "WATI",
+			keys: [
+				"WATI_API_TOKEN",
+				"WATI_TENANT_ID",
+				"WATI_WEBHOOK_PORT"
+			]
+		},
+		{
+			header: "Memory",
+			keys: ["MEMORY_TYPE", "MEMORY_DB_PATH"]
+		},
+		{
+			header: "Intent",
+			keys: ["INTENT_CLASSIFIER"]
+		},
+		{
+			header: "Knowledge Base",
+			keys: [
+				"KB_ENABLED",
+				"KB_DB_PATH",
+				"KB_EMBEDDING_PROVIDER",
+				"KB_EMBEDDING_MODEL",
+				"KB_EMBEDDING_API_KEY",
+				"KB_RENDER_JS",
+				"KB_CHUNK_SIZE",
+				"KB_CHUNK_OVERLAP"
+			]
+		},
+		{
+			header: "Training Mode",
+			keys: ["TRAINING_MODE_ENABLED", "TRAINING_MODE_WHITELIST"]
+		},
+		{
+			header: "Training Copilot",
+			keys: [
+				"COPILOT_ENABLED",
+				"COPILOT_DB_PATH",
+				"COPILOT_TRACKING_THRESHOLD",
+				"COPILOT_CLUSTER_THRESHOLD",
+				"COPILOT_DIGEST_INTERVAL",
+				"COPILOT_DIGEST_MAX_ITEMS",
+				"COPILOT_AUTO_SUGGEST"
+			]
+		},
+		{
+			header: "Analytics",
+			keys: [
+				"ANALYTICS_ENABLED",
+				"ANALYTICS_DB_PATH",
+				"ANALYTICS_DIGEST_ENABLED",
+				"ANALYTICS_DIGEST_SCHEDULE",
+				"ANALYTICS_DIGEST_TIME"
+			]
+		}
+	];
+	const knownKeys = /* @__PURE__ */ new Set();
+	for (const section of sections) {
+		const sectionLines = [];
+		for (const key of section.keys) {
+			knownKeys.add(key);
+			if (config[key]) sectionLines.push(`${key}=${config[key]}`);
+		}
+		if (sectionLines.length > 0) {
+			lines.push(`# ${section.header}`);
+			lines.push(...sectionLines);
+			lines.push("");
+		}
+	}
+	const extraLines = [];
+	for (const [key, value] of Object.entries(config)) if (value && !knownKeys.has(key)) extraLines.push(`${key}=${value}`);
+	if (extraLines.length > 0) {
+		lines.push("# Other");
+		lines.push(...extraLines);
+		lines.push("");
+	}
+	writeFileSync(ENV_PATH, lines.join("\n"));
+}
+
+//#endregion
+//#region src/setup.ts
+function detectApiKey(provider) {
+	const vars = {
+		openai: ["OPENAI_API_KEY"],
+		anthropic: ["ANTHROPIC_API_KEY"],
+		google: ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"],
+		groq: ["GROQ_API_KEY"]
+	}[provider] || [];
+	for (const varName of vars) {
+		const value = process.env[varName];
+		if (value) return value;
+	}
+}
+function maskApiKey(key) {
+	if (key.length <= 8) return "••••••••";
+	return key.slice(0, 4) + "••••" + key.slice(-4);
+}
+async function runQuickSetup() {
+	console.clear();
+	clack.intro("Operor - Quick Setup");
+	const llmProvider = await clack.select({
+		message: "Choose your LLM provider",
+		options: [
+			{
+				value: "openai",
+				label: "OpenAI"
+			},
+			{
+				value: "anthropic",
+				label: "Anthropic (Claude)"
+			},
+			{
+				value: "google",
+				label: "Google (Gemini)"
+			},
+			{
+				value: "groq",
+				label: "Groq"
+			},
+			{
+				value: "ollama",
+				label: "Ollama (local)"
+			}
+		]
+	});
+	if (clack.isCancel(llmProvider)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	let llmApiKey = "";
+	if (llmProvider !== "ollama") {
+		const detectedKey = detectApiKey(llmProvider);
+		if (detectedKey) {
+			const useExisting = await clack.confirm({
+				message: `Found existing API key (${maskApiKey(detectedKey)}). Use it?`,
+				initialValue: true
+			});
+			if (clack.isCancel(useExisting)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			llmApiKey = useExisting ? detectedKey : await clack.password({
+				message: "Enter your API key",
+				validate: (value) => !value ? "API key is required" : void 0
+			});
+		} else llmApiKey = await clack.password({
+			message: "Enter your API key",
+			validate: (value) => !value ? "API key is required" : void 0
+		});
+		if (clack.isCancel(llmApiKey)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+	}
+	const spinner = clack.spinner();
+	spinner.start("Validating LLM credentials");
+	try {
+		await new AIProvider({
+			provider: llmProvider,
+			apiKey: llmApiKey
+		}).complete([{
+			role: "user",
+			content: "test"
+		}]);
+		spinner.stop("LLM credentials validated");
+	} catch (error) {
+		spinner.stop("LLM validation failed");
+		clack.log.error(`Failed to validate LLM credentials: ${error.message}`);
+		process.exit(1);
+	}
+	const config = {
+		LLM_PROVIDER: llmProvider,
+		LLM_API_KEY: llmApiKey,
+		CHANNEL: "mock",
+		MEMORY_TYPE: "sqlite",
+		INTENT_CLASSIFIER: "llm",
+		KB_ENABLED: "true",
+		KB_EMBEDDING_PROVIDER: llmProvider,
+		KB_EMBEDDING_API_KEY: llmApiKey,
+		TRAINING_MODE_ENABLED: "false",
+		ANALYTICS_ENABLED: "true"
+	};
+	writeConfig({
+		...readConfig(),
+		...config
+	});
+	clack.log.success("Configuration saved to .env");
+	clack.log.info(`  LLM Provider:    ${llmProvider}`);
+	clack.log.info(`  Channel:         mock (testing)`);
+	clack.log.info(`  Memory:          sqlite`);
+	clack.log.info(`  Intent:          llm`);
+	clack.log.info(`  Knowledge Base:  enabled`);
+	clack.log.info(`  Analytics:       enabled`);
+	clack.log.info(`  Training Mode:   disabled`);
+	clack.outro("Quick setup complete. Starting Operor...");
+}
+async function runSetup() {
+	console.clear();
+	clack.intro("Operor - Setup");
+	const existingConfig = readConfig();
+	const llmProvider = await clack.select({
+		message: "Choose your LLM provider",
+		options: [
+			{
+				value: "openai",
+				label: "OpenAI"
+			},
+			{
+				value: "anthropic",
+				label: "Anthropic (Claude)"
+			},
+			{
+				value: "google",
+				label: "Google (Gemini)"
+			},
+			{
+				value: "groq",
+				label: "Groq"
+			},
+			{
+				value: "ollama",
+				label: "Ollama (local)"
+			}
+		],
+		initialValue: existingConfig.LLM_PROVIDER || void 0
+	});
+	if (clack.isCancel(llmProvider)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const detectedKey = detectApiKey(llmProvider);
+	const existingApiKey = existingConfig.LLM_API_KEY || detectedKey;
+	let llmApiKey;
+	if (existingApiKey && llmProvider !== "ollama") {
+		const useExisting = await clack.confirm({
+			message: `Found existing API key (${maskApiKey(existingApiKey)}). Use it?`,
+			initialValue: true
+		});
+		if (clack.isCancel(useExisting)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		if (useExisting) llmApiKey = existingApiKey;
+		else llmApiKey = await clack.password({
+			message: "Enter your API key",
+			validate: (value) => !value ? "API key is required" : void 0
+		});
+	} else llmApiKey = await clack.password({
+		message: "Enter your API key",
+		validate: (value) => {
+			if (llmProvider === "ollama") return;
+			if (!value) return "API key is required";
+		}
+	});
+	if (clack.isCancel(llmApiKey)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const llmModel = await clack.text({
+		message: "Enter model name (optional, press Enter for default)",
+		placeholder: getDefaultModel(llmProvider),
+		initialValue: existingConfig.LLM_MODEL || void 0
+	});
+	if (clack.isCancel(llmModel)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const spinner = clack.spinner();
+	spinner.start("Validating LLM credentials");
+	try {
+		await new AIProvider({
+			provider: llmProvider,
+			apiKey: llmApiKey,
+			model: llmModel || void 0
+		}).complete([{
+			role: "user",
+			content: "test"
+		}]);
+		spinner.stop("LLM credentials validated");
+	} catch (error) {
+		spinner.stop("LLM validation failed");
+		clack.log.error(`Failed to validate LLM credentials: ${error.message}`);
+		process.exit(1);
+	}
+	const channel = await clack.select({
+		message: "Choose your messaging channel",
+		options: [
+			{
+				value: "whatsapp",
+				label: "WhatsApp (Baileys)"
+			},
+			{
+				value: "wati",
+				label: "WhatsApp via WATI (Business API)"
+			},
+			{
+				value: "telegram",
+				label: "Telegram (grammY)"
+			},
+			{
+				value: "mock",
+				label: "Mock (for testing)"
+			}
+		],
+		initialValue: existingConfig.CHANNEL || void 0
+	});
+	if (clack.isCancel(channel)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const channelConfig = {};
+	if (channel === "telegram") {
+		const botToken = await clack.password({
+			message: "Telegram Bot Token (from @BotFather)",
+			validate: (value) => !value ? "Bot token is required" : void 0
+		});
+		if (clack.isCancel(botToken)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		channelConfig.TELEGRAM_BOT_TOKEN = botToken;
+	}
+	if (channel === "wati") {
+		const apiToken = await clack.password({
+			message: "WATI API Token (from your WATI dashboard)",
+			validate: (value) => !value ? "API token is required" : void 0
+		});
+		if (clack.isCancel(apiToken)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		const tenantId = await clack.text({
+			message: "WATI Tenant ID",
+			validate: (value) => !value ? "Tenant ID is required" : void 0,
+			initialValue: existingConfig.WATI_TENANT_ID || void 0
+		});
+		if (clack.isCancel(tenantId)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		channelConfig.WATI_API_TOKEN = apiToken;
+		channelConfig.WATI_TENANT_ID = tenantId;
+	}
+	const enableSkills = await clack.confirm({
+		message: "Configure MCP skills? (Shopify, Stripe, search, etc. via mcp.json)",
+		initialValue: existingConfig.SKILLS_ENABLED === "true"
+	});
+	if (clack.isCancel(enableSkills)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	let selectedSkills = [];
+	if (enableSkills) {
+		const skillOptions = loadSkillCatalog().skills.map((s) => ({
+			value: s.name,
+			label: `${s.displayName} — ${s.description}`
+		}));
+		const skills = await clack.multiselect({
+			message: "Select MCP skills to enable (space to toggle)",
+			options: skillOptions,
+			required: false
+		});
+		if (clack.isCancel(skills)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		selectedSkills = skills;
+	}
+	const memoryType = await clack.select({
+		message: "Choose storage backend",
+		options: [{
+			value: "sqlite",
+			label: "SQLite (recommended, zero config)"
+		}, {
+			value: "memory",
+			label: "In-memory (data lost on restart)"
+		}],
+		initialValue: existingConfig.MEMORY_TYPE || void 0
+	});
+	if (clack.isCancel(memoryType)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const intentClassifier = await clack.select({
+		message: "Choose intent classification method",
+		options: [{
+			value: "llm",
+			label: "LLM-based (uses your LLM provider)"
+		}, {
+			value: "keyword",
+			label: "Keyword matching (no LLM cost)"
+		}],
+		initialValue: existingConfig.INTENT_CLASSIFIER || void 0
+	});
+	if (clack.isCancel(intentClassifier)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	const kbEnabled = await clack.confirm({
+		message: "Enable Knowledge Base (RAG)?",
+		initialValue: existingConfig.KB_ENABLED === "true"
+	});
+	if (clack.isCancel(kbEnabled)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	let kbEmbeddingProvider;
+	let kbEmbeddingApiKey;
+	let kbEmbeddingModel;
+	let kbDbPath;
+	if (kbEnabled) {
+		const embProvider = await clack.select({
+			message: "Embedding provider",
+			options: [
+				{
+					value: "openai",
+					label: "OpenAI (text-embedding-3-small, 1536d)"
+				},
+				{
+					value: "google",
+					label: "Google (text-embedding-004, 768d)"
+				},
+				{
+					value: "mistral",
+					label: "Mistral (mistral-embed, 1024d)"
+				},
+				{
+					value: "cohere",
+					label: "Cohere (embed-english-v3.0, 1024d)"
+				},
+				{
+					value: "ollama",
+					label: "Ollama (local, nomic-embed-text, 768d)"
+				}
+			],
+			initialValue: existingConfig.KB_EMBEDDING_PROVIDER || void 0
+		});
+		if (clack.isCancel(embProvider)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		kbEmbeddingProvider = embProvider;
+		if (kbEmbeddingProvider !== "ollama") {
+			const embKey = await clack.password({ message: "Embedding API key (or Enter to reuse LLM key)" });
+			if (clack.isCancel(embKey)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			kbEmbeddingApiKey = embKey || llmApiKey;
+		}
+		const embModel = await clack.text({
+			message: "Embedding model (optional, press Enter for default)",
+			placeholder: getDefaultEmbeddingModel(kbEmbeddingProvider),
+			initialValue: existingConfig.KB_EMBEDDING_MODEL || void 0
+		});
+		if (clack.isCancel(embModel)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		kbEmbeddingModel = embModel || void 0;
+		const dbPath = await clack.text({
+			message: "Knowledge base DB path",
+			placeholder: "./knowledge.db",
+			initialValue: existingConfig.KB_DB_PATH || void 0
+		});
+		if (clack.isCancel(dbPath)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		kbDbPath = dbPath || "./knowledge.db";
+	}
+	const trainingEnabled = await clack.confirm({
+		message: "Enable training mode? (allows /teach command to add FAQ answers)",
+		initialValue: existingConfig.TRAINING_MODE_ENABLED === "true"
+	});
+	if (clack.isCancel(trainingEnabled)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	let trainingWhitelist = "";
+	if (trainingEnabled) {
+		const whitelistInput = await clack.text({
+			message: "Whitelist phone numbers for training (comma-separated, e.g. 85253332683,85291234567)",
+			placeholder: "85253332683,85291234567",
+			initialValue: existingConfig.TRAINING_MODE_WHITELIST || void 0
+		});
+		if (clack.isCancel(whitelistInput)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		trainingWhitelist = whitelistInput || "";
+	}
+	let copilotConfig = {};
+	if (kbEnabled) {
+		const copilotEnabled = await clack.confirm({
+			message: "Enable Training Copilot? (auto-tracks unanswered queries, suggests FAQ additions)",
+			initialValue: existingConfig.COPILOT_ENABLED !== "false"
+		});
+		if (clack.isCancel(copilotEnabled)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		if (copilotEnabled) {
+			copilotConfig.COPILOT_ENABLED = "true";
+			const copilotDbPath = await clack.text({
+				message: "Copilot database path",
+				placeholder: "./copilot.db",
+				initialValue: existingConfig.COPILOT_DB_PATH || void 0
+			});
+			if (clack.isCancel(copilotDbPath)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			copilotConfig.COPILOT_DB_PATH = copilotDbPath || "./copilot.db";
+			const trackingThreshold = await clack.text({
+				message: "Tracking threshold (KB score below which queries are tracked)",
+				placeholder: "0.70",
+				initialValue: existingConfig.COPILOT_TRACKING_THRESHOLD || void 0
+			});
+			if (clack.isCancel(trackingThreshold)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			if (trackingThreshold) copilotConfig.COPILOT_TRACKING_THRESHOLD = trackingThreshold;
+			const autoSuggest = await clack.confirm({
+				message: "Auto-generate LLM answer suggestions for unanswered queries?",
+				initialValue: existingConfig.COPILOT_AUTO_SUGGEST !== "false"
+			});
+			if (clack.isCancel(autoSuggest)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			copilotConfig.COPILOT_AUTO_SUGGEST = autoSuggest ? "true" : "false";
+		} else copilotConfig.COPILOT_ENABLED = "false";
+	}
+	let analyticsConfig = {};
+	const analyticsEnabled = await clack.confirm({
+		message: "Enable Analytics & Reporting? (tracks response times, token usage, conversation metrics)",
+		initialValue: existingConfig.ANALYTICS_ENABLED !== "false"
+	});
+	if (clack.isCancel(analyticsEnabled)) {
+		clack.cancel("Setup cancelled");
+		process.exit(0);
+	}
+	if (analyticsEnabled) {
+		analyticsConfig.ANALYTICS_ENABLED = "true";
+		const analyticsDbPath = await clack.text({
+			message: "Analytics database path",
+			placeholder: "./analytics.db",
+			initialValue: existingConfig.ANALYTICS_DB_PATH || void 0
+		});
+		if (clack.isCancel(analyticsDbPath)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		analyticsConfig.ANALYTICS_DB_PATH = analyticsDbPath || "./analytics.db";
+		const digestEnabled = await clack.select({
+			message: "Enable daily digest reports via WhatsApp?",
+			options: [
+				{
+					value: "daily",
+					label: "Yes, daily digest"
+				},
+				{
+					value: "weekly",
+					label: "Weekly only"
+				},
+				{
+					value: "both",
+					label: "Both daily and weekly"
+				},
+				{
+					value: "false",
+					label: "No digest reports"
+				}
+			],
+			initialValue: existingConfig.ANALYTICS_DIGEST_ENABLED === "true" ? existingConfig.ANALYTICS_DIGEST_SCHEDULE || "daily" : "false"
+		});
+		if (clack.isCancel(digestEnabled)) {
+			clack.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		if (digestEnabled !== "false") {
+			analyticsConfig.ANALYTICS_DIGEST_ENABLED = "true";
+			analyticsConfig.ANALYTICS_DIGEST_SCHEDULE = digestEnabled;
+			const digestTime = await clack.text({
+				message: "Digest delivery time (HH:MM, 24h format)",
+				placeholder: "09:00",
+				initialValue: existingConfig.ANALYTICS_DIGEST_TIME || void 0,
+				validate: (value) => {
+					if (!value) return void 0;
+					if (!/^\d{2}:\d{2}$/.test(value)) return "Use HH:MM format (e.g. 09:00)";
+				}
+			});
+			if (clack.isCancel(digestTime)) {
+				clack.cancel("Setup cancelled");
+				process.exit(0);
+			}
+			analyticsConfig.ANALYTICS_DIGEST_TIME = digestTime || "09:00";
+		} else analyticsConfig.ANALYTICS_DIGEST_ENABLED = "false";
+	} else analyticsConfig.ANALYTICS_ENABLED = "false";
+	const newConfig = {
+		LLM_PROVIDER: llmProvider,
+		LLM_API_KEY: llmApiKey,
+		LLM_MODEL: llmModel || void 0,
+		CHANNEL: channel,
+		SKILLS_ENABLED: enableSkills ? "true" : "false",
+		MEMORY_TYPE: memoryType,
+		INTENT_CLASSIFIER: intentClassifier,
+		...channelConfig,
+		...kbEnabled && {
+			KB_ENABLED: "true",
+			KB_DB_PATH: kbDbPath,
+			KB_EMBEDDING_PROVIDER: kbEmbeddingProvider,
+			KB_EMBEDDING_MODEL: kbEmbeddingModel,
+			KB_EMBEDDING_API_KEY: kbEmbeddingApiKey
+		},
+		TRAINING_MODE_ENABLED: trainingEnabled ? "true" : "false",
+		...trainingWhitelist && { TRAINING_MODE_WHITELIST: trainingWhitelist },
+		...copilotConfig,
+		...analyticsConfig
+	};
+	if (enableSkills && selectedSkills.length > 0) {
+		const catalog = loadSkillCatalog();
+		const mcpSkills = [];
+		const mcpPath = resolve(process.cwd(), "mcp.json");
+		let previousSkillNames = [];
+		try {
+			previousSkillNames = (JSON.parse(readFileSync(mcpPath, "utf-8")).skills || []).map((s) => s.name);
+		} catch {}
+		for (const skillName of selectedSkills) {
+			const entry = findSkillInCatalog(catalog, skillName);
+			if (!entry) continue;
+			for (const [varName, spec] of Object.entries(entry.envVars)) {
+				if (!spec.required) continue;
+				const value = await clack.password({
+					message: `${entry.displayName}: ${spec.description}`,
+					validate: (v) => !v ? `${varName} is required` : void 0
+				});
+				if (clack.isCancel(value)) {
+					clack.cancel("Setup cancelled");
+					process.exit(0);
+				}
+				newConfig[varName] = value;
+			}
+			mcpSkills.push(catalogEntryToConfig(entry));
+		}
+		const mcpConfig = { skills: mcpSkills };
+		writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+		clack.log.info("  MCP config saved to mcp.json");
+		const addedSkills = selectedSkills.filter((s) => !previousSkillNames.includes(s));
+		const removedSkills = previousSkillNames.filter((s) => !selectedSkills.includes(s));
+		const updatedAgents = syncSkillsToAgents(resolve(process.cwd(), "agents"), addedSkills, removedSkills);
+		if (updatedAgents.length > 0) clack.log.info(`  Updated skills in: ${updatedAgents.join(", ")}`);
+	}
+	writeConfig({
+		...existingConfig,
+		...newConfig
+	});
+	clack.outro("Config saved to .env. Starting Operor...");
+}
+/**
+* Sync skill names into agent INSTRUCTIONS.md frontmatter.
+* Only touches agents that already have a `skills:` field.
+* If the resulting skills array is empty, removes the `skills` key entirely.
+*/
+function syncSkillsToAgents(agentsDir, addedSkills, removedSkills) {
+	if (addedSkills.length === 0 && removedSkills.length === 0) return [];
+	const updated = [];
+	let entries;
+	try {
+		entries = readdirSync(agentsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("_")).map((d) => d.name);
+	} catch {
+		return [];
+	}
+	for (const agentName of entries) {
+		const instrPath = join(agentsDir, agentName, "INSTRUCTIONS.md");
+		if (!existsSync(instrPath)) continue;
+		const parsed = matter(readFileSync(instrPath, "utf-8"));
+		if (!Array.isArray(parsed.data.skills)) continue;
+		const currentSkills = parsed.data.skills;
+		let newSkills = currentSkills.filter((s) => !removedSkills.includes(s));
+		for (const skill of addedSkills) if (!newSkills.includes(skill)) newSkills.push(skill);
+		if (newSkills.length === currentSkills.length && newSkills.every((s, i) => s === currentSkills[i])) continue;
+		if (newSkills.length === 0) delete parsed.data.skills;
+		else parsed.data.skills = newSkills;
+		writeFileSync(instrPath, matter.stringify(parsed.content, parsed.data));
+		updated.push(agentName);
+	}
+	return updated;
+}
+function getDefaultModel(provider) {
+	return {
+		openai: "gpt-5-mini",
+		anthropic: "claude-3-5-sonnet-20241022",
+		google: "gemini-2.0-flash-exp",
+		groq: "llama-3.3-70b-versatile",
+		ollama: "llama3.2"
+	}[provider] || "";
+}
+function getDefaultEmbeddingModel(provider) {
+	return {
+		openai: "text-embedding-3-small",
+		google: "text-embedding-004",
+		mistral: "mistral-embed",
+		cohere: "embed-english-v3.0",
+		ollama: "nomic-embed-text"
+	}[provider] || "";
+}
+
+//#endregion
+//#region src/start.ts
+async function startOperor() {
+	const config = readConfig();
+	if (!config.LLM_PROVIDER || !config.CHANNEL) {
+		console.error("Missing configuration. Run \"operor setup\" first.");
+		process.exit(1);
+	}
+	console.log("[Operor] Starting...");
+	const { Operor, LLMIntentClassifier, AgentLoader } = await import("@operor/core");
+	const { AIProvider } = await import("@operor/llm");
+	let memory;
+	if (config.MEMORY_TYPE === "sqlite") {
+		const { SQLiteMemory } = await import("@operor/memory");
+		memory = new SQLiteMemory(config.MEMORY_DB_PATH || "./operor.db");
+		console.log("[Operor] Using SQLite memory store");
+	}
+	let llmProvider = config.LLM_PROVIDER;
+	let llmModel = config.LLM_MODEL;
+	let llmApiKey = config.LLM_API_KEY;
+	if (memory?.getSetting) try {
+		const storedProvider = await memory.getSetting("llm_provider");
+		const storedModel = await memory.getSetting("llm_model");
+		if (storedProvider) llmProvider = storedProvider;
+		if (storedModel) llmModel = storedModel;
+		const storedKey = await memory.getSetting(`llm_apikey_${llmProvider}`);
+		if (storedKey) llmApiKey = storedKey;
+	} catch {}
+	const llm = new AIProvider({
+		provider: llmProvider,
+		apiKey: llmApiKey,
+		model: llmModel
+	});
+	if (memory?.getSetting) for (const p of [
+		"openai",
+		"anthropic",
+		"google",
+		"groq",
+		"ollama"
+	]) {
+		if (p === llmProvider) continue;
+		try {
+			const k = await memory.getSetting(`llm_apikey_${p}`);
+			if (k) llm.setApiKey(p, k);
+		} catch {}
+	}
+	let intentClassifier;
+	if (config.INTENT_CLASSIFIER === "llm") {
+		intentClassifier = new LLMIntentClassifier(llm);
+		console.log("[Operor] Using LLM intent classification");
+	}
+	let kbRuntime;
+	let embedder;
+	if (config.KB_ENABLED === "true") try {
+		const { SQLiteKnowledgeStore, EmbeddingService, TextChunker, IngestionPipeline, RetrievalPipeline, QueryRewriter, UrlIngestor, SiteCrawler, FileIngestor } = await import("@operor/knowledge");
+		embedder = new EmbeddingService({
+			provider: config.KB_EMBEDDING_PROVIDER || "openai",
+			apiKey: config.KB_EMBEDDING_API_KEY || config.LLM_API_KEY,
+			model: config.KB_EMBEDDING_MODEL
+		});
+		const kbStore = new SQLiteKnowledgeStore(config.KB_DB_PATH || "./knowledge.db", embedder.dimensions);
+		await kbStore.initialize();
+		const chunker = new TextChunker({
+			chunkSize: config.KB_CHUNK_SIZE ? parseInt(config.KB_CHUNK_SIZE) : void 0,
+			chunkOverlap: config.KB_CHUNK_OVERLAP ? parseInt(config.KB_CHUNK_OVERLAP) : void 0
+		});
+		const ingestion = new IngestionPipeline(kbStore, embedder, chunker);
+		let queryRewriter;
+		try {
+			queryRewriter = new QueryRewriter({ model: llm.getModel() });
+		} catch {}
+		const retrieval = new RetrievalPipeline(kbStore, embedder, {
+			faqThreshold: .85,
+			queryRewriter,
+			fusionStrategy: config.FUSION_STRATEGY || "rrf"
+		});
+		const crawl4aiUrl = config.CRAWL4AI_URL || void 0;
+		const urlIngestor = new UrlIngestor(ingestion, { crawl4aiUrl });
+		const siteCrawler = new SiteCrawler(ingestion, { crawl4aiUrl });
+		const fileIngestor = new FileIngestor(ingestion);
+		kbRuntime = {
+			ingestFaq: async (question, answer, metadata) => {
+				const result = await ingestion.ingestFaq(question, answer, metadata);
+				return {
+					id: result.id,
+					existingMatch: result.existingMatch
+				};
+			},
+			listDocuments: async () => {
+				return await kbStore.listDocuments();
+			},
+			deleteDocument: async (id) => {
+				return await kbStore.deleteDocument(id);
+			},
+			retrieve: async (query) => {
+				return await retrieval.retrieve(query);
+			},
+			getStats: async () => {
+				return await kbStore.getStats();
+			},
+			ingestUrl: async (url) => {
+				const doc = await urlIngestor.ingestUrl(url);
+				const faqCount = doc.metadata?.faqCount;
+				const chunks = faqCount ?? (kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0);
+				return {
+					id: doc.id,
+					title: doc.title,
+					chunks,
+					faqCount
+				};
+			},
+			ingestSite: async (url, options) => {
+				const docs = await siteCrawler.crawlSite(url, {
+					...options,
+					onProgress: options?.onProgress
+				});
+				const totalChunks = docs.reduce((sum, doc) => {
+					return sum + (kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0);
+				}, 0);
+				return {
+					documents: docs.length,
+					chunks: totalChunks
+				};
+			},
+			ingestFile: async (buffer, fileName) => {
+				const { writeFile, unlink } = await import("fs/promises");
+				const { join } = await import("path");
+				const { tmpdir } = await import("os");
+				const tempPath = join(tmpdir(), `operor-${Date.now()}-${fileName}`);
+				await writeFile(tempPath, buffer);
+				try {
+					const doc = await fileIngestor.ingestFile(tempPath, fileName);
+					const chunkCount = kbStore.getChunkCount ? kbStore.getChunkCount(doc.id) : 0;
+					return {
+						id: doc.id,
+						title: doc.title,
+						chunks: chunkCount
+					};
+				} finally {
+					await unlink(tempPath).catch(() => {});
+				}
+			},
+			rebuild: async () => {
+				return await ingestion.rebuild();
+			}
+		};
+		console.log("[Operor] Knowledge Base enabled");
+	} catch (error) {
+		console.error(`[Operor] Failed to initialize Knowledge Base: ${error.message}`);
+	}
+	let copilotHandler;
+	let copilotTracker;
+	if (config.COPILOT_ENABLED !== "false" && kbRuntime) try {
+		const { SQLiteCopilotStore, UnansweredQueryTracker, QueryClusterer, SuggestionEngine, CopilotCommandHandler, DigestScheduler, DEFAULT_COPILOT_CONFIG } = await import("@operor/copilot");
+		const copilotConfig = {
+			...DEFAULT_COPILOT_CONFIG,
+			enabled: true,
+			trackingThreshold: config.COPILOT_TRACKING_THRESHOLD ? parseFloat(config.COPILOT_TRACKING_THRESHOLD) : DEFAULT_COPILOT_CONFIG.trackingThreshold,
+			clusterThreshold: config.COPILOT_CLUSTER_THRESHOLD ? parseFloat(config.COPILOT_CLUSTER_THRESHOLD) : DEFAULT_COPILOT_CONFIG.clusterThreshold,
+			digestIntervalMs: config.COPILOT_DIGEST_INTERVAL ? parseInt(config.COPILOT_DIGEST_INTERVAL) : DEFAULT_COPILOT_CONFIG.digestIntervalMs,
+			digestMaxItems: config.COPILOT_DIGEST_MAX_ITEMS ? parseInt(config.COPILOT_DIGEST_MAX_ITEMS) : DEFAULT_COPILOT_CONFIG.digestMaxItems,
+			autoSuggest: config.COPILOT_AUTO_SUGGEST !== "false"
+		};
+		const copilotStore = new SQLiteCopilotStore(config.COPILOT_DB_PATH || "./copilot.db", embedder.dimensions);
+		await copilotStore.initialize();
+		const clusterer = new QueryClusterer(copilotStore, embedder, { clusterThreshold: copilotConfig.clusterThreshold });
+		copilotTracker = new UnansweredQueryTracker(copilotStore, copilotConfig, embedder, clusterer);
+		copilotHandler = new CopilotCommandHandler(copilotStore, copilotConfig.autoSuggest ? new SuggestionEngine({ generateText: (opts) => llm.complete([...opts.system ? [{
+			role: "system",
+			content: opts.system
+		}] : [], {
+			role: "user",
+			content: opts.prompt
+		}]) }, kbRuntime) : void 0, kbRuntime, clusterer);
+		const adminPhones = config.TRAINING_MODE_WHITELIST?.split(",").map((p) => p.trim()).filter(Boolean) || [];
+		if (adminPhones.length > 0) new DigestScheduler(copilotStore, copilotConfig, async (phone, text) => {
+			try {
+				if (provider && typeof provider.sendMessage === "function") await provider.sendMessage(phone, text);
+			} catch (err) {
+				console.warn("[Copilot] Failed to send digest:", err?.message);
+			}
+		}).start(adminPhones);
+		console.log("[Operor] Training Copilot enabled");
+	} catch (error) {
+		console.error(`[Operor] Failed to initialize Training Copilot: ${error.message}`);
+		console.error("[Operor]    /review commands will not be available. Try running \"pnpm install\" if packages are missing.");
+	}
+	let analyticsCollector;
+	let analyticsStore;
+	if (config.ANALYTICS_ENABLED !== "false") try {
+		const { SQLiteAnalyticsStore, AnalyticsCollector } = await import("@operor/analytics");
+		analyticsStore = new SQLiteAnalyticsStore(config.ANALYTICS_DB_PATH || "./analytics.db");
+		await analyticsStore.initialize();
+		analyticsCollector = new AnalyticsCollector(analyticsStore, { debug: true });
+		console.log("[Operor] Analytics enabled");
+	} catch (error) {
+		console.error(`[Operor] Failed to initialize Analytics: ${error.message}`);
+	}
+	let trainingWhitelist = config.TRAINING_MODE_WHITELIST?.split(",").map((p) => p.trim()).filter(Boolean) || [];
+	if (config.TRAINING_MODE_ENABLED === "true" && memory?.getSetting) try {
+		const stored = await memory.getSetting("training_whitelist");
+		if (stored) trainingWhitelist = stored.split(",").map((p) => p.trim()).filter(Boolean);
+		else if (trainingWhitelist.length > 0) await memory.setSetting("training_whitelist", trainingWhitelist.join(","));
+	} catch {}
+	let skillsModule;
+	try {
+		skillsModule = await import("@operor/skills");
+	} catch {}
+	const agentsDir = `${process.cwd()}/agents`;
+	const hasAgentsDir = fs.existsSync(agentsDir);
+	const os = new Operor({
+		debug: true,
+		llmProvider: llm,
+		...memory && { memory },
+		...intentClassifier && { intentClassifier },
+		...kbRuntime && { kb: kbRuntime },
+		...copilotHandler && { copilotHandler },
+		...copilotTracker && { copilotTracker },
+		...analyticsCollector && { analyticsCollector },
+		...analyticsStore && { analyticsStore },
+		...skillsModule && { skillsModule },
+		...hasAgentsDir && { agentsDir },
+		...config.TRAINING_MODE_ENABLED === "true" && { trainingMode: {
+			enabled: true,
+			whitelist: trainingWhitelist
+		} }
+	});
+	let provider;
+	if (config.CHANNEL === "whatsapp") {
+		const { BaileysProvider } = await import("@operor/provider-baileys");
+		provider = new BaileysProvider({ groupMode: config.WHATSAPP_GROUP_MODE || "mention-only" });
+	} else if (config.CHANNEL === "telegram") {
+		const { TelegramProvider } = await import("@operor/provider-telegram");
+		provider = new TelegramProvider({ botToken: config.TELEGRAM_BOT_TOKEN });
+	} else if (config.CHANNEL === "wati") {
+		const { WatiProvider } = await import("@operor/provider-wati");
+		provider = new WatiProvider({
+			apiToken: config.WATI_API_TOKEN,
+			tenantId: config.WATI_TENANT_ID,
+			webhookPort: config.WATI_WEBHOOK_PORT ? parseInt(config.WATI_WEBHOOK_PORT) : void 0
+		});
+	} else {
+		const { MockProvider } = await import("@operor/provider-mock");
+		provider = new MockProvider();
+	}
+	os.addProvider(provider);
+	let skillManager;
+	const skillInstances = [];
+	let loadSkillsConfig;
+	try {
+		const skillsMod = await import("@operor/skills");
+		loadSkillsConfig = skillsMod.loadSkillsConfig;
+		const { SkillManager } = skillsMod;
+		const skillsConfig = loadSkillsConfig();
+		skillManager = new SkillManager();
+		const mcpSkills = await skillManager.initialize(skillsConfig);
+		for (const skill of mcpSkills) {
+			os.addSkill(skill);
+			skillInstances.push(skill);
+		}
+		if (mcpSkills.length > 0) console.log(`[Operor] ${mcpSkills.length} MCP skill(s) loaded`);
+	} catch (error) {
+		if (config.SKILLS_ENABLED === "true") console.warn(`[Operor] Failed to load MCP skills: ${error.message}`);
+	}
+	const allTools = skillInstances.flatMap((skill) => Object.values(skill.tools));
+	const getPromptSkills = (agentSkillNames) => {
+		return skillInstances.filter((s) => typeof s.getContent === "function").filter((s) => !agentSkillNames || agentSkillNames.includes(s.name)).map((s) => ({
+			name: s.name,
+			content: s.getContent()
+		}));
+	};
+	const agentToolsMap = /* @__PURE__ */ new Map();
+	let definitions = [];
+	if (hasAgentsDir) {
+		definitions = await new AgentLoader(process.cwd()).loadAll();
+		if (definitions.length === 0) {
+			console.error("[Operor] agents/ directory found but no valid agent definitions. Check INSTRUCTIONS.md files.");
+			process.exit(1);
+		}
+		for (const def of definitions) {
+			const agentTools = def.config.skills ? skillInstances.filter((skill) => def.config.skills.includes(skill.name)).flatMap((skill) => Object.values(skill.tools)) : allTools;
+			agentToolsMap.set(def.config.name, agentTools);
+			applyLLMOverride(os.createAgent({
+				...def.config,
+				tools: agentTools
+			}), llm, agentTools, {
+				systemPrompt: def.systemPrompt,
+				kbRuntime,
+				useKB: def.config.knowledgeBase,
+				guardrails: def.config.guardrails,
+				promptSkills: getPromptSkills(def.config.skills)
+			});
+			console.log(`[Operor] Loaded agent: ${def.config.name}` + (def.config.channels ? ` (channels: ${def.config.channels.join(", ")})` : "") + (def.config.skills ? ` (skills: ${def.config.skills.join(", ")})` : "") + (def.config.knowledgeBase ? " (KB)" : "") + (def.config.priority ? ` (priority: ${def.config.priority})` : ""));
+		}
+		console.log(`[Operor] Loaded ${definitions.length} agent(s) from agents/ directory`);
+	} else {
+		const agent = os.createAgent({
+			name: "support",
+			purpose: "Customer support agent",
+			personality: "Friendly, helpful, and professional",
+			triggers: ["*"],
+			tools: allTools
+		});
+		agentToolsMap.set("support", allTools);
+		applyLLMOverride(agent, llm, allTools, {
+			kbRuntime,
+			promptSkills: getPromptSkills()
+		});
+		console.log("[Operor] Using default single-agent mode");
+	}
+	const reloadSkills = async () => {
+		if (!skillManager || !loadSkillsConfig) return;
+		console.log("[Operor] 🔄 Reloading MCP skills...");
+		try {
+			const newConfig = loadSkillsConfig();
+			for (const skill of skillInstances) await os.removeSkill(skill.name);
+			await skillManager.closeAll();
+			const newSkills = await skillManager.initialize(newConfig);
+			skillInstances.splice(0, skillInstances.length, ...newSkills);
+			for (const skill of newSkills) await os.addSkill(skill);
+			const freshTools = skillInstances.flatMap((skill) => Object.values(skill.tools));
+			allTools.splice(0, allTools.length, ...freshTools);
+			for (const def of definitions) {
+				const agentTools = agentToolsMap.get(def.config.name);
+				if (!agentTools) continue;
+				const newAgentTools = def.config.skills ? skillInstances.filter((skill) => def.config.skills.includes(skill.name)).flatMap((skill) => Object.values(skill.tools)) : freshTools;
+				agentTools.splice(0, agentTools.length, ...newAgentTools);
+			}
+			if (definitions.length === 0) {
+				const fallbackTools = agentToolsMap.get("support");
+				if (fallbackTools) fallbackTools.splice(0, fallbackTools.length, ...freshTools);
+			}
+			for (const def of definitions) {
+				const agentTools = agentToolsMap.get(def.config.name);
+				if (!agentTools) continue;
+				const agent = os.getAgents().find((a) => a.getConfig?.().name === def.config.name || a.config?.name === def.config.name);
+				if (agent) applyLLMOverride(agent, llm, agentTools, {
+					systemPrompt: def.systemPrompt,
+					kbRuntime,
+					useKB: def.config.knowledgeBase,
+					guardrails: def.config.guardrails,
+					promptSkills: getPromptSkills(def.config.skills)
+				});
+			}
+			console.log(`[Operor] \u2705 Reloaded ${newSkills.length} skill(s)`);
+		} catch (error) {
+			console.error(`[Operor] \u274C Failed to reload MCP skills: ${error.message}`);
+		}
+	};
+	await os.start();
+	console.log("[Operor] Running. Press Ctrl+C to stop.");
+	const mcpJsonPath = `${process.cwd()}/mcp.json`;
+	if (fs.existsSync(mcpJsonPath) && loadSkillsConfig) {
+		let reloadTimer = null;
+		fs.watch(mcpJsonPath, () => {
+			if (reloadTimer) clearTimeout(reloadTimer);
+			reloadTimer = setTimeout(() => {
+				reloadTimer = null;
+				reloadSkills().catch((err) => {
+					console.error(`[Operor] Skill reload error: ${err.message}`);
+				});
+			}, 500);
+		});
+		console.log("[Operor] Watching mcp.json for changes");
+	}
+	const shutdown = async () => {
+		console.log("\n[Operor] Shutting down...");
+		if (skillManager) await skillManager.closeAll();
+		await os.stop();
+		process.exit(0);
+	};
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+	if (config.CHANNEL === "mock") setTimeout(() => {
+		provider.simulateIncomingMessage("+1234567890", "Hi, I need help with my order #1001");
+	}, 2e3);
+}
+
+//#endregion
+//#region src/commands/kb.ts
+function getKBConfig() {
+	if (!configExists()) {
+		clack.log.error(".env file not found. Run \"operor setup\" first.");
+		process.exit(1);
+	}
+	const config = readConfig();
+	if (config.KB_ENABLED !== "true") {
+		clack.log.error("Knowledge Base is not enabled. Run \"operor setup\" or set KB_ENABLED=true.");
+		process.exit(1);
+	}
+	return config;
+}
+async function loadKB(config) {
+	try {
+		const { SQLiteKnowledgeStore, EmbeddingService, TextChunker, IngestionPipeline, RetrievalPipeline, UrlIngestor, FileIngestor, SiteCrawler } = await import("@operor/knowledge");
+		const embeddings = new EmbeddingService({
+			provider: config.KB_EMBEDDING_PROVIDER || "openai",
+			apiKey: config.KB_EMBEDDING_API_KEY,
+			model: config.KB_EMBEDDING_MODEL
+		});
+		const store = new SQLiteKnowledgeStore(config.KB_DB_PATH || "./knowledge.db", embeddings.dimensions);
+		await store.initialize();
+		const chunker = new TextChunker({
+			chunkSize: config.KB_CHUNK_SIZE ? parseInt(config.KB_CHUNK_SIZE) : void 0,
+			chunkOverlap: config.KB_CHUNK_OVERLAP ? parseInt(config.KB_CHUNK_OVERLAP) : void 0
+		});
+		let llmProvider;
+		if (config.LLM_PROVIDER && config.LLM_API_KEY) {
+			const { AIProvider } = await import("@operor/llm");
+			llmProvider = new AIProvider({
+				provider: config.LLM_PROVIDER,
+				apiKey: config.LLM_API_KEY,
+				model: config.LLM_MODEL
+			});
+		}
+		const ingestion = new IngestionPipeline(store, embeddings, chunker, llmProvider);
+		const retrieval = new RetrievalPipeline(store, embeddings);
+		const crawl4aiUrl = config.CRAWL4AI_URL || void 0;
+		return {
+			store,
+			embeddings,
+			ingestion,
+			retrieval,
+			urlIngestor: new UrlIngestor(ingestion, { crawl4aiUrl }),
+			fileIngestor: new FileIngestor(ingestion),
+			siteCrawler: new SiteCrawler(ingestion, { crawl4aiUrl })
+		};
+	} catch {
+		clack.log.error("@operor/knowledge package not found. Install it first:\n  pnpm add @operor/knowledge");
+		process.exit(1);
+	}
+}
+function registerKBCommand(program) {
+	const kb = program.command("kb").description("Knowledge Base management");
+	kb.command("add-url").description("Ingest a URL into the knowledge base").argument("<url>", "URL to ingest").option("--priority <n>", "Document priority (1=official, 2=supplementary, 3=archived)", "2").option("--extract-qa", "Use LLM to extract Q&A pairs instead of chunking").action(async (url, opts) => {
+		clack.intro("KB — Add URL");
+		const { store, urlIngestor } = await loadKB(getKBConfig());
+		const spinner = clack.spinner();
+		spinner.start(`Fetching and ingesting ${url}`);
+		try {
+			const doc = await urlIngestor.ingestUrl(url, {
+				priority: parseInt(opts.priority),
+				extractQA: opts.extractQa
+			});
+			spinner.stop(`Ingested: ${doc.title || url}`);
+			clack.log.success(`Document ID: ${doc.id}`);
+		} catch (error) {
+			spinner.stop(`Failed to ingest URL`);
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("add-site").description("Crawl and ingest an entire website").argument("<url>", "Website URL to crawl").option("--depth <n>", "Maximum crawl depth", "2").option("--max-pages <n>", "Maximum pages to crawl", "50").option("--no-sitemap", "Skip sitemap.xml and use link crawling only").option("--delay <ms>", "Delay between requests in milliseconds", "500").action(async (url, opts) => {
+		clack.intro("KB — Crawl Site");
+		const { store, siteCrawler } = await loadKB(getKBConfig());
+		const spinner = clack.spinner();
+		spinner.start("Starting crawl...");
+		try {
+			const docs = await siteCrawler.crawlSite(url, {
+				maxDepth: parseInt(opts.depth),
+				maxPages: parseInt(opts.maxPages),
+				useSitemap: opts.sitemap,
+				delayMs: parseInt(opts.delay),
+				onProgress: (crawled, discovered, currentUrl) => {
+					const shortUrl = currentUrl.length > 60 ? currentUrl.slice(0, 57) + "..." : currentUrl;
+					spinner.message(`Crawling... (${crawled}/${discovered} pages) ${shortUrl}`);
+				}
+			});
+			spinner.stop(`Crawled ${docs.length} page(s)`);
+			clack.log.success(`Ingested ${docs.length} document(s) from ${url}`);
+		} catch (error) {
+			spinner.stop("Crawl failed");
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("add-file").description("Ingest a document file into the knowledge base").argument("<path>", "File path to ingest").option("--priority <n>", "Document priority (1=official, 2=supplementary, 3=archived)", "2").action(async (filePath, opts) => {
+		clack.intro("KB — Add File");
+		const { store, fileIngestor } = await loadKB(getKBConfig());
+		const spinner = clack.spinner();
+		spinner.start(`Ingesting ${filePath}`);
+		try {
+			const doc = await fileIngestor.ingestFile(filePath, void 0, { priority: parseInt(opts.priority) });
+			spinner.stop(`Ingested: ${doc.title || filePath}`);
+			clack.log.success(`Document ID: ${doc.id}`);
+		} catch (error) {
+			spinner.stop(`Failed to ingest file`);
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("add-faq").description("Add a manual FAQ entry").argument("<question>", "FAQ question").argument("<answer>", "FAQ answer").action(async (question, answer) => {
+		clack.intro("KB — Add FAQ");
+		const { store, ingestion } = await loadKB(getKBConfig());
+		const spinner = clack.spinner();
+		spinner.start("Adding FAQ entry");
+		try {
+			let doc = await ingestion.ingestFaq(question, answer);
+			if (doc.existingMatch) {
+				const match = doc.existingMatch;
+				clack.log.info(`Replacing similar FAQ (${(match.score * 100).toFixed(0)}% match): "${match.question}"`);
+				doc = await ingestion.ingestFaq(question, answer, {
+					forceReplace: true,
+					replaceId: match.id
+				});
+			}
+			spinner.stop("FAQ entry added");
+			clack.log.success(`Document ID: ${doc.id}`);
+		} catch (error) {
+			spinner.stop("Failed to add FAQ");
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("list").description("List all KB documents").action(async () => {
+		clack.intro("KB — Documents");
+		const { store } = await loadKB(getKBConfig());
+		try {
+			const docs = await store.listDocuments();
+			if (docs.length === 0) clack.log.info("No documents in the knowledge base.");
+			else {
+				const header = `${"ID".padEnd(40)} ${"Type".padEnd(12)} Title / Source`;
+				clack.log.info(header);
+				clack.log.info("─".repeat(header.length));
+				for (const doc of docs) {
+					const line = `${doc.id.padEnd(40)} ${doc.sourceType.padEnd(12)} ${doc.title || doc.sourceUrl || doc.fileName || "—"}`;
+					clack.log.info(line);
+				}
+				clack.log.info(`\n${docs.length} document(s)`);
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("");
+	});
+	kb.command("search").description("Test search against the knowledge base").argument("<query>", "Search query").option("-n, --limit <n>", "Max results", "5").action(async (query, opts) => {
+		clack.intro("KB — Search");
+		const { store, retrieval } = await loadKB(getKBConfig());
+		const spinner = clack.spinner();
+		spinner.start(`Searching for "${query}"`);
+		try {
+			const result = await retrieval.retrieve(query, { limit: parseInt(opts.limit) });
+			spinner.stop(`Found ${result.results.length} result(s)`);
+			if (result.results.length === 0) clack.log.info("No results found.");
+			else for (const r of result.results) {
+				clack.log.info(`\n[Score: ${r.score.toFixed(4)}] Doc #${r.document.id}`);
+				const preview = r.chunk.content.length > 200 ? r.chunk.content.slice(0, 200) + "…" : r.chunk.content;
+				clack.log.message(preview);
+			}
+		} catch (error) {
+			spinner.stop("Search failed");
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("");
+	});
+	kb.command("ask").description("Ask a question using KB retrieval + LLM generation (RAG)").argument("<question>", "Question to answer").option("-n, --limit <n>", "Max KB chunks to retrieve", "5").option("--no-sources", "Hide source attribution").action(async (question, opts) => {
+		clack.intro("KB — Ask");
+		const config = getKBConfig();
+		const { store, retrieval } = await loadKB(config);
+		const spinner = clack.spinner();
+		spinner.start("Searching knowledge base...");
+		try {
+			const result = await retrieval.retrieve(question, { limit: parseInt(opts.limit) });
+			if (result.isFaqMatch && result.results.length > 0) {
+				spinner.stop("FAQ match found");
+				clack.log.success(result.results[0].chunk.content);
+				if (opts.sources) clack.log.info(`\nSource: FAQ (score: ${result.results[0].score.toFixed(4)})`);
+				return;
+			}
+			if (result.results.length === 0) {
+				spinner.stop("No relevant KB content found");
+				clack.log.warn("Cannot answer — no matching documents.");
+				return;
+			}
+			if (!config.LLM_PROVIDER || !config.LLM_API_KEY) {
+				spinner.stop("KB results found, but no LLM configured");
+				clack.log.error("LLM_PROVIDER and LLM_API_KEY required. Use \"operor kb search\" for retrieval-only.");
+				return;
+			}
+			spinner.message("Generating answer...");
+			const { AIProvider } = await import("@operor/llm");
+			const response = await new AIProvider({
+				provider: config.LLM_PROVIDER,
+				apiKey: config.LLM_API_KEY,
+				model: config.LLM_MODEL
+			}).complete([{
+				role: "system",
+				content: `Answer using ONLY the provided context. If insufficient, say so.\n\n${result.context}`
+			}, {
+				role: "user",
+				content: question
+			}]);
+			spinner.stop("Answer generated");
+			clack.log.success(response.text);
+			if (opts.sources) {
+				clack.log.info("\nSources:");
+				for (const r of result.results) {
+					const title = r.document?.title || r.document?.id || "unknown";
+					clack.log.info(`  - ${title} (score: ${r.score.toFixed(4)})`);
+				}
+			}
+		} catch (error) {
+			spinner.stop("Failed");
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("");
+	});
+	kb.command("delete").description("Delete a document from the knowledge base").argument("<id>", "Document ID to delete").action(async (id) => {
+		clack.intro("KB — Delete");
+		const { store } = await loadKB(getKBConfig());
+		try {
+			await store.deleteDocument(id);
+			clack.log.success(`Document #${id} deleted`);
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("rebuild").description("Rebuild all KB vector embeddings using the current embedding provider").action(async () => {
+		clack.intro("KB — Rebuild Embeddings");
+		const config = getKBConfig();
+		const { store, ingestion } = await loadKB(config);
+		const spinner = clack.spinner();
+		try {
+			const stats = await store.getStats();
+			if (stats.documentCount === 0) {
+				clack.log.warn("Knowledge Base is empty — nothing to rebuild.");
+				return;
+			}
+			clack.log.info(`Provider: ${config.KB_EMBEDDING_PROVIDER || "openai"}`);
+			clack.log.info(`Documents: ${stats.documentCount}, Chunks: ${stats.chunkCount}`);
+			spinner.start("Rebuilding embeddings...");
+			const result = await ingestion.rebuild((current, total, docTitle) => {
+				if (current < total) spinner.message(`Rebuilding... (${current + 1}/${total}) ${docTitle}`);
+			});
+			spinner.stop("Rebuild complete");
+			clack.log.success([
+				`Documents rebuilt: ${result.documentsRebuilt}`,
+				`Chunks rebuilt:    ${result.chunksRebuilt}`,
+				`Old dimensions:    ${result.oldDimensions}`,
+				`New dimensions:    ${result.newDimensions}`
+			].join("\n"));
+		} catch (error) {
+			spinner.stop("Rebuild failed");
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("Done");
+	});
+	kb.command("stats").description("Show knowledge base statistics").action(async () => {
+		clack.intro("KB — Statistics");
+		const config = getKBConfig();
+		const { store } = await loadKB(config);
+		try {
+			const stats = await store.getStats();
+			clack.log.info(`Documents:        ${stats.documentCount}`);
+			clack.log.info(`Chunks:           ${stats.chunkCount}`);
+			clack.log.info(`Embedding dims:   ${stats.embeddingDimensions || "—"}`);
+			clack.log.info(`DB size:          ${formatBytes(stats.dbSizeBytes)}`);
+			clack.log.info(`DB path:          ${config.KB_DB_PATH || "./knowledge.db"}`);
+			clack.log.info(`Embedding provider: ${config.KB_EMBEDDING_PROVIDER || "openai"}`);
+			clack.log.info(`Embedding model:  ${config.KB_EMBEDDING_MODEL || "default"}`);
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			store.close();
+		}
+		clack.outro("");
+	});
+}
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+//#endregion
+//#region src/commands/analytics.ts
+function getAnalyticsConfig() {
+	if (!configExists()) {
+		clack.log.error(".env file not found. Run \"operor setup\" first.");
+		process.exit(1);
+	}
+	const config = readConfig();
+	if (config.ANALYTICS_ENABLED === "false") {
+		clack.log.error("Analytics is disabled. Set ANALYTICS_ENABLED=true in .env.");
+		process.exit(1);
+	}
+	return config;
+}
+async function loadStore(config) {
+	try {
+		const { SQLiteAnalyticsStore } = await import("@operor/analytics");
+		const store = new SQLiteAnalyticsStore(config.ANALYTICS_DB_PATH || "./analytics.db");
+		await store.initialize();
+		return store;
+	} catch {
+		clack.log.error("@operor/analytics package not found. Install it first:\n  pnpm add @operor/analytics");
+		process.exit(1);
+	}
+}
+function makeRange(days) {
+	const to = Date.now();
+	return {
+		from: to - days * 24 * 60 * 60 * 1e3,
+		to
+	};
+}
+/** Simple sparkline from an array of numbers */
+function sparkline(values) {
+	if (values.length === 0) return "";
+	const chars = "▁▂▃▄▅▆▇█";
+	const max = Math.max(...values);
+	if (max === 0) return chars[0].repeat(values.length);
+	return values.map((v) => chars[Math.min(Math.floor(v / max * 7), 7)]).join("");
+}
+/** Simple horizontal bar */
+function bar(value, max, width = 30) {
+	if (max === 0) return "";
+	const filled = Math.round(value / max * width);
+	return "█".repeat(filled) + "░".repeat(width - filled);
+}
+function maskPhone(phone) {
+	if (phone.length <= 6) return "***" + phone.slice(-3);
+	return phone.slice(0, 3) + "***" + phone.slice(-3);
+}
+function fmtMs(ms) {
+	if (ms < 1e3) return `${Math.round(ms)}ms`;
+	return `${(ms / 1e3).toFixed(1)}s`;
+}
+function fmtPct(pct) {
+	return `${pct.toFixed(1)}%`;
+}
+function registerAnalyticsCommand(program) {
+	const analytics = program.command("analytics").description("Usage analytics and insights");
+	analytics.option("--days <n>", "Number of days to include", "7").action(async (opts) => {
+		clack.intro("Analytics — Dashboard");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const [summary, volume, agents] = await Promise.all([
+				store.getSummary(range),
+				store.getMessageVolume(range, "day"),
+				store.getAgentStats(range)
+			]);
+			if (summary.totalMessages === 0) {
+				clack.log.info("No messages recorded in this period.");
+				return;
+			}
+			const trend = sparkline(volume.map((v) => v.count));
+			clack.log.info(`  Messages`);
+			clack.log.info(`    Total:       ${summary.totalMessages}`);
+			clack.log.info(`    Avg/day:     ${summary.avgPerDay.toFixed(1)}`);
+			clack.log.info(`    Peak day:    ${summary.peakDay || "—"}`);
+			clack.log.info(`    Trend:       ${trend}`);
+			clack.log.info("");
+			clack.log.info(`  Response Quality`);
+			clack.log.info(`    KB answered:   ${fmtPct(summary.kbAnsweredPct)}`);
+			clack.log.info(`    LLM fallback:  ${fmtPct(summary.llmFallbackPct)}`);
+			clack.log.info(`    No answer:     ${fmtPct(summary.noAnswerPct)}`);
+			clack.log.info(`    Avg response:  ${fmtMs(summary.avgResponseTime)}`);
+			clack.log.info(`    FAQ hit rate:  ${fmtPct(summary.faqHitRate)}`);
+			clack.log.info("");
+			clack.log.info(`  Customers`);
+			clack.log.info(`    Unique:      ${summary.uniqueCustomers}`);
+			clack.log.info(`    New:         ${summary.newCustomers}`);
+			clack.log.info(`    Returning:   ${summary.returningCustomers}`);
+			if (summary.uniqueCustomers > 0) clack.log.info(`    Avg msgs:    ${(summary.totalMessages / summary.uniqueCustomers).toFixed(1)}/customer`);
+			if (agents.length > 0) {
+				clack.log.info("");
+				clack.log.info(`  Agents`);
+				for (const a of agents) {
+					const pct = summary.totalMessages > 0 ? (a.messageCount / summary.totalMessages * 100).toFixed(1) : "0.0";
+					clack.log.info(`    ${a.agentName.padEnd(20)} ${String(a.messageCount).padStart(5)} msgs (${pct}%)  avg ${fmtMs(a.avgResponseTimeMs)}`);
+				}
+			}
+			if (summary.pendingReviews > 0) {
+				clack.log.info("");
+				clack.log.info(`  Copilot`);
+				clack.log.info(`    Pending reviews: ${summary.pendingReviews}`);
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+	analytics.command("messages").description("Message volume breakdown").option("--days <n>", "Number of days to include", "7").action(async (opts) => {
+		clack.intro("Analytics — Messages");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const [daily, hourly] = await Promise.all([store.getMessageVolume(range, "day"), store.getMessageVolume(makeRange(1), "hour")]);
+			if (daily.length === 0) {
+				clack.log.info("No messages recorded in this period.");
+				return;
+			}
+			const maxDaily = Math.max(...daily.map((d) => d.count));
+			clack.log.info("  Daily Volume");
+			for (const d of daily) clack.log.info(`    ${d.date}  ${bar(d.count, maxDaily, 25)} ${d.count}`);
+			if (hourly.length > 0) {
+				const maxHourly = Math.max(...hourly.map((h) => h.count));
+				clack.log.info("");
+				clack.log.info("  Today — Hourly");
+				for (const h of hourly) {
+					const hour = h.date.split(" ")[1] || h.date;
+					clack.log.info(`    ${hour}  ${bar(h.count, maxHourly, 20)} ${h.count}`);
+				}
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+	analytics.command("agents").description("Per-agent performance breakdown").option("--days <n>", "Number of days to include", "7").action(async (opts) => {
+		clack.intro("Analytics — Agents");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const [agents, summary] = await Promise.all([store.getAgentStats(range), store.getSummary(range)]);
+			if (agents.length === 0) {
+				clack.log.info("No agent activity in this period.");
+				return;
+			}
+			const header = `${"Agent".padEnd(22)} ${"Msgs".padStart(6)} ${"%".padStart(6)} ${"Avg Time".padStart(10)} ${"Confidence".padStart(11)} ${"Escalations".padStart(12)} ${"Tools".padStart(6)}`;
+			clack.log.info(header);
+			clack.log.info("─".repeat(header.length));
+			for (const a of agents) {
+				const pct = summary.totalMessages > 0 ? (a.messageCount / summary.totalMessages * 100).toFixed(1) : "0.0";
+				const line = `${a.agentName.padEnd(22)} ${String(a.messageCount).padStart(6)} ${(pct + "%").padStart(6)} ${fmtMs(a.avgResponseTimeMs).padStart(10)} ${fmtPct(a.avgConfidence * 100).padStart(11)} ${String(a.escalationCount).padStart(12)} ${String(a.toolCallCount).padStart(6)}`;
+				clack.log.info(line);
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+	analytics.command("customers").description("Customer engagement metrics").option("--days <n>", "Number of days to include", "7").option("-n, --limit <n>", "Top customers to show", "10").action(async (opts) => {
+		clack.intro("Analytics — Customers");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const [customers, summary] = await Promise.all([store.getCustomerStats(range, parseInt(opts.limit)), store.getSummary(range)]);
+			if (customers.length === 0) {
+				clack.log.info("No customer activity in this period.");
+				return;
+			}
+			clack.log.info(`  Unique:      ${summary.uniqueCustomers}`);
+			clack.log.info(`  New:         ${summary.newCustomers}`);
+			clack.log.info(`  Returning:   ${summary.returningCustomers}`);
+			const buckets = {
+				"1 msg": 0,
+				"2-5": 0,
+				"6-10": 0,
+				"10+": 0
+			};
+			for (const c of customers) if (c.messageCount === 1) buckets["1 msg"]++;
+			else if (c.messageCount <= 5) buckets["2-5"]++;
+			else if (c.messageCount <= 10) buckets["6-10"]++;
+			else buckets["10+"]++;
+			clack.log.info("");
+			clack.log.info("  Engagement Distribution");
+			const maxBucket = Math.max(...Object.values(buckets));
+			for (const [label, count] of Object.entries(buckets)) clack.log.info(`    ${label.padEnd(8)} ${bar(count, maxBucket, 20)} ${count}`);
+			clack.log.info("");
+			clack.log.info("  Top Customers");
+			const header = `${"Phone".padEnd(16)} ${"Msgs".padStart(6)} ${"Status".padStart(8)} ${"Last Seen".padStart(12)}`;
+			clack.log.info(`    ${header}`);
+			clack.log.info(`    ${"─".repeat(header.length)}`);
+			for (const c of customers) {
+				const lastSeen = new Date(c.lastSeen).toLocaleDateString();
+				const status = c.isNew ? "new" : "return";
+				clack.log.info(`    ${maskPhone(c.customerPhone).padEnd(16)} ${String(c.messageCount).padStart(6)} ${status.padStart(8)} ${lastSeen.padStart(12)}`);
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+	analytics.command("kb").description("Knowledge Base performance metrics").option("--days <n>", "Number of days to include", "7").action(async (opts) => {
+		clack.intro("Analytics — Knowledge Base");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const kbStats = await store.getKbStats(range);
+			if (kbStats.totalQueries === 0) {
+				clack.log.info("No KB queries in this period.");
+				return;
+			}
+			clack.log.info(`  Total queries:   ${kbStats.totalQueries}`);
+			clack.log.info(`  FAQ hits:        ${kbStats.faqHits} (${fmtPct(kbStats.faqHitRate)})`);
+			clack.log.info(`  Avg top score:   ${kbStats.avgTopScore.toFixed(4)}`);
+			const hybridCount = kbStats.totalQueries - kbStats.faqHits;
+			clack.log.info("");
+			clack.log.info("  Pipeline Breakdown");
+			clack.log.info(`    FAQ fast-path:  ${kbStats.faqHits}`);
+			clack.log.info(`    Hybrid/LLM:     ${hybridCount}`);
+			if (kbStats.topFaqHits.length > 0) {
+				clack.log.info("");
+				clack.log.info("  Top FAQ Hits");
+				for (const h of kbStats.topFaqHits.slice(0, 10)) clack.log.info(`    ${String(h.count).padStart(4)}x  ${h.intent}`);
+			}
+			if (kbStats.topMisses.length > 0) {
+				clack.log.info("");
+				clack.log.info("  Top Misses (consider teaching these)");
+				for (const m of kbStats.topMisses.slice(0, 10)) clack.log.info(`    ${String(m.count).padStart(4)}x  ${m.intent}  (avg score: ${m.avgScore.toFixed(3)})`);
+				clack.log.info("");
+				clack.log.info("  Tip: Use \"operor kb add-faq <question> <answer>\" to teach missed queries.");
+			}
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+	analytics.command("export").description("Export analytics data as CSV or JSON").option("--days <n>", "Number of days to include", "7").option("--json", "Export as JSON instead of CSV").option("-o, --output <file>", "Output file path").action(async (opts) => {
+		clack.intro("Analytics — Export");
+		const store = await loadStore(getAnalyticsConfig());
+		const range = makeRange(parseInt(opts.days));
+		try {
+			const [summary, volume, agents, customers, kbStats] = await Promise.all([
+				store.getSummary(range),
+				store.getMessageVolume(range, "day"),
+				store.getAgentStats(range),
+				store.getCustomerStats(range, 100),
+				store.getKbStats(range)
+			]);
+			const data = {
+				summary,
+				volume,
+				agents,
+				customers,
+				kbStats
+			};
+			let output;
+			if (opts.json) output = JSON.stringify(data, null, 2);
+			else {
+				const lines = ["date,messages"];
+				for (const v of volume) lines.push(`${v.date},${v.count}`);
+				output = lines.join("\n");
+			}
+			if (opts.output) {
+				const { writeFileSync } = await import("node:fs");
+				writeFileSync(opts.output, output);
+				clack.log.success(`Exported to ${opts.output}`);
+			} else console.log(output);
+		} catch (error) {
+			clack.log.error(error.message);
+			process.exit(1);
+		} finally {
+			await store.close();
+		}
+		clack.outro("");
+	});
+}
+
+//#endregion
+//#region src/commands/history.ts
+function registerHistoryCommand(program) {
+	program.command("history").description("Conversation history management").command("clear").description("Clear conversation history from the memory database").option("--customer <id>", "Clear history for a specific customer ID").option("--agent <name>", "Clear history for a specific agent").option("--all", "Clear all conversation history").option("--yes", "Skip confirmation prompt").action(async (opts) => {
+		if (!opts.customer && !opts.agent && !opts.all) {
+			console.error("Specify --customer <id>, --agent <name>, --all, or a combination.");
+			process.exit(1);
+		}
+		if (!configExists()) {
+			console.error(".env file not found. Run \"operor setup\" first.");
+			process.exit(1);
+		}
+		const config = readConfig();
+		if (config.MEMORY_TYPE !== "sqlite") {
+			console.error("History clear requires SQLite memory (MEMORY_TYPE=sqlite).");
+			process.exit(1);
+		}
+		const { SQLiteMemory } = await import("@operor/memory");
+		const memory = new SQLiteMemory(config.MEMORY_DB_PATH || "./operor.db");
+		await memory.initialize();
+		try {
+			const scope = opts.all ? "ALL conversation history" : `history for ${[opts.customer && `customer=${opts.customer}`, opts.agent && `agent=${opts.agent}`].filter(Boolean).join(", ")}`;
+			if (!opts.yes) {
+				const rl = createInterface({
+					input: process.stdin,
+					output: process.stdout
+				});
+				const answer = await new Promise((r) => rl.question(`Delete ${scope}? Type "yes" to confirm: `, r));
+				rl.close();
+				if (answer.trim().toLowerCase() !== "yes") {
+					console.log("Aborted.");
+					return;
+				}
+			}
+			const { deletedCount } = await memory.clearHistory(opts.all ? void 0 : opts.customer, opts.agent);
+			console.log(`Deleted ${deletedCount} message(s).`);
+		} finally {
+			await memory.close();
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/chat.ts
+async function buildPipeline(opts) {
+	const config = readConfig();
+	if (!config.LLM_PROVIDER || !config.LLM_API_KEY) {
+		clack.log.error("LLM_PROVIDER and LLM_API_KEY required. Run \"operor setup\" first.");
+		process.exit(1);
+	}
+	const { Operor, LLMIntentClassifier, AgentLoader } = await import("@operor/core");
+	const { AIProvider } = await import("@operor/llm");
+	const { MockProvider } = await import("@operor/provider-mock");
+	const llm = new AIProvider({
+		provider: config.LLM_PROVIDER,
+		apiKey: config.LLM_API_KEY,
+		model: config.LLM_MODEL
+	});
+	let intentClassifier;
+	if (config.INTENT_CLASSIFIER === "llm") intentClassifier = new LLMIntentClassifier(llm);
+	let skillsModule;
+	try {
+		skillsModule = await import("@operor/skills");
+	} catch {}
+	const os = new Operor({
+		debug: !!opts.debug,
+		...intentClassifier && { intentClassifier },
+		...skillsModule && { skillsModule }
+	});
+	const provider = new MockProvider();
+	os.addProvider(provider);
+	const skillInstances = [];
+	if (config.SKILLS_ENABLED !== "false") try {
+		const { SkillManager, loadSkillsConfig } = await import("@operor/skills");
+		const skillsConfig = loadSkillsConfig();
+		const skills = await new SkillManager().initialize(skillsConfig);
+		for (const skill of skills) {
+			os.addSkill(skill);
+			skillInstances.push(skill);
+			if (opts.debug) clack.log.info(`[debug] MCP skill loaded: ${skill.name}`);
+		}
+	} catch (error) {
+		if (opts.debug) clack.log.warn(`[debug] MCP skills not available: ${error.message}`);
+	}
+	const allTools = opts.tools !== false ? skillInstances.flatMap((skill) => Object.values(skill.tools)) : [];
+	const getPromptSkills = (agentSkillNames) => {
+		return skillInstances.filter((s) => typeof s.getContent === "function").filter((s) => !agentSkillNames || agentSkillNames.includes(s.name)).map((s) => ({
+			name: s.name,
+			content: s.getContent()
+		}));
+	};
+	let kbRuntime;
+	let kbStore = null;
+	if (opts.kb !== false && config.KB_ENABLED === "true") try {
+		const { SQLiteKnowledgeStore, EmbeddingService, TextChunker, IngestionPipeline, RetrievalPipeline, QueryRewriter } = await import("@operor/knowledge");
+		const embedder = new EmbeddingService({
+			provider: config.KB_EMBEDDING_PROVIDER || "openai",
+			apiKey: config.KB_EMBEDDING_API_KEY || config.LLM_API_KEY,
+			model: config.KB_EMBEDDING_MODEL
+		});
+		kbStore = new SQLiteKnowledgeStore(config.KB_DB_PATH || "./knowledge.db", embedder.dimensions);
+		await kbStore.initialize();
+		let queryRewriter;
+		try {
+			queryRewriter = new QueryRewriter({ model: llm.getModel() });
+		} catch {}
+		const retrieval = new RetrievalPipeline(kbStore, embedder, {
+			faqThreshold: .85,
+			queryRewriter
+		});
+		kbRuntime = {
+			retrieve: async (query) => retrieval.retrieve(query),
+			getStats: async () => kbStore.getStats()
+		};
+		if (opts.debug) clack.log.info("[debug] Knowledge Base loaded");
+	} catch (e) {
+		clack.log.warn(`Knowledge Base configured but failed to load: ${e?.message}. Continuing without KB.`);
+	}
+	const agentsDir = `${process.cwd()}/agents`;
+	if (fs.existsSync(agentsDir)) {
+		const definitions = await new AgentLoader(process.cwd()).loadAll();
+		if (definitions.length === 0) clack.log.warn("agents/ directory found but no valid agent definitions. Falling back to default agent.");
+		else {
+			for (const def of definitions) {
+				const agentTools = def.config.skills ? skillInstances.filter((skill) => def.config.skills.includes(skill.name)).flatMap((skill) => Object.values(skill.tools)) : allTools;
+				applyLLMOverride(os.createAgent({
+					...def.config,
+					tools: agentTools
+				}), llm, agentTools, {
+					systemPrompt: def.systemPrompt,
+					kbRuntime,
+					useKB: def.config.knowledgeBase,
+					guardrails: def.config.guardrails,
+					promptSkills: getPromptSkills(def.config.skills)
+				});
+				if (opts.debug) clack.log.info(`[debug] Loaded agent: ${def.config.name}` + (def.config.skills ? ` (skills: ${def.config.skills.join(", ")})` : "") + (def.config.knowledgeBase ? " (KB)" : ""));
+			}
+			if (opts.debug) clack.log.info(`[debug] Loaded ${definitions.length} agent(s) from agents/`);
+			os.on("message:processed", (event) => {
+				os.addAssistantMessage(event.customer.id, event.response.text);
+				if (opts.debug) clack.log.info(`[debug] Agent: ${event.agent}, intent: ${event.intent?.name || "default"}, ${event.duration}ms`);
+			});
+			return {
+				os,
+				provider,
+				llm,
+				kbStore
+			};
+		}
+	}
+	applyLLMOverride(os.createAgent({
+		name: "support",
+		purpose: "Customer support agent",
+		personality: "Friendly, helpful, and professional",
+		triggers: ["*"],
+		tools: allTools,
+		...kbRuntime && { knowledgeBase: true }
+	}), llm, allTools, {
+		kbRuntime,
+		promptSkills: getPromptSkills()
+	});
+	os.on("message:processed", (event) => {
+		os.addAssistantMessage(event.customer.id, event.response.text);
+		if (opts.debug) clack.log.info(`[debug] Agent: ${event.agent}, intent: ${event.intent?.name || "default"}, ${event.duration}ms`);
+	});
+	return {
+		os,
+		provider,
+		llm,
+		kbStore
+	};
+}
+function registerChatCommand(program) {
+	program.command("chat").description("Chat with your agent (full pipeline REPL)").option("-m, --message <text>", "One-shot mode: send a single message and exit").option("--debug", "Show intent, agent selection, and KB retrieval details").option("--no-kb", "Skip Knowledge Base context injection").option("--no-tools", "Disable tool calling").action(async (opts) => {
+		if (!configExists()) {
+			clack.log.error("No configuration found. Run \"operor setup\" first.");
+			process.exit(1);
+		}
+		clack.intro("Operor — Chat");
+		const spinner = clack.spinner();
+		spinner.start("Loading pipeline...");
+		let pipeline;
+		try {
+			pipeline = await buildPipeline(opts);
+		} catch (error) {
+			spinner.stop("Failed to load pipeline");
+			clack.log.error(error.message);
+			process.exit(1);
+		}
+		const { os, provider, kbStore } = pipeline;
+		await os.start();
+		spinner.stop("Pipeline ready");
+		const cleanup = () => {
+			if (kbStore) kbStore.close();
+		};
+		if (opts.message) {
+			const responsePromise = new Promise((resolve) => {
+				os.on("message:processed", (event) => {
+					resolve(event.response.text);
+				});
+			});
+			provider.simulateIncomingMessage("+cli-user", opts.message);
+			const response = await responsePromise;
+			console.log(response);
+			cleanup();
+			clack.outro("");
+			return;
+		}
+		clack.log.info("Type your message and press Enter. Type \"exit\" or Ctrl+C to quit.\n");
+		const rl = readline.createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		const askQuestion = () => {
+			rl.question("You: ", async (input) => {
+				const trimmed = input.trim();
+				if (!trimmed || trimmed === "exit" || trimmed === "quit") {
+					rl.close();
+					cleanup();
+					clack.outro("Goodbye");
+					return;
+				}
+				const responsePromise = new Promise((resolve) => {
+					const handler = (event) => {
+						os.removeListener("message:processed", handler);
+						resolve(event.response.text);
+					};
+					os.on("message:processed", handler);
+				});
+				provider.simulateIncomingMessage("+cli-user", trimmed);
+				try {
+					const response = await responsePromise;
+					console.log(`\nAgent: ${response}\n`);
+				} catch (error) {
+					console.log(`\nError: ${error.message}\n`);
+				}
+				askQuestion();
+			});
+		};
+		rl.on("close", () => {
+			cleanup();
+			clack.outro("Goodbye");
+			process.exit(0);
+		});
+		askQuestion();
+	});
+}
+
+//#endregion
+//#region src/commands/init.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir() {
+	let dir = __dirname;
+	for (let i = 0; i < 5; i++) {
+		const candidate = join(dir, "templates", "agents");
+		if (existsSync(candidate)) return candidate;
+		dir = dirname(dir);
+	}
+	throw new Error("Could not find templates directory. Ensure packages/cli/templates/agents/ exists.");
+}
+const TEMPLATES = [
+	"customer-support",
+	"sales",
+	"faq-bot"
+];
+async function copyDir(src, dest) {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (entry.isDirectory()) await copyDir(srcPath, destPath);
+		else await cp(srcPath, destPath);
+	}
+}
+async function dirExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function runInit(templateArg) {
+	clack.intro("Operor — Initialize Agent");
+	const templatesDir = getTemplatesDir();
+	let template;
+	if (templateArg && TEMPLATES.includes(templateArg)) template = templateArg;
+	else if (templateArg === "blank") {
+		const name = await clack.text({
+			message: "Agent name:",
+			placeholder: "my-agent",
+			validate: (v) => v.length === 0 ? "Name is required" : void 0
+		});
+		if (clack.isCancel(name)) {
+			clack.cancel("Cancelled.");
+			process.exit(0);
+		}
+		const agentDir = join(process.cwd(), "agents", name);
+		if (await dirExists(agentDir)) {
+			clack.log.error(`Directory already exists: agents/${name}`);
+			process.exit(1);
+		}
+		await mkdir(agentDir, { recursive: true });
+		const defaultsDir = join(templatesDir, "_defaults");
+		if (await dirExists(defaultsDir)) {
+			const defaultsTarget = join(process.cwd(), "agents", "_defaults");
+			if (!await dirExists(defaultsTarget)) {
+				await copyDir(defaultsDir, defaultsTarget);
+				clack.log.info("Created agents/_defaults/");
+			}
+		}
+		clack.log.success(`Created blank agent at agents/${name}/`);
+		clack.log.info("Add INSTRUCTIONS.md, IDENTITY.md, and SOUL.md to configure your agent.");
+		clack.outro("Done!");
+		return;
+	} else {
+		const choice = await clack.select({
+			message: "Choose a template:",
+			options: [
+				{
+					value: "customer-support",
+					label: "Customer Support",
+					hint: "E-commerce support with Shopify"
+				},
+				{
+					value: "sales",
+					label: "Sales",
+					hint: "Lead qualification and demo booking"
+				},
+				{
+					value: "faq-bot",
+					label: "FAQ Bot",
+					hint: "Simple knowledge base Q&A"
+				},
+				{
+					value: "blank",
+					label: "Blank",
+					hint: "Empty agent directory"
+				}
+			]
+		});
+		if (clack.isCancel(choice)) {
+			clack.cancel("Cancelled.");
+			process.exit(0);
+		}
+		if (choice === "blank") {
+			await runInit("blank");
+			return;
+		}
+		template = choice;
+	}
+	const name = await clack.text({
+		message: "Agent name:",
+		placeholder: template,
+		defaultValue: template,
+		validate: (v) => v.length === 0 ? "Name is required" : void 0
+	});
+	if (clack.isCancel(name)) {
+		clack.cancel("Cancelled.");
+		process.exit(0);
+	}
+	const agentName = name;
+	const agentDir = join(process.cwd(), "agents", agentName);
+	if (await dirExists(agentDir)) {
+		clack.log.error(`Directory already exists: agents/${agentName}`);
+		process.exit(1);
+	}
+	const templateDir = join(templatesDir, template);
+	if (!await dirExists(templateDir)) {
+		clack.log.error(`Template not found: ${template}`);
+		process.exit(1);
+	}
+	await copyDir(templateDir, agentDir);
+	clack.log.success(`Created agent from "${template}" template at agents/${agentName}/`);
+	const defaultsDir = join(templatesDir, "_defaults");
+	if (await dirExists(defaultsDir)) {
+		const defaultsTarget = join(process.cwd(), "agents", "_defaults");
+		if (!await dirExists(defaultsTarget)) {
+			await copyDir(defaultsDir, defaultsTarget);
+			clack.log.info("Created agents/_defaults/");
+		}
+	}
+	const userMdSrc = join(templatesDir, "_defaults", "USER.md");
+	const userMdDest = join(process.cwd(), "USER.md");
+	if (await dirExists(userMdSrc) && !await dirExists(userMdDest)) {
+		await cp(userMdSrc, userMdDest);
+		clack.log.info("Created USER.md");
+	}
+	clack.outro("Done! Edit the files in agents/" + agentName + "/ to customize your agent.");
+}
+function registerInitCommand(program) {
+	program.command("init [template]").description("Initialize a new agent from a template (customer-support, sales, faq-bot, blank)").action(async (template) => {
+		await runInit(template);
+	});
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("operor").description("Operor - AI Agent Operating System").version("0.1.0");
+program.command("setup").description("Run the interactive setup wizard").option("--quick", "Quick setup with sensible defaults (3 questions)").action(async (opts) => {
+	if (opts.quick) await runQuickSetup();
+	else await runSetup();
+	await startOperor();
+});
+program.command("start").description("Start Operor with existing configuration").action(async () => {
+	if (!configExists()) {
+		console.error("No configuration found. Run \"operor setup\" first.");
+		process.exit(1);
+	}
+	await startOperor();
+});
+program.command("status").description("Show Operor configuration status").action(async () => {
+	const { runStatus } = await import("./status-D6LIZvQa.js");
+	await runStatus();
+});
+program.command("doctor").description("Validate Operor configuration and test connections").action(async () => {
+	const { runDoctor } = await import("./doctor-98gPl743.js");
+	await runDoctor();
+});
+program.command("test").description("Run Operor test scenarios").option("--csv <path>", "Load test cases from a CSV file").option("--tag <tag>", "Filter test cases by tag").option("--report <path>", "Save JSON results to file").option("--real", "Use real skills instead of mocks").option("--allow-writes", "Allow write operations with real skills").option("--dry-run", "Real reads, mock writes").action(async (opts) => {
+	const { runTest } = await import("./test-DYjkxbtK.js");
+	await runTest(opts);
+});
+program.command("test-suite <file>").description("Run a test suite from a CSV or JSON file").option("--strategy <type>", "Evaluation strategy: exact, contains, semantic", "contains").option("--timeout <ms>", "Per-test timeout in milliseconds", parseInt).option("--parallel", "Run tests in parallel").option("--verbose", "Show detailed output for failed tests").option("--json", "Output results as JSON").option("--real", "Use real skills instead of mocks").option("--allow-writes", "Allow write operations with real skills").option("--dry-run", "Real reads, mock writes").option("--llm", "Use LLM-based agent processing instead of pattern matcher").action(async (file, opts) => {
+	const { runTestSuite } = await import("./test-suite-D8H_5uKs.js");
+	await runTestSuite(file, opts);
+});
+program.command("converse [scenario]").description("Run multi-turn conversation test scenarios").option("--file <path>", "Load scenarios from a JSON file").option("--turns <n>", "Override max turns per scenario", parseInt).option("--persona <style>", "Override persona (polite|frustrated|confused|terse|verbose)").option("--verbose", "Show full conversation transcripts").option("--json", "Output results as JSON").option("--real", "Use real skills instead of mocks").option("--allow-writes", "Allow write operations with real skills").option("--dry-run", "Real reads, mock writes").action(async (scenario, opts) => {
+	const { runConverse } = await import("./converse-C_PB7-JH.js");
+	await runConverse({
+		scenario,
+		...opts
+	});
+});
+program.command("simulate").description("Run pre-deployment simulation (test suites + conversation scenarios)").option("--tests <files...>", "CSV/JSON test suite files to include").option("--scenarios <names...>", "Scenario names to run (or \"all\" for built-in)").option("--conversations <n>", "Number of conversations to run (default: 10)", parseInt).option("--strategy <type>", "Evaluation strategy: exact, similarity, llm_judge", "similarity").option("--real", "Use real skills instead of mocks").option("--allow-writes", "Allow write operations with real skills").option("--dry-run", "Real reads, mock writes").option("--timeout <ms>", "Per-test timeout in milliseconds", parseInt).option("--parallel", "Run tests in parallel").option("--json", "Output full report as JSON").option("--report <file>", "Save detailed JSON report to file").action(async (opts) => {
+	const { runSimulate } = await import("./simulate-BKv62GJc.js");
+	await runSimulate({
+		...opts,
+		output: opts.report
+	});
+});
+registerKBCommand(program);
+registerAnalyticsCommand(program);
+registerHistoryCommand(program);
+registerChatCommand(program);
+registerInitCommand(program);
+program.command("reset").description("Delete all data (KB, memory, analytics, copilot, skills, auth) to start fresh").option("--yes", "Skip confirmation prompt").option("--keep-config", "Keep .env and mcp.json, only delete databases").action(async (opts) => {
+	const { runReset } = await import("./reset-DT8SBgFS.js");
+	await runReset(opts);
+});
+program.command("vibe [action]").description("AI-powered agent copilot for creating and customizing agents").option("--agent <name>", "Target a specific agent").action(async (action, opts) => {
+	const { runVibe } = await import("./vibe-Bl_js3Jo.js");
+	await runVibe({
+		action,
+		agent: opts.agent
+	});
+});
+const configCmd = program.command("config").description("View and modify configuration");
+configCmd.command("show").description("Show current config").action(async () => {
+	const { showConfig } = await import("./config-Bn2pbORi.js");
+	showConfig();
+});
+configCmd.command("set <key> <value>").description("Set a config value").action(async (k, v) => {
+	const { setConfigValue } = await import("./config-Bn2pbORi.js");
+	setConfigValue(k, v);
+});
+configCmd.command("unset <key>").description("Remove a config value").action(async (k) => {
+	const { unsetConfigValue } = await import("./config-Bn2pbORi.js");
+	unsetConfigValue(k);
+});
+program.action(async () => {
+	if (!configExists()) await runSetup();
+	await startOperor();
+});
+program.parse();
+
+//#endregion
+export { readConfig as n, writeConfig as r, configExists as t };
+//# sourceMappingURL=index.js.map