milaidy 1.0.0

package/dist/eliza-CPJjgw-e.js

@@ -0,0 +1,1491 @@
+import { d as filterBootstrapFilesForSession, f as loadWorkspaceBootstrapFiles, n as DEFAULT_AGENT_WORKSPACE_DIR, p as resolveDefaultAgentWorkspaceDir, u as ensureAgentWorkspace } from "./workspace-DCA6MNVK.js";
+import "./paths-D_yh1DEJ.js";
+import "./theme-DBvtuGeq.js";
+import "./utils-C1AUpp_V.js";
+import { n as saveMilaidyConfig, t as loadMilaidyConfig } from "./workspace-Co3Wul2D.js";
+import { t as VERSION } from "./version-Cpn3yr5D.js";
+import process$1 from "node:process";
+import { homedir, platform } from "node:os";
+import { basename, extname, join, resolve } from "node:path";
+import { AgentRuntime, ChannelType, MemoryType, ModelType, buildAgentMainSessionKey, createCharacter, createMessageMemory, getSessionProviders, logger, parseAgentSessionKey, resolveDefaultSessionStorePath, stringToUuid } from "@elizaos/core";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import crypto from "node:crypto";
+import * as readline from "node:readline";
+
+//#region src/config/plugin-auto-enable.ts
+/**
+* Channel to plugin mappings.
+*/
+const CHANNEL_PLUGINS = {
+	telegram: "@elizaos/plugin-telegram",
+	discord: "@elizaos/plugin-discord",
+	slack: "@elizaos/plugin-slack",
+	twitter: "@elizaos/plugin-twitter",
+	whatsapp: "@elizaos/plugin-whatsapp",
+	signal: "@elizaos/plugin-signal",
+	bluebubbles: "@elizaos/plugin-bluebubbles",
+	imessage: "@elizaos/plugin-imessage",
+	farcaster: "@elizaos/plugin-farcaster",
+	lens: "@elizaos/plugin-lens",
+	msteams: "@elizaos/plugin-msteams",
+	mattermost: "@elizaos/plugin-mattermost",
+	googlechat: "@elizaos/plugin-google-chat",
+	feishu: "@elizaos/plugin-feishu",
+	matrix: "@elizaos/plugin-matrix",
+	nostr: "@elizaos/plugin-nostr"
+};
+/**
+* Provider to plugin mappings.
+*/
+const PROVIDER_PLUGINS = {
+	"google-antigravity": "@elizaos/plugin-google-antigravity",
+	"google-gemini": "@elizaos/plugin-google-gemini",
+	openai: "@elizaos/plugin-openai",
+	anthropic: "@elizaos/plugin-anthropic",
+	qwen: "@elizaos/plugin-qwen",
+	minimax: "@elizaos/plugin-minimax",
+	groq: "@elizaos/plugin-groq",
+	xai: "@elizaos/plugin-xai",
+	openrouter: "@elizaos/plugin-openrouter",
+	ollama: "@elizaos/plugin-ollama",
+	deepseek: "@elizaos/plugin-deepseek",
+	together: "@elizaos/plugin-together",
+	mistral: "@elizaos/plugin-mistral",
+	cohere: "@elizaos/plugin-cohere",
+	perplexity: "@elizaos/plugin-perplexity"
+};
+/**
+* Auth provider secret key to plugin mappings.
+* Used to auto-enable plugins when API keys are present in environment or secrets.
+*/
+const AUTH_PROVIDER_PLUGINS = {
+	ANTHROPIC_API_KEY: "@elizaos/plugin-anthropic",
+	CLAUDE_API_KEY: "@elizaos/plugin-anthropic",
+	OPENAI_API_KEY: "@elizaos/plugin-openai",
+	GOOGLE_API_KEY: "@elizaos/plugin-google-gemini",
+	GOOGLE_GENERATIVE_AI_API_KEY: "@elizaos/plugin-google-gemini",
+	GOOGLE_CLOUD_API_KEY: "@elizaos/plugin-google-antigravity",
+	GROQ_API_KEY: "@elizaos/plugin-groq",
+	XAI_API_KEY: "@elizaos/plugin-xai",
+	GROK_API_KEY: "@elizaos/plugin-xai",
+	OPENROUTER_API_KEY: "@elizaos/plugin-openrouter",
+	OLLAMA_BASE_URL: "@elizaos/plugin-ollama",
+	DEEPSEEK_API_KEY: "@elizaos/plugin-deepseek",
+	TOGETHER_API_KEY: "@elizaos/plugin-together",
+	MISTRAL_API_KEY: "@elizaos/plugin-mistral",
+	COHERE_API_KEY: "@elizaos/plugin-cohere",
+	PERPLEXITY_API_KEY: "@elizaos/plugin-perplexity"
+};
+/**
+* Feature to plugin mappings for optional features.
+*/
+const FEATURE_PLUGINS = {
+	browser: "@elizaos/plugin-browser",
+	cron: "@elizaos/plugin-cron",
+	shell: "@elizaos/plugin-shell",
+	imageGen: "@elizaos/plugin-image-generation",
+	tts: "@elizaos/plugin-tts",
+	stt: "@elizaos/plugin-stt",
+	agentSkills: "@elizaos/plugin-agent-skills",
+	directives: "@elizaos/plugin-directives",
+	commands: "@elizaos/plugin-commands",
+	diagnosticsOtel: "@elizaos/plugin-diagnostics-otel",
+	webhooks: "@elizaos/plugin-webhooks",
+	gmailWatch: "@elizaos/plugin-gmail-watch",
+	personality: "@elizaos/plugin-personality",
+	experience: "@elizaos/plugin-experience",
+	form: "@elizaos/plugin-form"
+};
+/**
+* Check if a channel is configured with credentials.
+*/
+function isChannelConfigured(channelName, channelConfig) {
+	if (!channelConfig || typeof channelConfig !== "object") return false;
+	const config = channelConfig;
+	if (config.botToken || config.token || config.apiKey) return true;
+	switch (channelName) {
+		case "bluebubbles": return Boolean(config.serverUrl && config.password);
+		case "imessage": return Boolean(config.cliPath);
+		case "whatsapp": return Boolean(config.authState || config.sessionPath);
+		default: return Object.keys(config).length > 0;
+	}
+}
+/**
+* Apply plugin auto-enable based on configuration.
+*
+* This function analyzes the configuration and automatically enables
+* plugins that are required based on configured channels and providers.
+*
+* @param params - Parameters
+* @returns Result with updated config and changes
+*/
+function applyPluginAutoEnable(params) {
+	const { config, env } = params;
+	const changes = [];
+	const updatedConfig = JSON.parse(JSON.stringify(config));
+	if (updatedConfig.plugins && typeof updatedConfig.plugins === "object" && updatedConfig.plugins.enabled === false) return {
+		config: updatedConfig,
+		changes
+	};
+	updatedConfig.plugins = updatedConfig.plugins ?? {};
+	const pluginsConfig = updatedConfig.plugins;
+	pluginsConfig.allow = pluginsConfig.allow ?? [];
+	pluginsConfig.entries = pluginsConfig.entries ?? {};
+	if (updatedConfig.channels && typeof updatedConfig.channels === "object") for (const [channelName, channelConfig] of Object.entries(updatedConfig.channels)) {
+		const pluginName = CHANNEL_PLUGINS[channelName];
+		if (!pluginName) continue;
+		if (!isChannelConfigured(channelName, channelConfig)) continue;
+		const entryConfig = pluginsConfig.entries[channelName];
+		if (entryConfig && entryConfig.enabled === false) continue;
+		if (!pluginsConfig.allow.includes(pluginName) && !pluginsConfig.allow.includes(channelName)) {
+			pluginsConfig.allow.push(channelName);
+			changes.push(`Auto-enabled plugin: ${pluginName} (channel: ${channelName})`);
+		}
+	}
+	if (updatedConfig.auth && typeof updatedConfig.auth === "object" && updatedConfig.auth.profiles) {
+		const profiles = updatedConfig.auth.profiles;
+		for (const [profileKey, profile] of Object.entries(profiles)) {
+			const provider = profile.provider;
+			if (!provider) continue;
+			const pluginName = PROVIDER_PLUGINS[provider];
+			if (!pluginName) continue;
+			if (!pluginsConfig.allow.includes(pluginName) && !pluginsConfig.allow.includes(provider)) {
+				pluginsConfig.allow.push(provider);
+				changes.push(`Auto-enabled plugin: ${pluginName} (auth profile: ${profileKey})`);
+			}
+		}
+	}
+	for (const [envKey, pluginName] of Object.entries(AUTH_PROVIDER_PLUGINS)) {
+		const envValue = env[envKey];
+		if (!envValue || typeof envValue !== "string" || envValue.trim() === "") continue;
+		const pluginId = pluginName.replace("@elizaos/plugin-", "");
+		const entryConfig = pluginsConfig.entries[pluginId];
+		if (entryConfig && entryConfig.enabled === false) continue;
+		if (!pluginsConfig.allow.includes(pluginName) && !pluginsConfig.allow.includes(pluginId)) {
+			pluginsConfig.allow.push(pluginId);
+			changes.push(`Auto-enabled plugin: ${pluginName} (env: ${envKey})`);
+		}
+	}
+	if (updatedConfig.features && typeof updatedConfig.features === "object") {
+		const features = updatedConfig.features;
+		for (const [featureName, featureConfig] of Object.entries(features)) {
+			const pluginName = FEATURE_PLUGINS[featureName];
+			if (!pluginName) continue;
+			if (!(featureConfig === true || featureConfig && typeof featureConfig === "object" && featureConfig.enabled !== false)) continue;
+			const pluginId = pluginName.replace("@elizaos/plugin-", "");
+			const entryConfig = pluginsConfig.entries[pluginId];
+			if (entryConfig && entryConfig.enabled === false) continue;
+			if (!pluginsConfig.allow.includes(pluginName) && !pluginsConfig.allow.includes(pluginId)) {
+				pluginsConfig.allow.push(pluginId);
+				changes.push(`Auto-enabled plugin: ${pluginName} (feature: ${featureName})`);
+			}
+		}
+	}
+	const hooksConfig = updatedConfig.hooks;
+	if (hooksConfig && hooksConfig.enabled !== false && hooksConfig.token) {
+		const webhooksPlugin = FEATURE_PLUGINS.webhooks;
+		if (webhooksPlugin) {
+			const pluginId = webhooksPlugin.replace("@elizaos/plugin-", "");
+			if (!pluginsConfig.allow.includes(webhooksPlugin) && !pluginsConfig.allow.includes(pluginId)) {
+				pluginsConfig.allow.push(pluginId);
+				changes.push(`Auto-enabled plugin: ${webhooksPlugin} (hooks.enabled + hooks.token)`);
+			}
+		}
+	}
+	if (hooksConfig) {
+		const gmailConfig = hooksConfig.gmail ?? {};
+		if (typeof gmailConfig.account === "string" && gmailConfig.account.trim()) {
+			const gmailPlugin = FEATURE_PLUGINS.gmailWatch;
+			if (gmailPlugin) {
+				const pluginId = gmailPlugin.replace("@elizaos/plugin-", "");
+				if (!pluginsConfig.allow.includes(gmailPlugin) && !pluginsConfig.allow.includes(pluginId)) {
+					pluginsConfig.allow.push(pluginId);
+					changes.push(`Auto-enabled plugin: ${gmailPlugin} (hooks.gmail.account)`);
+				}
+			}
+		}
+	}
+	return {
+		config: updatedConfig,
+		changes
+	};
+}
+
+//#endregion
+//#region src/hooks/registry.ts
+/**
+* Hook Registry — event registration and dispatch.
+*
+* Maintains a registry of hook handlers keyed by event strings.
+* Handlers are dispatched sequentially; errors are isolated.
+*
+* @module hooks/registry
+*/
+/** Internal registry: event key -> handler list. */
+const registry = /* @__PURE__ */ new Map();
+/**
+* Register a handler for an event key.
+*
+* Event keys can be:
+* - General: "command" (matches all command events)
+* - Specific: "command:new" (matches only /new)
+*/
+function registerHook(eventKey, handler) {
+	const handlers = registry.get(eventKey) ?? [];
+	handlers.push(handler);
+	registry.set(eventKey, handlers);
+}
+/**
+* Clear all registered hooks (useful for testing).
+*/
+function clearHooks() {
+	registry.clear();
+}
+/**
+* Trigger a hook event. Dispatches to all matching handlers.
+*
+* Matching order:
+* 1. Specific key: "command:new"
+* 2. General key: "command"
+*
+* Handlers run sequentially. Errors are caught and logged
+* but don't prevent other handlers from running.
+*/
+async function triggerHook(event) {
+	const specificKey = `${event.type}:${event.action}`;
+	const generalKey = event.type;
+	const handlers = [];
+	const specificHandlers = registry.get(specificKey);
+	if (specificHandlers) for (const handler of specificHandlers) handlers.push({
+		key: specificKey,
+		handler
+	});
+	const generalHandlers = registry.get(generalKey);
+	if (generalHandlers) for (const handler of generalHandlers) handlers.push({
+		key: generalKey,
+		handler
+	});
+	if (handlers.length === 0) return;
+	for (const { key, handler } of handlers) try {
+		await handler(event);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.error(`[hooks] Handler error for "${key}": ${msg}`);
+	}
+}
+/**
+* Create a hook event with sensible defaults.
+*/
+function createHookEvent(type, action, sessionKey, context = {}) {
+	return {
+		type,
+		action,
+		sessionKey,
+		timestamp: /* @__PURE__ */ new Date(),
+		messages: [],
+		context
+	};
+}
+
+//#endregion
+//#region src/hooks/discovery.ts
+/**
+* Hook Discovery — scan directories for hooks.
+*
+* Discovers hooks from three locations (in order of precedence):
+* 1. Workspace hooks: <workspace>/hooks/ (highest)
+* 2. Managed hooks: ~/.milaidy/hooks/
+* 3. Bundled hooks: <milaidy>/dist/hooks/bundled/ (lowest)
+*
+* Each hook is a directory containing HOOK.md + handler.ts/js.
+*
+* @module hooks/discovery
+*/
+const HOOK_MD = "HOOK.md";
+const HANDLER_NAMES = [
+	"handler.ts",
+	"handler.js",
+	"index.ts",
+	"index.js"
+];
+/**
+* Parse YAML-like frontmatter from HOOK.md content.
+* Supports name, description, homepage, and metadata (JSON).
+*/
+function parseFrontmatter(content) {
+	const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+	if (!fmMatch) return null;
+	const fmBlock = fmMatch[1];
+	const result = {
+		name: "",
+		description: ""
+	};
+	for (const line of fmBlock.split("\n")) {
+		const kvMatch = line.match(/^(\w+):\s*(.+)/);
+		if (!kvMatch) continue;
+		const [, key, rawValue] = kvMatch;
+		const value = rawValue.replace(/^["']|["']$/g, "").trim();
+		switch (key) {
+			case "name":
+				result.name = value;
+				break;
+			case "description":
+				result.description = value;
+				break;
+			case "homepage":
+				result.homepage = value;
+				break;
+			case "metadata":
+				try {
+					const metaStart = fmBlock.indexOf("metadata:");
+					if (metaStart !== -1) {
+						const jsonMatch = fmBlock.slice(metaStart + 9).trim().match(/\{[\s\S]*\}/);
+						if (jsonMatch) result.metadata = JSON.parse(jsonMatch[0]);
+					}
+				} catch {
+					try {
+						result.metadata = JSON.parse(value);
+					} catch {
+						logger.warn(`[hooks] Failed to parse metadata in HOOK.md`);
+					}
+				}
+				break;
+		}
+	}
+	return result.name ? result : null;
+}
+/**
+* Extract MilaidyHookMetadata from parsed frontmatter.
+*/
+function extractMetadata(frontmatter) {
+	const milaidy = frontmatter.metadata?.milaidy;
+	if (!milaidy) return void 0;
+	return {
+		always: milaidy.always,
+		hookKey: milaidy.hookKey,
+		emoji: milaidy.emoji,
+		homepage: milaidy.homepage ?? frontmatter.homepage,
+		events: Array.isArray(milaidy.events) ? milaidy.events : [],
+		export: milaidy.export,
+		os: milaidy.os,
+		requires: milaidy.requires,
+		install: milaidy.install
+	};
+}
+/**
+* Check if a path exists and is a directory.
+*/
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/**
+* Check if a file exists.
+*/
+async function fileExists(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+/**
+* Find the handler file in a hook directory.
+*/
+async function findHandlerPath(dir) {
+	for (const name of HANDLER_NAMES) {
+		const p = join(dir, name);
+		if (await fileExists(p)) return p;
+	}
+	return null;
+}
+/**
+* Load a single hook from a directory.
+*/
+async function loadHookFromDir(dir, source, pluginId) {
+	const hookMdPath = join(dir, HOOK_MD);
+	if (!await fileExists(hookMdPath)) return null;
+	const handlerPath = await findHandlerPath(dir);
+	if (!handlerPath) {
+		logger.warn(`[hooks] Hook at ${dir} has HOOK.md but no handler`);
+		return null;
+	}
+	try {
+		const frontmatter = parseFrontmatter(await readFile(hookMdPath, "utf-8"));
+		if (!frontmatter) {
+			logger.warn(`[hooks] Invalid frontmatter in ${hookMdPath}`);
+			return null;
+		}
+		const metadata = extractMetadata(frontmatter);
+		return {
+			hook: {
+				name: frontmatter.name,
+				description: frontmatter.description,
+				source,
+				pluginId,
+				filePath: hookMdPath,
+				baseDir: dir,
+				handlerPath
+			},
+			frontmatter,
+			metadata
+		};
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[hooks] Error loading hook from ${dir}: ${msg}`);
+		return null;
+	}
+}
+/**
+* Scan a directory for hook subdirectories.
+*/
+async function scanHooksDir(dir, source) {
+	if (!await isDirectory(dir)) return [];
+	const entries = [];
+	try {
+		const items = await readdir(dir);
+		for (const item of items) {
+			const itemPath = join(dir, item);
+			if (!await isDirectory(itemPath)) continue;
+			const entry = await loadHookFromDir(itemPath, source);
+			if (entry) entries.push(entry);
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[hooks] Error scanning ${dir}: ${msg}`);
+	}
+	return entries;
+}
+/**
+* Discover all hooks from configured directories.
+*
+* Precedence (later wins on name conflicts):
+* 1. Extra dirs (lowest)
+* 2. Bundled hooks
+* 3. Managed hooks (~/.milaidy/hooks/)
+* 4. Workspace hooks (<workspace>/hooks/) (highest)
+*/
+async function discoverHooks(options = {}) {
+	const seen = /* @__PURE__ */ new Map();
+	if (options.extraDirs) for (const dir of options.extraDirs) {
+		const entries = await scanHooksDir(resolve(dir.replace(/^~/, homedir())), "milaidy-managed");
+		for (const entry of entries) seen.set(entry.hook.name, entry);
+	}
+	if (options.bundledDir) {
+		const entries = await scanHooksDir(options.bundledDir, "milaidy-bundled");
+		for (const entry of entries) seen.set(entry.hook.name, entry);
+	}
+	const managedEntries = await scanHooksDir(join(homedir(), ".milaidy", "hooks"), "milaidy-managed");
+	for (const entry of managedEntries) seen.set(entry.hook.name, entry);
+	if (options.workspacePath) {
+		const wsEntries = await scanHooksDir(join(options.workspacePath.replace(/^~/, homedir()), "hooks"), "milaidy-workspace");
+		for (const entry of wsEntries) seen.set(entry.hook.name, entry);
+	}
+	const all = Array.from(seen.values());
+	logger.info(`[hooks] Discovered ${all.length} hooks`);
+	return all;
+}
+
+//#endregion
+//#region src/hooks/eligibility.ts
+/**
+* Hook Eligibility — determine if a hook should be loaded.
+*
+* Checks OS, binary, environment, and config requirements.
+*
+* @module hooks/eligibility
+*/
+/**
+* Check if a binary exists on PATH.
+*/
+function binaryExists(name) {
+	const pathDirs = (process.env.PATH ?? "").split(":");
+	for (const dir of pathDirs) if (existsSync(`${dir}/${name}`)) return true;
+	return false;
+}
+/**
+* Resolve a dot-separated config path to a value.
+*/
+function resolveConfigPath(config, pathStr) {
+	const parts = pathStr.split(".");
+	let current = config;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+}
+/**
+* Check if a config path is truthy.
+*/
+function isConfigPathTruthy(config, pathStr) {
+	const value = resolveConfigPath(config, pathStr);
+	return value !== void 0 && value !== null && value !== false && value !== "" && value !== 0;
+}
+/**
+* Check if a hook meets all eligibility requirements.
+*/
+function checkEligibility(metadata, hookConfig, milaidyConfig = {}) {
+	const missing = [];
+	if (!metadata) return {
+		eligible: true,
+		missing: []
+	};
+	if (hookConfig?.enabled === false) return {
+		eligible: false,
+		missing: ["Disabled in config"]
+	};
+	if (metadata.os && metadata.os.length > 0) {
+		if (!metadata.os.includes(platform())) missing.push(`OS: requires ${metadata.os.join("|")}, current: ${platform()}`);
+	}
+	if (metadata.always) return {
+		eligible: missing.length === 0,
+		missing
+	};
+	if (metadata.requires?.bins) {
+		for (const bin of metadata.requires.bins) if (!binaryExists(bin)) missing.push(`Binary missing: ${bin}`);
+	}
+	if (metadata.requires?.anyBins && metadata.requires.anyBins.length > 0) {
+		if (!metadata.requires.anyBins.some(binaryExists)) missing.push(`None of: ${metadata.requires.anyBins.join(", ")}`);
+	}
+	if (metadata.requires?.env) for (const envVar of metadata.requires.env) {
+		const hasInProcess = Boolean(process.env[envVar]);
+		const hasInHookConfig = Boolean(hookConfig?.env?.[envVar]);
+		if (!hasInProcess && !hasInHookConfig) missing.push(`Env missing: ${envVar}`);
+	}
+	if (metadata.requires?.config) {
+		for (const configPath of metadata.requires.config) if (!isConfigPathTruthy(milaidyConfig, configPath)) missing.push(`Config missing: ${configPath}`);
+	}
+	return {
+		eligible: missing.length === 0,
+		missing
+	};
+}
+/**
+* Resolve per-hook config from the internal hooks config.
+*/
+function resolveHookConfig(internalConfig, hookKey) {
+	return internalConfig?.entries?.[hookKey];
+}
+
+//#endregion
+//#region src/hooks/loader.ts
+/**
+* Hook Loader — load and register hooks into the event system.
+*
+* Orchestrates discovery -> eligibility -> loading -> registration.
+*
+* @module hooks/loader
+*/
+/**
+* Dynamically import a hook handler module.
+* Uses cache-busting query parameter for dev mode hot reload.
+*/
+async function loadHandlerModule(handlerPath, exportName = "default") {
+	try {
+		const handler = (await import(`${pathToFileURL(handlerPath).href}?t=${Date.now()}`))[exportName];
+		if (typeof handler !== "function") {
+			logger.warn(`[hooks] Handler at ${handlerPath} does not export a function as "${exportName}"`);
+			return null;
+		}
+		return handler;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.error(`[hooks] Failed to load handler ${handlerPath}: ${msg}`);
+		return null;
+	}
+}
+/**
+* Discover, filter, load, and register all hooks.
+*
+* This is the main entry point called during gateway startup.
+*/
+async function loadHooks(options = {}) {
+	const { internalConfig, milaidyConfig = {} } = options;
+	if (internalConfig?.enabled === false) {
+		logger.info("[hooks] Internal hooks disabled");
+		return {
+			discovered: 0,
+			eligible: 0,
+			registered: 0,
+			skipped: [],
+			failed: []
+		};
+	}
+	clearHooks();
+	const entries = await discoverHooks({
+		workspacePath: options.workspacePath,
+		bundledDir: options.bundledDir,
+		extraDirs: [...options.extraDirs ?? [], ...internalConfig?.load?.extraDirs ?? []]
+	});
+	const result = {
+		discovered: entries.length,
+		eligible: 0,
+		registered: 0,
+		skipped: [],
+		failed: []
+	};
+	for (const entry of entries) {
+		const hookConfig = resolveHookConfig(internalConfig, entry.metadata?.hookKey ?? entry.hook.name);
+		const eligibility = checkEligibility(entry.metadata, hookConfig, milaidyConfig);
+		if (!eligibility.eligible) {
+			result.skipped.push(`${entry.hook.name}: ${eligibility.missing.join(", ")}`);
+			continue;
+		}
+		result.eligible++;
+		if (hookConfig?.enabled === false) {
+			result.skipped.push(`${entry.hook.name}: disabled in config`);
+			continue;
+		}
+		const exportName = entry.metadata?.export ?? "default";
+		const handler = await loadHandlerModule(entry.hook.handlerPath, exportName);
+		if (!handler) {
+			result.failed.push(entry.hook.name);
+			continue;
+		}
+		const events = entry.metadata?.events ?? [];
+		if (events.length === 0) {
+			logger.warn(`[hooks] Hook "${entry.hook.name}" has no events configured`);
+			result.skipped.push(`${entry.hook.name}: no events`);
+			continue;
+		}
+		for (const eventKey of events) registerHook(eventKey, handler);
+		const emoji = entry.metadata?.emoji ?? "🔗";
+		logger.info(`[hooks] ${emoji} Registered: ${entry.hook.name} -> ${events.join(", ")}`);
+		result.registered++;
+	}
+	if (internalConfig?.handlers) for (const legacyHandler of internalConfig.handlers) try {
+		const handler = await loadHandlerModule(legacyHandler.module, legacyHandler.export ?? "default");
+		if (handler) {
+			registerHook(legacyHandler.event, handler);
+			logger.info(`[hooks] Registered legacy handler: ${legacyHandler.event} -> ${legacyHandler.module}`);
+			result.registered++;
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[hooks] Failed to load legacy handler: ${msg}`);
+		result.failed.push(legacyHandler.module);
+	}
+	logger.info(`[hooks] Load complete: ${result.registered}/${result.discovered} registered, ${result.skipped.length} skipped, ${result.failed.length} failed`);
+	return result;
+}
+
+//#endregion
+//#region src/agents/workspace-provider.ts
+const DEFAULT_MAX_CHARS = 2e4;
+const CACHE_TTL_MS = 6e4;
+const cache = /* @__PURE__ */ new Map();
+async function getFiles(dir) {
+	const entry = cache.get(dir);
+	if (entry && Date.now() - entry.at < CACHE_TTL_MS) return entry.files;
+	const files = await loadWorkspaceBootstrapFiles(dir);
+	cache.set(dir, {
+		files,
+		at: Date.now()
+	});
+	return files;
+}
+function truncate(content, max) {
+	if (content.length <= max) return content;
+	return `${content.slice(0, max)}\n\n[... truncated at ${max.toLocaleString()} chars]`;
+}
+function buildContext(files, maxChars) {
+	const sections = [];
+	for (const f of files) {
+		if (f.missing || !f.content?.trim()) continue;
+		const text = truncate(f.content.trim(), maxChars);
+		const tag = text.length > f.content.trim().length ? " [TRUNCATED]" : "";
+		sections.push(`### ${f.name}${tag}\n\n${text}`);
+	}
+	if (sections.length === 0) return "";
+	return `## Project Context (Workspace)\n\n${sections.join("\n\n---\n\n")}`;
+}
+function createWorkspaceProvider(options) {
+	const dir = options?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+	const maxChars = options?.maxCharsPerFile ?? DEFAULT_MAX_CHARS;
+	return {
+		name: "workspaceContext",
+		description: "Workspace bootstrap files (AGENTS.md, TOOLS.md, IDENTITY.md, etc.)",
+		position: 10,
+		async get(_runtime, message, _state) {
+			try {
+				const allFiles = await getFiles(dir);
+				const sessionKey = message.metadata?.sessionKey;
+				return {
+					text: buildContext(filterBootstrapFilesForSession(allFiles, sessionKey), maxChars),
+					data: { workspaceDir: dir }
+				};
+			} catch (err) {
+				return {
+					text: `[Workspace context unavailable: ${err instanceof Error ? err.message : err}]`,
+					data: {}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/agents/session-bridge.ts
+/**
+* Resolve an Milaidy session key from an ElizaOS room.
+*
+* DMs -> agent:{agentId}:main
+* Groups -> agent:{agentId}:{channel}:group:{groupId}
+* Channels -> agent:{agentId}:{channel}:channel:{channelId}
+* Threads append :thread:{threadId}
+*/
+function resolveSessionKeyFromRoom(agentId, room, meta) {
+	const channel = meta?.channel ?? room.source ?? "unknown";
+	if (room.type === ChannelType.DM || room.type === ChannelType.SELF) return buildAgentMainSessionKey({
+		agentId,
+		mainKey: "main"
+	});
+	const id = meta?.groupId ?? room.channelId ?? room.id;
+	const base = `agent:${agentId}:${channel}:${room.type === ChannelType.GROUP ? "group" : "channel"}:${id}`;
+	return meta?.threadId ? `${base}:thread:${meta.threadId}` : base;
+}
+function createSessionKeyProvider(options) {
+	const agentId = options?.defaultAgentId ?? "main";
+	return {
+		name: "milaidySessionKey",
+		description: "Milaidy session key (DM/group/thread isolation)",
+		dynamic: true,
+		position: 5,
+		async get(runtime, message, _state) {
+			const meta = message.metadata ?? {};
+			const existing = meta.sessionKey;
+			if (existing) {
+				const parsed = parseAgentSessionKey(existing);
+				return {
+					text: `Session: ${existing}`,
+					values: {
+						sessionKey: existing,
+						agentId: parsed?.agentId ?? agentId
+					},
+					data: { sessionKey: existing }
+				};
+			}
+			const room = await runtime.getRoom(message.roomId);
+			if (!room) {
+				const key = buildAgentMainSessionKey({
+					agentId,
+					mainKey: "main"
+				});
+				return {
+					text: `Session: ${key}`,
+					values: { sessionKey: key },
+					data: { sessionKey: key }
+				};
+			}
+			const key = resolveSessionKeyFromRoom(agentId, room, {
+				threadId: meta.threadId,
+				groupId: meta.groupId,
+				channel: meta.channel ?? room.source
+			});
+			return {
+				text: `Session: ${key}`,
+				values: {
+					sessionKey: key,
+					isGroup: room.type === ChannelType.GROUP
+				},
+				data: { sessionKey: key }
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/agents/compaction-action.ts
+/**
+* Compaction: summarize conversation history, store summary, set compaction point.
+*
+* After compaction, recentMessages provider only loads messages after lastCompactionAt.
+* The summary becomes the effective "first message" in the room.
+*/
+function buildPrompt(messages, instructions) {
+	let prompt = "Summarize this conversation for context preservation. Focus on decisions, facts learned, open questions, action items, and key context needed to continue.\n\nConversation:\n" + messages;
+	if (instructions) prompt += `\n\nAdditional instructions: ${instructions}`;
+	prompt += "\n\nSummary:";
+	return prompt;
+}
+async function summarize(runtime, roomId, instructions) {
+	const messages = await runtime.getMemories({
+		tableName: "messages",
+		roomId,
+		count: 200
+	});
+	if (!messages?.length) return "No conversation history to compact.";
+	const formatted = messages.sort((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0)).map((m) => {
+		return `${m.entityId === runtime.agentId ? "Assistant" : "User"}: ${m.content?.text ?? ""}`;
+	}).join("\n");
+	return runtime.useModel(ModelType.TEXT_LARGE, { prompt: buildPrompt(formatted, instructions) });
+}
+const compactAction = {
+	name: "COMPACT_SESSION",
+	similes: [
+		"COMPACT",
+		"COMPRESS",
+		"SUMMARIZE_SESSION"
+	],
+	description: "Summarize conversation history and set a compaction point.",
+	validate: async () => true,
+	handler: async (runtime, message, _state, _options, callback) => {
+		const { roomId } = message;
+		const instructions = (message.content?.text ?? "").replace(/^\/?compact\s*/i, "").trim() || void 0;
+		try {
+			const summary = await summarize(runtime, roomId, instructions);
+			const now = Date.now();
+			await runtime.createMemory({
+				id: crypto.randomUUID(),
+				entityId: runtime.agentId,
+				roomId,
+				content: {
+					text: `[Compaction Summary]\n\n${summary}`,
+					source: "compaction"
+				},
+				createdAt: now,
+				metadata: { type: MemoryType.CUSTOM }
+			}, "messages");
+			const room = await runtime.getRoom(roomId);
+			if (room) {
+				const prev = Array.isArray(room.metadata?.compactionHistory) ? room.metadata.compactionHistory : [];
+				const entry = {
+					timestamp: now,
+					triggeredBy: message.entityId
+				};
+				const compactionHistory = [...prev, entry].slice(-10);
+				await runtime.updateRoom({
+					...room,
+					metadata: {
+						...room.metadata,
+						lastCompactionAt: now,
+						compactionHistory
+					}
+				});
+			}
+			if (callback) await callback({ text: "Session compacted." });
+			return {
+				success: true,
+				data: { compactedAt: now }
+			};
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			if (callback) await callback({ text: `Compaction failed: ${msg}` });
+			return {
+				success: false,
+				error: msg
+			};
+		}
+	},
+	examples: [[{
+		name: "{{name1}}",
+		content: { text: "/compact" }
+	}, {
+		name: "{{agentName}}",
+		content: {
+			text: "Session compacted.",
+			actions: ["COMPACT_SESSION"]
+		}
+	}], [{
+		name: "{{name1}}",
+		content: { text: "/compact Focus on decisions" }
+	}, {
+		name: "{{agentName}}",
+		content: {
+			text: "Session compacted.",
+			actions: ["COMPACT_SESSION"]
+		}
+	}]]
+};
+
+//#endregion
+//#region src/agents/tools/memory-tools.ts
+/**
+* memory_search and memory_get actions for workspace memory files.
+*/
+const SUPPORTED_EXT = new Set([
+	".md",
+	".txt",
+	".json"
+]);
+function resolveMemoryDir(workspacePath) {
+	return join(workspacePath?.replace(/^~/, homedir()) ?? join(homedir(), ".milaidy", "workspace"), "memory");
+}
+function score(content, query) {
+	const lower = content.toLowerCase();
+	const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+	if (terms.length === 0) return 0;
+	let matched = 0;
+	for (const t of terms) if (lower.includes(t)) matched++;
+	return matched / terms.length;
+}
+const memorySearchAction = {
+	name: "memory_search",
+	description: "Search workspace memory files for relevant context.",
+	similes: ["MEMORY_SEARCH", "SEARCH_MEMORY"],
+	examples: [],
+	validate: async (_runtime, message) => {
+		const text = message.content?.text;
+		return typeof text === "string" && text.length > 0;
+	},
+	handler: async (_runtime, message, _state, options, callback) => {
+		const params = options ?? {};
+		const query = params.query ?? message.content?.text ?? "";
+		const limit = Math.min(Number(params.limit ?? 10), 50);
+		const memDir = resolveMemoryDir(params.workspacePath);
+		let files;
+		try {
+			files = await readdir(memDir);
+		} catch {
+			const msg = `Memory directory not found: ${memDir}`;
+			if (callback) await callback({ text: msg });
+			return {
+				success: false,
+				error: msg
+			};
+		}
+		const results = [];
+		for (const file of files) {
+			if (!SUPPORTED_EXT.has(extname(file))) continue;
+			const filePath = join(memDir, file);
+			let content;
+			try {
+				content = await readFile(filePath, "utf-8");
+			} catch {
+				continue;
+			}
+			const relevance = score(content, query);
+			if (relevance > 0) {
+				const snippet = content.slice(0, 200).replace(/\n/g, " ").trim();
+				results.push({
+					name: basename(file, extname(file)),
+					path: filePath,
+					relevance,
+					snippet: snippet.length < content.length ? `${snippet}...` : snippet
+				});
+			}
+		}
+		results.sort((a, b) => b.relevance - a.relevance);
+		const top = results.slice(0, limit);
+		if (top.length === 0) {
+			const msg = `No memory entries found matching "${query}"`;
+			if (callback) await callback({ text: msg });
+			return {
+				success: true,
+				text: msg
+			};
+		}
+		const output = top.map((r, i) => `${i + 1}. **${r.name}** (${(r.relevance * 100).toFixed(0)}%)\n   ${r.snippet}`).join("\n\n");
+		const text = `Found ${top.length} memory entries:\n\n${output}`;
+		if (callback) await callback({ text });
+		return {
+			success: true,
+			text,
+			data: { results: top }
+		};
+	}
+};
+const memoryGetAction = {
+	name: "memory_get",
+	description: "Retrieve a specific memory file by name.",
+	similes: [
+		"MEMORY_GET",
+		"GET_MEMORY",
+		"READ_MEMORY"
+	],
+	examples: [],
+	validate: async (_runtime, message) => {
+		const text = message.content?.text;
+		return typeof text === "string" && text.length > 0;
+	},
+	handler: async (_runtime, message, _state, options, callback) => {
+		const params = options ?? {};
+		const name = params.name ?? message.content?.text ?? "";
+		const memDir = resolveMemoryDir(params.workspacePath);
+		const candidates = [
+			name,
+			`${name}.md`,
+			`${name}.txt`,
+			`${name}.json`
+		];
+		for (const candidate of candidates) {
+			const filePath = candidate.startsWith("/") ? candidate : join(memDir, candidate);
+			let content;
+			try {
+				content = await readFile(filePath, "utf-8");
+			} catch {
+				continue;
+			}
+			const text = `# Memory: ${basename(filePath)}\n\n${content}`;
+			if (callback) await callback({ text });
+			return {
+				success: true,
+				text,
+				data: {
+					name: basename(filePath),
+					content,
+					path: filePath
+				}
+			};
+		}
+		let hint = "";
+		try {
+			const available = (await readdir(memDir)).filter((f) => SUPPORTED_EXT.has(extname(f)));
+			if (available.length > 0) hint = `\n\nAvailable: ${available.slice(0, 10).join(", ")}`;
+		} catch {}
+		const msg = `Memory not found: "${name}"${hint}`;
+		if (callback) await callback({ text: msg });
+		return {
+			success: false,
+			error: msg,
+			text: msg
+		};
+	}
+};
+
+//#endregion
+//#region src/milaidy-plugin.ts
+function createMilaidyPlugin(config) {
+	const workspaceDir = config?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+	const agentId = config?.agentId ?? "main";
+	const sessionStorePath = config?.sessionStorePath ?? resolveDefaultSessionStorePath(agentId);
+	return {
+		name: "milaidy",
+		description: "Milaidy workspace context, session keys, and compaction",
+		providers: [
+			createWorkspaceProvider({
+				workspaceDir,
+				maxCharsPerFile: config?.bootstrapMaxChars
+			}),
+			createSessionKeyProvider({ defaultAgentId: agentId }),
+			...getSessionProviders({ storePath: sessionStorePath })
+		],
+		actions: [
+			compactAction,
+			memorySearchAction,
+			memoryGetAction
+		],
+		events: { MESSAGE_RECEIVED: [async (payload) => {
+			const { runtime, message } = payload;
+			if (!message || !runtime) return;
+			const meta = message.metadata ?? {};
+			if (meta.sessionKey) return;
+			const room = await runtime.getRoom(message.roomId);
+			if (!room) return;
+			const key = resolveSessionKeyFromRoom(agentId, room, {
+				threadId: meta.threadId,
+				groupId: meta.groupId,
+				channel: meta.channel ?? room.source
+			});
+			message.metadata.sessionKey = key;
+		}] }
+	};
+}
+const milaidyPlugin = createMilaidyPlugin();
+
+//#endregion
+//#region src/eliza.ts
+/**
+* ElizaOS runtime entry point for Milaidy.
+*
+* Starts the ElizaOS agent runtime with Milaidy's plugin configuration.
+* Can be run directly via: node --import tsx src/eliza.ts
+* Or via the CLI: milaidy start
+*
+* @module eliza
+*/
+/**
+* Maps Milaidy channel config fields to the environment variable names
+* that ElizaOS plugins expect.
+*
+* Milaidy stores channel credentials under `config.channels.<name>.<field>`,
+* while ElizaOS plugins read them from process.env.
+*/
+const CHANNEL_ENV_MAP = {
+	discord: { token: "DISCORD_BOT_TOKEN" },
+	telegram: { botToken: "TELEGRAM_BOT_TOKEN" },
+	slack: {
+		botToken: "SLACK_BOT_TOKEN",
+		appToken: "SLACK_APP_TOKEN",
+		userToken: "SLACK_USER_TOKEN"
+	},
+	signal: { account: "SIGNAL_ACCOUNT" },
+	msteams: {
+		appId: "MSTEAMS_APP_ID",
+		appPassword: "MSTEAMS_APP_PASSWORD"
+	},
+	mattermost: {
+		botToken: "MATTERMOST_BOT_TOKEN",
+		baseUrl: "MATTERMOST_BASE_URL"
+	},
+	googlechat: { serviceAccountKey: "GOOGLE_CHAT_SERVICE_ACCOUNT_KEY" }
+};
+/** Core plugins that should always be loaded. */
+const CORE_PLUGINS = [
+	"@elizaos/plugin-sql",
+	"@elizaos/plugin-agent-skills",
+	"@elizaos/plugin-directives",
+	"@elizaos/plugin-commands",
+	"@elizaos/plugin-shell",
+	"@elizaos/plugin-personality",
+	"@elizaos/plugin-experience",
+	"@elizaos/plugin-form"
+];
+/** Maps Milaidy channel names to ElizaOS plugin package names. */
+const CHANNEL_PLUGIN_MAP = {
+	discord: "@elizaos/plugin-discord",
+	telegram: "@elizaos/plugin-telegram",
+	slack: "@elizaos/plugin-slack",
+	whatsapp: "@elizaos/plugin-whatsapp",
+	signal: "@elizaos/plugin-signal",
+	imessage: "@elizaos/plugin-imessage",
+	bluebubbles: "@elizaos/plugin-bluebubbles",
+	msteams: "@elizaos/plugin-msteams",
+	mattermost: "@elizaos/plugin-mattermost",
+	googlechat: "@elizaos/plugin-google-chat"
+};
+/** Maps environment variable names to model-provider plugin packages. */
+const PROVIDER_PLUGIN_MAP = {
+	ANTHROPIC_API_KEY: "@elizaos/plugin-anthropic",
+	OPENAI_API_KEY: "@elizaos/plugin-openai",
+	GOOGLE_API_KEY: "@elizaos/plugin-google-genai",
+	GOOGLE_GENERATIVE_AI_API_KEY: "@elizaos/plugin-google-genai",
+	GROQ_API_KEY: "@elizaos/plugin-groq",
+	XAI_API_KEY: "@elizaos/plugin-xai",
+	OPENROUTER_API_KEY: "@elizaos/plugin-openrouter",
+	OLLAMA_BASE_URL: "@elizaos/plugin-ollama"
+};
+/** Optional feature plugins keyed by feature name. */
+const OPTIONAL_PLUGIN_MAP = {};
+function looksLikePlugin(value) {
+	if (!value || typeof value !== "object") return false;
+	const obj = value;
+	return typeof obj.name === "string" && typeof obj.description === "string";
+}
+function extractPlugin(mod) {
+	if (looksLikePlugin(mod.default)) return mod.default;
+	if (looksLikePlugin(mod.plugin)) return mod.plugin;
+	if (looksLikePlugin(mod)) return mod;
+	return null;
+}
+/**
+* Collect the set of plugin package names that should be loaded
+* based on config, environment variables, and feature flags.
+*/
+function collectPluginNames(config) {
+	const pluginsToLoad = new Set(CORE_PLUGINS);
+	const channels = config.channels ?? {};
+	for (const [channelName, channelConfig] of Object.entries(channels)) if (channelConfig && typeof channelConfig === "object") {
+		const pluginName = CHANNEL_PLUGIN_MAP[channelName];
+		if (pluginName) pluginsToLoad.add(pluginName);
+	}
+	for (const [envKey, pluginName] of Object.entries(PROVIDER_PLUGIN_MAP)) if (process$1.env[envKey]) pluginsToLoad.add(pluginName);
+	const pluginsConfig = config.plugins;
+	if (pluginsConfig?.entries) {
+		for (const [key, entry] of Object.entries(pluginsConfig.entries)) if (entry && typeof entry === "object" && entry.enabled !== false) {
+			const pluginName = OPTIONAL_PLUGIN_MAP[key];
+			if (pluginName) pluginsToLoad.add(pluginName);
+		}
+	}
+	const features = config.features;
+	if (features && typeof features === "object") {
+		for (const [featureName, featureValue] of Object.entries(features)) if (featureValue === true || typeof featureValue === "object" && featureValue !== null && featureValue.enabled !== false) {
+			const pluginName = OPTIONAL_PLUGIN_MAP[featureName];
+			if (pluginName) pluginsToLoad.add(pluginName);
+		}
+	}
+	return pluginsToLoad;
+}
+/**
+* Resolve Milaidy plugins from config and auto-enable logic.
+* Returns an array of ElizaOS Plugin instances ready for AgentRuntime.
+*/
+async function resolvePlugins(config) {
+	const plugins = [];
+	const autoEnableResult = applyPluginAutoEnable({
+		config,
+		env: process$1.env
+	});
+	for (const change of autoEnableResult.changes) logger.info(`[milaidy] ${change}`);
+	const pluginsToLoad = collectPluginNames(config);
+	for (const pluginName of pluginsToLoad) try {
+		const pluginInstance = extractPlugin(await import(pluginName));
+		if (pluginInstance) {
+			plugins.push({
+				name: pluginName,
+				plugin: pluginInstance
+			});
+			logger.info(`[milaidy] Loaded plugin: ${pluginName}`);
+		} else logger.warn(`[milaidy] Plugin ${pluginName} did not export a valid Plugin object`);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[milaidy] Could not load plugin ${pluginName}: ${msg}`);
+	}
+	return plugins;
+}
+/**
+* Propagate channel credentials from Milaidy config into process.env so
+* that ElizaOS plugins can find them.
+*/
+function applyChannelSecretsToEnv(config) {
+	const channels = config.channels ?? {};
+	for (const [channelName, channelConfig] of Object.entries(channels)) {
+		if (!channelConfig || typeof channelConfig !== "object") continue;
+		const envMap = CHANNEL_ENV_MAP[channelName];
+		if (!envMap) continue;
+		const configObj = channelConfig;
+		for (const [configField, envKey] of Object.entries(envMap)) {
+			const value = configObj[configField];
+			if (typeof value === "string" && value.trim() && !process$1.env[envKey]) process$1.env[envKey] = value;
+		}
+	}
+}
+/**
+* Build an ElizaOS Character from the Milaidy config.
+*
+* Merges the deprecated `config.agent` object and the newer
+* `config.agents.defaults` into a single Character, collecting
+* secrets from environment variables along the way.
+*/
+function buildCharacterFromConfig(config) {
+	const legacyAgent = config.agent;
+	const name = legacyAgent?.name ?? config.ui?.assistant?.name ?? "Milaidy";
+	const bio = legacyAgent?.bio ?? "An AI assistant powered by Milaidy and ElizaOS.";
+	const systemPrompt = legacyAgent?.system_prompt;
+	const secretKeys = [
+		"ANTHROPIC_API_KEY",
+		"OPENAI_API_KEY",
+		"GOOGLE_API_KEY",
+		"GOOGLE_GENERATIVE_AI_API_KEY",
+		"GROQ_API_KEY",
+		"XAI_API_KEY",
+		"OPENROUTER_API_KEY",
+		"OLLAMA_BASE_URL",
+		"DISCORD_BOT_TOKEN",
+		"TELEGRAM_BOT_TOKEN",
+		"SLACK_BOT_TOKEN",
+		"SLACK_APP_TOKEN",
+		"SLACK_USER_TOKEN",
+		"SIGNAL_ACCOUNT",
+		"MSTEAMS_APP_ID",
+		"MSTEAMS_APP_PASSWORD",
+		"MATTERMOST_BOT_TOKEN",
+		"MATTERMOST_BASE_URL"
+	];
+	const secrets = {};
+	for (const key of secretKeys) {
+		const value = process$1.env[key];
+		if (value && value.trim()) secrets[key] = value;
+	}
+	return createCharacter({
+		name,
+		bio,
+		system: systemPrompt,
+		secrets
+	});
+}
+/**
+* Resolve the primary model identifier from Milaidy config.
+*
+* Milaidy stores the model under `agents.defaults.model.primary` as an
+* AgentModelListConfig object. Returns undefined when no model is
+* explicitly configured (ElizaOS falls back to whichever model
+* plugin is loaded).
+*/
+function resolvePrimaryModel(config) {
+	const modelConfig = config.agents?.defaults?.model;
+	if (!modelConfig) return void 0;
+	return modelConfig.primary;
+}
+/**
+* Detect whether this is the first run (no agent name configured)
+* and prompt the user to pick a name for their agent.
+*
+* Saves the chosen name, a default bio, and a basic system prompt
+* back to the Milaidy config so subsequent runs skip this step.
+*/
+async function runFirstTimeSetup(config) {
+	if (Boolean(config.agent?.name || config.ui?.assistant?.name)) return config;
+	if (!process$1.stdin.isTTY) return config;
+	const rl = readline.createInterface({
+		input: process$1.stdin,
+		output: process$1.stdout
+	});
+	const ask = (question) => new Promise((resolve) => {
+		rl.question(question, (answer) => resolve(answer));
+	});
+	console.log("");
+	const answer = await ask("  What should your agent be called? (Milaidy) ");
+	rl.close();
+	const name = answer.trim() || "Milaidy";
+	const updated = {
+		...config,
+		agent: {
+			...config.agent,
+			name,
+			bio: `An autonomous agent`,
+			system_prompt: `You are ${name}, an autonomous AI agent powered by ElizaOS. You are helpful, concise, and proactive.`
+		}
+	};
+	saveMilaidyConfig(updated);
+	console.log(`  Agent "${name}" created.\n`);
+	return updated;
+}
+/**
+* Start the ElizaOS runtime with Milaidy's configuration.
+*/
+async function startEliza() {
+	logger.info(`Milaidy v${VERSION} — starting ElizaOS runtime`);
+	let config;
+	try {
+		config = await loadMilaidyConfig();
+	} catch {
+		logger.warn("[milaidy] No config found, using defaults");
+		config = {};
+	}
+	config = await runFirstTimeSetup(config);
+	applyChannelSecretsToEnv(config);
+	const character = buildCharacterFromConfig(config);
+	logger.info(`[milaidy] Agent character: ${character.name ?? "Milaidy"}`);
+	const primaryModel = resolvePrimaryModel(config);
+	if (primaryModel) logger.info(`[milaidy] Primary model: ${primaryModel}`);
+	const workspaceDir = config.agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
+	logger.info(`[milaidy] Agent workspace: ${workspaceDir}`);
+	await ensureAgentWorkspace({
+		dir: workspaceDir,
+		ensureBootstrapFiles: true
+	});
+	const agentId = character.name?.toLowerCase().replace(/\s+/g, "-") ?? "main";
+	const milaidyPlugin = createMilaidyPlugin({
+		workspaceDir,
+		bootstrapMaxChars: config.agents?.defaults?.bootstrapMaxChars,
+		agentId
+	});
+	const resolvedPlugins = await resolvePlugins(config);
+	logger.info(`[milaidy] Resolved ${resolvedPlugins.length} plugins`);
+	logger.info(`[milaidy] Plugins: ${resolvedPlugins.map((p) => p.name.replace("@elizaos/", "")).join(", ")}`);
+	if (resolvedPlugins.length === 0) {
+		logger.error("[milaidy] No plugins loaded — at least one model provider plugin is required");
+		logger.error("[milaidy] Set an API key (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY) in your environment");
+		throw new Error("No plugins loaded");
+	}
+	const sqlPlugin = resolvedPlugins.find((p) => p.name === "@elizaos/plugin-sql");
+	const runtime = new AgentRuntime({
+		character,
+		plugins: [milaidyPlugin, ...resolvedPlugins.filter((p) => p.name !== "@elizaos/plugin-sql").map((p) => p.plugin)],
+		settings: { ...primaryModel ? { MODEL_PROVIDER: primaryModel } : {} }
+	});
+	if (sqlPlugin) await runtime.registerPlugin(sqlPlugin.plugin);
+	logger.info("[milaidy] Initializing AgentRuntime...");
+	await runtime.initialize();
+	logger.info("[milaidy] AgentRuntime initialized successfully");
+	let isShuttingDown = false;
+	const shutdown = async () => {
+		if (isShuttingDown) return;
+		isShuttingDown = true;
+		logger.info("[milaidy] Shutting down...");
+		try {
+			await runtime.stop();
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			logger.warn(`[milaidy] Error during shutdown: ${msg}`);
+		}
+		process$1.exit(0);
+	};
+	process$1.on("SIGINT", () => void shutdown());
+	process$1.on("SIGTERM", () => void shutdown());
+	try {
+		const internalHooksConfig = config.hooks?.internal;
+		const hooksResult = await loadHooks({
+			workspacePath: workspaceDir,
+			internalConfig: internalHooksConfig,
+			milaidyConfig: config
+		});
+		if (hooksResult.registered > 0) logger.info(`[milaidy] Hooks: ${hooksResult.registered} registered`);
+		await triggerHook(createHookEvent("gateway", "startup", "system", { cfg: config }));
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[milaidy] Hooks system could not load: ${msg}`);
+	}
+	logger.info("[milaidy] Runtime is ready.");
+	const agentName = character.name ?? "Milaidy";
+	const userId = crypto.randomUUID();
+	const roomId = stringToUuid(`${agentName}-chat-room`);
+	const worldId = stringToUuid(`${agentName}-chat-world`);
+	try {
+		await runtime.ensureConnection({
+			entityId: userId,
+			roomId,
+			worldId,
+			userName: "User",
+			source: "cli",
+			channelId: `${agentName}-chat`,
+			type: ChannelType.DM
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[milaidy] Could not establish chat room, retrying with fresh IDs: ${msg}`);
+		const freshRoomId = crypto.randomUUID();
+		const freshWorldId = crypto.randomUUID();
+		await runtime.ensureConnection({
+			entityId: userId,
+			roomId: freshRoomId,
+			worldId: freshWorldId,
+			userName: "User",
+			source: "cli",
+			channelId: `${agentName}-chat`,
+			type: ChannelType.DM
+		});
+	}
+	const rl = readline.createInterface({
+		input: process$1.stdin,
+		output: process$1.stdout
+	});
+	console.log(`\n💬 Chat with ${agentName} (type 'exit' to quit)\n`);
+	const prompt = () => {
+		rl.question("You: ", async (input) => {
+			const text = input.trim();
+			if (text.toLowerCase() === "exit" || text.toLowerCase() === "quit") {
+				console.log("\nGoodbye!");
+				rl.close();
+				await runtime.stop();
+				process$1.exit(0);
+			}
+			if (!text) {
+				prompt();
+				return;
+			}
+			const message = createMessageMemory({
+				id: crypto.randomUUID(),
+				entityId: userId,
+				roomId,
+				content: {
+					text,
+					source: "client_chat",
+					channelType: ChannelType.DM
+				}
+			});
+			process$1.stdout.write(`${agentName}: `);
+			await runtime?.messageService?.handleMessage(runtime, message, async (content) => {
+				if (content?.text) process$1.stdout.write(content.text);
+				return [];
+			});
+			console.log("\n");
+			prompt();
+		});
+	};
+	prompt();
+}
+if (import.meta.url === `file://${process$1.argv[1]}` || process$1.argv[1]?.endsWith("/eliza.ts") || process$1.argv[1]?.endsWith("/eliza.js")) startEliza().catch((err) => {
+	console.error("[milaidy] Fatal error:", err instanceof Error ? err.stack ?? err.message : err);
+	process$1.exit(1);
+});
+
+//#endregion
+export { startEliza };