milaidy 1.0.0

package/dist/eliza.js

@@ -0,0 +1,2192 @@
+import { createRequire } from "node:module";
+import crypto from "node:crypto";
+import process$1 from "node:process";
+import * as readline from "node:readline";
+import { AgentRuntime, ChannelType, MemoryType, ModelType, buildAgentMainSessionKey, createCharacter, createMessageMemory, getSessionProviders, isSubagentSessionKey, logger, parseAgentSessionKey, resolveDefaultSessionStorePath, stringToUuid } from "@elizaos/core";
+import fs, { existsSync } from "node:fs";
+import path, { basename, extname, join, resolve } from "node:path";
+import JSON5 from "json5";
+import os, { homedir, platform } from "node:os";
+import fs$1, { readFile, readdir, stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { spawn } from "node:child_process";
+import chalk, { Chalk } from "chalk";
+
+//#region src/version.ts
+function readVersionFromPackageJson() {
+	try {
+		return createRequire(import.meta.url)("../package.json").version ?? null;
+	} catch {
+		return null;
+	}
+}
+function readVersionFromBuildInfo() {
+	try {
+		const require = createRequire(import.meta.url);
+		for (const candidate of ["../build-info.json", "./build-info.json"]) try {
+			const info = require(candidate);
+			if (info.version) return info.version;
+		} catch {}
+		return null;
+	} catch {
+		return null;
+	}
+}
+const VERSION = typeof __MILAIDY_VERSION__ === "string" && __MILAIDY_VERSION__ || process.env.MILAIDY_BUNDLED_VERSION || readVersionFromPackageJson() || readVersionFromBuildInfo() || "0.0.0";
+
+//#endregion
+//#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/config/paths.ts
+/**
+* Nix mode detection: When MILAIDY_NIX_MODE=1, the gateway is running under Nix.
+* In this mode:
+* - No auto-install flows should be attempted
+* - Missing dependencies should produce actionable Nix-specific error messages
+* - Config is managed externally (read-only from Nix perspective)
+*/
+function resolveIsNixMode(env = process.env) {
+	return env.MILAIDY_NIX_MODE === "1";
+}
+const isNixMode = resolveIsNixMode();
+const STATE_DIRNAME = ".milaidy";
+const CONFIG_FILENAME = "milaidy.json";
+function stateDir(homedir = os.homedir) {
+	return path.join(homedir(), STATE_DIRNAME);
+}
+/**
+* State directory for mutable data (sessions, logs, caches).
+* Can be overridden via MILAIDY_STATE_DIR.
+* Default: ~/.milaidy
+*/
+function resolveStateDir(env = process.env, homedir = os.homedir) {
+	const override = env.MILAIDY_STATE_DIR?.trim();
+	if (override) return resolveUserPath$1(override);
+	return stateDir(homedir);
+}
+function resolveUserPath$1(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+const STATE_DIR = resolveStateDir();
+/**
+* Config file path (JSON5).
+* Can be overridden via MILAIDY_CONFIG_PATH.
+* Default: ~/.milaidy/milaidy.json (or $MILAIDY_STATE_DIR/milaidy.json)
+*/
+function resolveCanonicalConfigPath(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+	const override = env.MILAIDY_CONFIG_PATH?.trim();
+	if (override) return resolveUserPath$1(override);
+	return path.join(stateDirPath, CONFIG_FILENAME);
+}
+/**
+* Resolve the active config path by preferring existing config candidates
+* before falling back to the canonical path.
+*/
+function resolveConfigPathCandidate(env = process.env, homedir = os.homedir) {
+	return resolveCanonicalConfigPath(env, resolveStateDir(env, homedir));
+}
+/**
+* Active config path (prefers existing config files).
+*/
+function resolveConfigPath$1(env = process.env, stateDirPath = resolveStateDir(env, os.homedir), _homedir = os.homedir) {
+	const override = env.MILAIDY_CONFIG_PATH?.trim();
+	if (override) return resolveUserPath$1(override);
+	return path.join(stateDirPath, CONFIG_FILENAME);
+}
+const CONFIG_PATH = resolveConfigPathCandidate();
+
+//#endregion
+//#region src/config/includes.ts
+/**
+* Config includes: $include directive for modular configs
+*
+* @example
+* ```json5
+* {
+*   "$include": "./base.json5",           // single file
+*   "$include": ["./a.json5", "./b.json5"] // merge multiple
+* }
+* ```
+*/
+const INCLUDE_KEY = "$include";
+const MAX_INCLUDE_DEPTH = 10;
+var ConfigIncludeError = class extends Error {
+	constructor(message, includePath, cause) {
+		super(message);
+		this.includePath = includePath;
+		this.cause = cause;
+		this.name = "ConfigIncludeError";
+	}
+};
+var CircularIncludeError = class extends ConfigIncludeError {
+	constructor(chain) {
+		super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1]);
+		this.chain = chain;
+		this.name = "CircularIncludeError";
+	}
+};
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+/** Deep merge: arrays concatenate, objects merge recursively, primitives: source wins */
+function deepMerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	if (isPlainObject(target) && isPlainObject(source)) {
+		const result = { ...target };
+		for (const key of Object.keys(source)) result[key] = key in result ? deepMerge(result[key], source[key]) : source[key];
+		return result;
+	}
+	return source;
+}
+var IncludeProcessor = class IncludeProcessor {
+	constructor(basePath, resolver) {
+		this.basePath = basePath;
+		this.resolver = resolver;
+		this.visited = /* @__PURE__ */ new Set();
+		this.depth = 0;
+		this.visited.add(path.normalize(basePath));
+	}
+	process(obj) {
+		if (Array.isArray(obj)) return obj.map((item) => this.process(item));
+		if (!isPlainObject(obj)) return obj;
+		if (!(INCLUDE_KEY in obj)) return this.processObject(obj);
+		return this.processInclude(obj);
+	}
+	processObject(obj) {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) result[key] = this.process(value);
+		return result;
+	}
+	processInclude(obj) {
+		const includeValue = obj[INCLUDE_KEY];
+		const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
+		const included = this.resolveInclude(includeValue);
+		if (otherKeys.length === 0) return included;
+		if (!isPlainObject(included)) throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
+		const rest = {};
+		for (const key of otherKeys) rest[key] = this.process(obj[key]);
+		return deepMerge(included, rest);
+	}
+	resolveInclude(value) {
+		if (typeof value === "string") return this.loadFile(value);
+		if (Array.isArray(value)) return value.reduce((merged, item) => {
+			if (typeof item !== "string") throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
+			return deepMerge(merged, this.loadFile(item));
+		}, {});
+		throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
+	}
+	loadFile(includePath) {
+		const resolvedPath = this.resolvePath(includePath);
+		this.checkCircular(resolvedPath);
+		this.checkDepth(includePath);
+		const raw = this.readFile(includePath, resolvedPath);
+		const parsed = this.parseFile(includePath, resolvedPath, raw);
+		return this.processNested(resolvedPath, parsed);
+	}
+	resolvePath(includePath) {
+		const resolved = path.isAbsolute(includePath) ? includePath : path.resolve(path.dirname(this.basePath), includePath);
+		return path.normalize(resolved);
+	}
+	checkCircular(resolvedPath) {
+		if (this.visited.has(resolvedPath)) throw new CircularIncludeError([...this.visited, resolvedPath]);
+	}
+	checkDepth(includePath) {
+		if (this.depth >= MAX_INCLUDE_DEPTH) throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+	}
+	readFile(includePath, resolvedPath) {
+		try {
+			return this.resolver.readFile(resolvedPath);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	parseFile(includePath, resolvedPath, raw) {
+		try {
+			return this.resolver.parseJson(raw);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	processNested(resolvedPath, parsed) {
+		const nested = new IncludeProcessor(resolvedPath, this.resolver);
+		nested.visited = new Set([...this.visited, resolvedPath]);
+		nested.depth = this.depth + 1;
+		return nested.process(parsed);
+	}
+};
+const defaultResolver = {
+	readFile: (p) => fs.readFileSync(p, "utf-8"),
+	parseJson: (raw) => JSON5.parse(raw)
+};
+/**
+* Resolves all $include directives in a parsed config object.
+*/
+function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+	return new IncludeProcessor(configPath, resolver).process(obj);
+}
+
+//#endregion
+//#region src/config/env-vars.ts
+function collectConfigEnvVars(cfg) {
+	const envConfig = cfg?.env;
+	if (!envConfig) return {};
+	const entries = {};
+	if (envConfig.vars) for (const [key, value] of Object.entries(envConfig.vars)) {
+		if (!value) continue;
+		entries[key] = value;
+	}
+	for (const [key, value] of Object.entries(envConfig)) {
+		if (key === "shellEnv" || key === "vars") continue;
+		if (typeof value !== "string" || !value.trim()) continue;
+		entries[key] = value;
+	}
+	return entries;
+}
+
+//#endregion
+//#region src/config/config.ts
+/**
+* Config loading and types.
+*
+* Reads ~/.milaidy/milaidy.json (or $MILAIDY_CONFIG_PATH), resolves $include
+* directives, and applies inline env vars.
+*
+* @module config/config
+*/
+/**
+* Load the Milaidy config from disk.
+*
+* 1. Resolves the config path (~/.milaidy/milaidy.json or MILAIDY_CONFIG_PATH).
+* 2. Parses the file as JSON5.
+* 3. Resolves any $include directives.
+* 4. Applies inline env vars (config.env.vars) to process.env.
+*
+* Returns an empty MilaidyConfig when the file is missing.
+*/
+async function loadMilaidyConfig() {
+	const configPath = resolveConfigPath$1();
+	let raw;
+	try {
+		raw = fs.readFileSync(configPath, "utf-8");
+	} catch {
+		return {};
+	}
+	const resolved = resolveConfigIncludes(JSON5.parse(raw), configPath);
+	const envVars = collectConfigEnvVars(resolved);
+	for (const [key, value] of Object.entries(envVars)) if (!process.env[key]) process.env[key] = value;
+	return resolved;
+}
+/**
+* Save the Milaidy config to disk.
+*
+* Writes the config as pretty-printed JSON to the resolved config path.
+* Creates the parent directory if it doesn't exist.
+*/
+function saveMilaidyConfig(config) {
+	const configPath = resolveConfigPath$1();
+	const dir = path.dirname(configPath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+}
+
+//#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/process/exec.ts
+/**
+* Runs a command with an optional timeout.
+* Returns { code, stdout, stderr }.
+* Rejects if the process cannot be spawned or the timeout fires.
+*/
+function runCommandWithTimeout(argv, opts = {}) {
+	const [cmd, ...args] = argv;
+	if (!cmd) return Promise.reject(/* @__PURE__ */ new Error("runCommandWithTimeout: empty argv"));
+	return new Promise((resolve, reject) => {
+		const child = spawn(cmd, args, {
+			cwd: opts.cwd,
+			env: opts.env ?? process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+		child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+		let timedOut = false;
+		let timer;
+		if (opts.timeoutMs && opts.timeoutMs > 0) timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGKILL");
+		}, opts.timeoutMs);
+		child.on("error", (err) => {
+			if (timer) clearTimeout(timer);
+			reject(err);
+		});
+		child.on("close", (exitCode) => {
+			if (timer) clearTimeout(timer);
+			if (timedOut) {
+				reject(/* @__PURE__ */ new Error(`Command timed out after ${opts.timeoutMs}ms: ${argv.join(" ")}`));
+				return;
+			}
+			resolve({
+				code: exitCode ?? 1,
+				stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+				stderr: Buffer.concat(stderrChunks).toString("utf-8")
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/logging.ts
+const ALLOWED_LOG_LEVELS = [
+	"trace",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"fatal",
+	"silent"
+];
+function normalizeLogLevel(level, fallback = "info") {
+	if (!level) return fallback;
+	const normalized = level.toLowerCase();
+	return ALLOWED_LOG_LEVELS.includes(normalized) ? normalized : fallback;
+}
+let consoleSettings = {
+	level: normalizeLogLevel(process.env.LOG_LEVEL, "info"),
+	style: process.env.LOG_JSON_FORMAT === "true" ? "json" : "pretty"
+};
+
+//#endregion
+//#region src/terminal/palette.ts
+const CLI_PALETTE = {
+	accent: "#FF5A2D",
+	accentBright: "#FF7A3D",
+	accentDim: "#D14A22",
+	info: "#FF8A5B",
+	success: "#2FBF71",
+	warn: "#FFB020",
+	error: "#E23D2D",
+	muted: "#8B7F77"
+};
+
+//#endregion
+//#region src/terminal/theme.ts
+const hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
+const baseChalk = process.env.NO_COLOR && !hasForceColor ? new Chalk({ level: 0 }) : chalk;
+const hex = (value) => baseChalk.hex(value);
+const theme = {
+	accent: hex(CLI_PALETTE.accent),
+	accentBright: hex(CLI_PALETTE.accentBright),
+	accentDim: hex(CLI_PALETTE.accentDim),
+	info: hex(CLI_PALETTE.info),
+	success: hex(CLI_PALETTE.success),
+	warn: hex(CLI_PALETTE.warn),
+	error: hex(CLI_PALETTE.error),
+	muted: hex(CLI_PALETTE.muted),
+	heading: baseChalk.bold.hex(CLI_PALETTE.accent),
+	command: hex(CLI_PALETTE.accentBright),
+	option: hex(CLI_PALETTE.warn)
+};
+
+//#endregion
+//#region src/globals.ts
+const success = theme.success;
+const warn = theme.warn;
+const info = theme.info;
+const danger = theme.error;
+
+//#endregion
+//#region src/utils.ts
+function resolveUserPath(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+function resolveConfigDir(env = process.env, homedir = os.homedir) {
+	const override = env.MILAIDY_STATE_DIR?.trim();
+	if (override) return resolveUserPath(override);
+	return path.join(homedir(), ".milaidy");
+}
+const CONFIG_DIR = resolveConfigDir();
+
+//#endregion
+//#region src/infra/milaidy-root.ts
+const CORE_PACKAGE_NAMES = new Set(["milaidy"]);
+async function readPackageName(dir) {
+	try {
+		const raw = await fs$1.readFile(path.join(dir, "package.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.name === "string" ? parsed.name : null;
+	} catch {
+		return null;
+	}
+}
+async function findPackageRoot(startDir, maxDepth = 12) {
+	let current = path.resolve(startDir);
+	for (let i = 0; i < maxDepth; i += 1) {
+		const name = await readPackageName(current);
+		if (name && CORE_PACKAGE_NAMES.has(name)) return current;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+function candidateDirsFromArgv1(argv1) {
+	const normalized = path.resolve(argv1);
+	const candidates = [path.dirname(normalized)];
+	const parts = normalized.split(path.sep);
+	const binIndex = parts.lastIndexOf(".bin");
+	if (binIndex > 0 && parts[binIndex - 1] === "node_modules") {
+		const binName = path.basename(normalized);
+		const nodeModulesDir = parts.slice(0, binIndex).join(path.sep);
+		candidates.push(path.join(nodeModulesDir, binName));
+	}
+	return candidates;
+}
+async function resolveMilaidyPackageRoot(opts) {
+	const candidates = [];
+	if (opts.moduleUrl) candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));
+	if (opts.argv1) candidates.push(...candidateDirsFromArgv1(opts.argv1));
+	if (opts.cwd) candidates.push(opts.cwd);
+	for (const candidate of candidates) {
+		const found = await findPackageRoot(candidate);
+		if (found) return found;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/agents/workspace-templates.ts
+const FALLBACK_TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../docs/reference/templates");
+let cachedTemplateDir;
+let resolvingTemplateDir;
+async function pathExists(candidate) {
+	try {
+		await fs$1.access(candidate);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveWorkspaceTemplateDir(opts) {
+	if (cachedTemplateDir) return cachedTemplateDir;
+	if (resolvingTemplateDir) return resolvingTemplateDir;
+	resolvingTemplateDir = (async () => {
+		const moduleUrl = opts?.moduleUrl ?? import.meta.url;
+		const argv1 = opts?.argv1 ?? process.argv[1];
+		const cwd = opts?.cwd ?? process.cwd();
+		const packageRoot = await resolveMilaidyPackageRoot({
+			moduleUrl,
+			argv1,
+			cwd
+		});
+		const candidates = [
+			packageRoot ? path.join(packageRoot, "docs", "reference", "templates") : null,
+			cwd ? path.resolve(cwd, "docs", "reference", "templates") : null,
+			FALLBACK_TEMPLATE_DIR
+		].filter(Boolean);
+		for (const candidate of candidates) if (await pathExists(candidate)) {
+			cachedTemplateDir = candidate;
+			return candidate;
+		}
+		cachedTemplateDir = candidates[0] ?? FALLBACK_TEMPLATE_DIR;
+		return cachedTemplateDir;
+	})();
+	try {
+		return await resolvingTemplateDir;
+	} finally {
+		resolvingTemplateDir = void 0;
+	}
+}
+
+//#endregion
+//#region src/agents/workspace.ts
+function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+	const profile = env.MILAIDY_PROFILE?.trim();
+	if (profile && profile.toLowerCase() !== "default") return path.join(homedir(), ".milaidy", `workspace-${profile}`);
+	return path.join(homedir(), ".milaidy", "workspace");
+}
+const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
+const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+const DEFAULT_USER_FILENAME = "USER.md";
+const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
+const DEFAULT_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
+const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+function stripFrontMatter(content) {
+	if (!content.startsWith("---")) return content;
+	const endIndex = content.indexOf("\n---", 3);
+	if (endIndex === -1) return content;
+	const start = endIndex + 4;
+	let trimmed = content.slice(start);
+	trimmed = trimmed.replace(/^\s+/, "");
+	return trimmed;
+}
+async function loadTemplate(name) {
+	const templateDir = await resolveWorkspaceTemplateDir();
+	const templatePath = path.join(templateDir, name);
+	try {
+		return stripFrontMatter(await fs$1.readFile(templatePath, "utf-8"));
+	} catch {
+		throw new Error(`Missing workspace template: ${name} (${templatePath}). Ensure docs/reference/templates are packaged.`);
+	}
+}
+async function writeFileIfMissing(filePath, content) {
+	try {
+		await fs$1.writeFile(filePath, content, {
+			encoding: "utf-8",
+			flag: "wx"
+		});
+	} catch (err) {
+		if (err.code !== "EEXIST") throw err;
+	}
+}
+async function hasGitRepo(dir) {
+	try {
+		await fs$1.stat(path.join(dir, ".git"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isGitAvailable() {
+	try {
+		return (await runCommandWithTimeout(["git", "--version"], { timeoutMs: 2e3 })).code === 0;
+	} catch {
+		return false;
+	}
+}
+async function ensureGitRepo(dir, isBrandNewWorkspace) {
+	if (!isBrandNewWorkspace) return;
+	if (await hasGitRepo(dir)) return;
+	if (!await isGitAvailable()) return;
+	try {
+		await runCommandWithTimeout(["git", "init"], {
+			cwd: dir,
+			timeoutMs: 1e4
+		});
+	} catch {}
+}
+async function ensureAgentWorkspace(params) {
+	const dir = resolveUserPath(params?.dir?.trim() ? params.dir.trim() : DEFAULT_AGENT_WORKSPACE_DIR);
+	await fs$1.mkdir(dir, { recursive: true });
+	if (!params?.ensureBootstrapFiles) return { dir };
+	const agentsPath = path.join(dir, DEFAULT_AGENTS_FILENAME);
+	const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
+	const identityPath = path.join(dir, DEFAULT_IDENTITY_FILENAME);
+	const userPath = path.join(dir, DEFAULT_USER_FILENAME);
+	const heartbeatPath = path.join(dir, DEFAULT_HEARTBEAT_FILENAME);
+	const bootstrapPath = path.join(dir, DEFAULT_BOOTSTRAP_FILENAME);
+	const isBrandNewWorkspace = await (async () => {
+		const paths = [
+			agentsPath,
+			toolsPath,
+			identityPath,
+			userPath,
+			heartbeatPath
+		];
+		return (await Promise.all(paths.map(async (p) => {
+			try {
+				await fs$1.access(p);
+				return true;
+			} catch {
+				return false;
+			}
+		}))).every((v) => !v);
+	})();
+	const agentsTemplate = await loadTemplate(DEFAULT_AGENTS_FILENAME);
+	const toolsTemplate = await loadTemplate(DEFAULT_TOOLS_FILENAME);
+	const identityTemplate = await loadTemplate(DEFAULT_IDENTITY_FILENAME);
+	const userTemplate = await loadTemplate(DEFAULT_USER_FILENAME);
+	const heartbeatTemplate = await loadTemplate(DEFAULT_HEARTBEAT_FILENAME);
+	const bootstrapTemplate = await loadTemplate(DEFAULT_BOOTSTRAP_FILENAME);
+	await writeFileIfMissing(agentsPath, agentsTemplate);
+	await writeFileIfMissing(toolsPath, toolsTemplate);
+	await writeFileIfMissing(identityPath, identityTemplate);
+	await writeFileIfMissing(userPath, userTemplate);
+	await writeFileIfMissing(heartbeatPath, heartbeatTemplate);
+	if (isBrandNewWorkspace) await writeFileIfMissing(bootstrapPath, bootstrapTemplate);
+	await ensureGitRepo(dir, isBrandNewWorkspace);
+	return {
+		dir,
+		agentsPath,
+		toolsPath,
+		identityPath,
+		userPath,
+		heartbeatPath,
+		bootstrapPath
+	};
+}
+async function resolveMemoryBootstrapEntries(resolvedDir) {
+	const candidates = [DEFAULT_MEMORY_FILENAME, DEFAULT_MEMORY_ALT_FILENAME];
+	const entries = [];
+	for (const name of candidates) {
+		const filePath = path.join(resolvedDir, name);
+		try {
+			await fs$1.access(filePath);
+			entries.push({
+				name,
+				filePath
+			});
+		} catch {}
+	}
+	if (entries.length <= 1) return entries;
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const entry of entries) {
+		let key = entry.filePath;
+		try {
+			key = await fs$1.realpath(entry.filePath);
+		} catch {}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(entry);
+	}
+	return deduped;
+}
+async function loadWorkspaceBootstrapFiles(dir) {
+	const resolvedDir = resolveUserPath(dir);
+	const entries = [
+		{
+			name: DEFAULT_AGENTS_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_AGENTS_FILENAME)
+		},
+		{
+			name: DEFAULT_TOOLS_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_TOOLS_FILENAME)
+		},
+		{
+			name: DEFAULT_IDENTITY_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_IDENTITY_FILENAME)
+		},
+		{
+			name: DEFAULT_USER_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_USER_FILENAME)
+		},
+		{
+			name: DEFAULT_HEARTBEAT_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_HEARTBEAT_FILENAME)
+		},
+		{
+			name: DEFAULT_BOOTSTRAP_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_BOOTSTRAP_FILENAME)
+		}
+	];
+	entries.push(...await resolveMemoryBootstrapEntries(resolvedDir));
+	const result = [];
+	for (const entry of entries) try {
+		const content = await fs$1.readFile(entry.filePath, "utf-8");
+		result.push({
+			name: entry.name,
+			path: entry.filePath,
+			content,
+			missing: false
+		});
+	} catch {
+		result.push({
+			name: entry.name,
+			path: entry.filePath,
+			missing: true
+		});
+	}
+	return result;
+}
+const SUBAGENT_BOOTSTRAP_ALLOWLIST = new Set([DEFAULT_AGENTS_FILENAME, DEFAULT_TOOLS_FILENAME]);
+function filterBootstrapFilesForSession(files, sessionKey) {
+	if (!sessionKey || !isSubagentSessionKey(sessionKey)) return files;
+	return files.filter((file) => SUBAGENT_BOOTSTRAP_ALLOWLIST.has(file.name));
+}
+
+//#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 };