miladyai 2.0.0-alpha.27

package/dist/runtime/eliza.js

@@ -0,0 +1,2061 @@
+import { resolveStateDir, resolveUserPath } from "../config/paths.js";
+import { collectConfigEnvVars } from "../config/env-vars.js";
+import { configFileExists, loadMiladyConfig, saveMiladyConfig } from "../config/config.js";
+import { ensureAgentWorkspace, resolveDefaultAgentWorkspaceDir } from "../providers/workspace.js";
+import { CORE_PLUGINS, OPTIONAL_CORE_PLUGINS } from "./core-plugins.js";
+import { SandboxAuditLog } from "../security/audit-log.js";
+import { debugLogResolvedContext, validateRuntimeContext } from "../api/plugin-validation.js";
+import { STYLE_PRESETS } from "../onboarding-presets.js";
+import { pickRandomNames } from "./onboarding-names.js";
+import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
+import { createHookEvent, triggerHook } from "../hooks/registry.js";
+import { loadHooks } from "../hooks/loader.js";
+import "../hooks/index.js";
+import { SandboxManager } from "../services/sandbox-manager.js";
+import { diagnoseNoAIProvider } from "../services/version-compat.js";
+import { createMiladyPlugin } from "./milady-plugin.js";
+import { createRequire } from "node:module";
+import process from "node:process";
+import os from "node:os";
+import path from "node:path";
+import { AgentRuntime, AutonomyService, ChannelType, addLogListener, createMessageMemory, logger, mergeCharacterDefaults, stringToUuid } from "@elizaos/core";
+import crypto from "node:crypto";
+import { existsSync, mkdirSync, symlinkSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import fs$1 from "node:fs/promises";
+import * as readline from "node:readline";
+import * as clack from "@clack/prompts";
+
+//#region src/runtime/eliza.ts
+/**
+* ElizaOS runtime entry point for Milady.
+*
+* Starts the ElizaOS agent runtime with Milady's plugin configuration.
+* Can be run directly via: node --import tsx src/runtime/eliza.ts
+* Or via the CLI: milady start
+*
+* @module eliza
+*/
+function configureLocalEmbeddingPlugin(_plugin, config) {
+	const isAppleSilicon = process.platform === "darwin" && process.arch === "arm64";
+	const embeddingConfig = config?.embedding;
+	const configuredModel = embeddingConfig?.model?.trim();
+	const configuredRepo = embeddingConfig?.modelRepo?.trim();
+	const configuredDimensions = typeof embeddingConfig?.dimensions === "number" && Number.isInteger(embeddingConfig.dimensions) && embeddingConfig.dimensions > 0 ? String(embeddingConfig.dimensions) : void 0;
+	const configuredContextSize = typeof embeddingConfig?.contextSize === "number" && Number.isInteger(embeddingConfig.contextSize) && embeddingConfig.contextSize > 0 ? String(embeddingConfig.contextSize) : void 0;
+	const configuredGpuLayers = (() => {
+		const value = embeddingConfig?.gpuLayers;
+		if (typeof value === "number" && Number.isInteger(value) && value >= 0) return String(value);
+		if (value === "auto" || value === "max") return "auto";
+	})();
+	const setEnvIfMissing = (key, value) => {
+		if (!value || process.env[key]) return;
+		process.env[key] = value;
+	};
+	const setEnvFromConfig = (key, value) => {
+		if (!value) return;
+		process.env[key] = value;
+	};
+	setEnvIfMissing("LOCAL_EMBEDDING_MODEL", configuredModel || "nomic-embed-text-v1.5.Q5_K_M.gguf");
+	setEnvFromConfig("LOCAL_EMBEDDING_MODEL_REPO", configuredRepo);
+	setEnvFromConfig("LOCAL_EMBEDDING_DIMENSIONS", configuredDimensions);
+	setEnvFromConfig("LOCAL_EMBEDDING_CONTEXT_SIZE", configuredContextSize);
+	if (configuredGpuLayers) process.env.LOCAL_EMBEDDING_GPU_LAYERS = configuredGpuLayers;
+	else if (!process.env.LOCAL_EMBEDDING_GPU_LAYERS) process.env.LOCAL_EMBEDDING_GPU_LAYERS = isAppleSilicon ? "auto" : "0";
+	setEnvIfMissing("LOCAL_EMBEDDING_USE_MMAP", isAppleSilicon ? "false" : "true");
+	setEnvIfMissing("MODELS_DIR", path.join(os.homedir(), ".eliza", "models"));
+	setEnvIfMissing("GOOGLE_GENERATIVE_AI_API_KEY", process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY);
+	setEnvIfMissing("GOOGLE_SMALL_MODEL", "gemini-3-flash-preview");
+	setEnvIfMissing("GOOGLE_LARGE_MODEL", "gemini-3.1-pro-preview");
+	logger.info(`[milady] Configured local embedding env: ${process.env.LOCAL_EMBEDDING_MODEL} (repo: ${process.env.LOCAL_EMBEDDING_MODEL_REPO ?? "auto"}, dims: ${process.env.LOCAL_EMBEDDING_DIMENSIONS ?? "auto"}, ctx: ${process.env.LOCAL_EMBEDDING_CONTEXT_SIZE ?? "auto"}, GPU: ${process.env.LOCAL_EMBEDDING_GPU_LAYERS}, mmap: ${process.env.LOCAL_EMBEDDING_USE_MMAP})`);
+}
+/** Extract a human-readable error message from an unknown thrown value. */
+function formatError(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/**
+* Remove duplicate actions across an ordered list of plugins.
+*
+* When multiple plugins define an action with the same `name`, only the first
+* occurrence is kept.  This prevents "Action already registered" warnings from
+* ElizaOS core.  The function mutates each plugin's `actions` array in-place.
+*/
+function deduplicatePluginActions(plugins) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) if (plugin.actions) plugin.actions = plugin.actions.filter((action) => {
+		if (seen.has(action.name)) {
+			logger.debug(`[milady] Skipping duplicate action "${action.name}" from plugin "${plugin.name}"`);
+			return false;
+		}
+		seen.add(action.name);
+		return true;
+	});
+}
+function collectTrajectoryLoggerCandidates(runtimeLike) {
+	const candidates = [];
+	if (typeof runtimeLike.getServicesByType === "function") {
+		const byType = runtimeLike.getServicesByType("trajectory_logger");
+		if (Array.isArray(byType) && byType.length > 0) {
+			for (const service of byType) if (service) candidates.push(service);
+		} else if (byType && !Array.isArray(byType)) candidates.push(byType);
+	}
+	if (typeof runtimeLike.getService === "function") {
+		const single = runtimeLike.getService("trajectory_logger");
+		if (single) candidates.push(single);
+	}
+	return candidates;
+}
+async function waitForTrajectoryLoggerService(runtime, context, timeoutMs = 3e3) {
+	const runtimeLike = runtime;
+	if (collectTrajectoryLoggerCandidates(runtimeLike).length > 0) return;
+	const registrationStatus = typeof runtimeLike.getServiceRegistrationStatus === "function" ? runtimeLike.getServiceRegistrationStatus("trajectory_logger") : "unknown";
+	if (registrationStatus !== "pending" && registrationStatus !== "registering") return;
+	if (typeof runtimeLike.getServiceLoadPromise !== "function") return;
+	let timedOut = false;
+	let timeoutHandle;
+	const timeoutPromise = new Promise((resolve) => {
+		timeoutHandle = setTimeout(() => {
+			timedOut = true;
+			resolve();
+		}, timeoutMs);
+	});
+	try {
+		await Promise.race([runtimeLike.getServiceLoadPromise("trajectory_logger").then(() => {}), timeoutPromise]);
+		if (timedOut) logger.debug(`[milady] trajectory_logger still ${registrationStatus} after ${timeoutMs}ms (${context})`);
+	} catch (err) {
+		logger.debug(`[milady] trajectory_logger registration failed while waiting (${context}): ${formatError(err)}`);
+	} finally {
+		if (timeoutHandle) clearTimeout(timeoutHandle);
+	}
+}
+function ensureTrajectoryLoggerEnabled(runtime, context) {
+	const candidates = collectTrajectoryLoggerCandidates(runtime);
+	let trajectoryLogger = null;
+	let bestScore = -1;
+	for (const candidate of candidates) {
+		const candidateWithRuntime = candidate;
+		let score = 0;
+		if (typeof candidate.isEnabled === "function") score += 2;
+		if (typeof candidateWithRuntime.setEnabled === "function") score += 2;
+		if (candidateWithRuntime.initialized === true) score += 3;
+		if (candidateWithRuntime.runtime?.adapter) score += 3;
+		if (typeof candidate.isEnabled === "function" ? candidate.isEnabled() : true) score += 1;
+		if (score > bestScore) {
+			trajectoryLogger = candidate;
+			bestScore = score;
+		}
+	}
+	if (!trajectoryLogger) {
+		logger.warn(`[milady] trajectory_logger service unavailable (${context}); trajectory capture disabled`);
+		return;
+	}
+	if (!(typeof trajectoryLogger.isEnabled === "function" ? trajectoryLogger.isEnabled() : true) && typeof trajectoryLogger.setEnabled === "function") {
+		trajectoryLogger.setEnabled(true);
+		logger.info("[milady] trajectory_logger enabled by default");
+	}
+}
+/**
+* Cancel the onboarding flow and exit cleanly.
+* Extracted to avoid duplicating the cancel+exit pattern 7 times.
+*/
+function cancelOnboarding() {
+	clack.cancel("Maybe next time!");
+	process.exit(0);
+}
+/**
+* Maps Milady channel config fields to the environment variable names
+* that ElizaOS plugins expect.
+*
+* Milady stores channel credentials under `config.channels.<name>.<field>`,
+* while ElizaOS plugins read them from process.env.
+*/
+const CHANNEL_ENV_MAP = {
+	discord: {
+		token: "DISCORD_API_TOKEN",
+		botToken: "DISCORD_API_TOKEN",
+		applicationId: "DISCORD_APPLICATION_ID"
+	},
+	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" }
+};
+/** Maps Milady channel names to plugin package names. */
+const CHANNEL_PLUGIN_MAP = {
+	discord: "@elizaos/plugin-discord",
+	telegram: "@elizaos/plugin-telegram",
+	slack: "@elizaos/plugin-slack",
+	twitter: "@elizaos/plugin-twitter",
+	whatsapp: "@milady/plugin-whatsapp",
+	signal: "@elizaos/plugin-signal",
+	imessage: "@elizaos/plugin-imessage",
+	bluebubbles: "@elizaos/plugin-bluebubbles",
+	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",
+	retake: "@milady/plugin-retake"
+};
+const PI_AI_PLUGIN_PACKAGE = "@elizaos/plugin-pi-ai";
+function isPiAiEnabledFromEnv(env = process.env) {
+	const raw = env.MILAIDY_USE_PI_AI;
+	if (!raw) return false;
+	const value = String(raw).trim().toLowerCase();
+	return value === "1" || value === "true" || value === "yes";
+}
+/** 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",
+	GEMINI_API_KEY: "@elizaos/plugin-google-genai",
+	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",
+	AI_GATEWAY_API_KEY: "@elizaos/plugin-vercel-ai-gateway",
+	AIGATEWAY_API_KEY: "@elizaos/plugin-vercel-ai-gateway",
+	OLLAMA_BASE_URL: "@elizaos/plugin-ollama",
+	ZAI_API_KEY: "@homunculuslabs/plugin-zai",
+	MILAIDY_USE_PI_AI: PI_AI_PLUGIN_PACKAGE,
+	ELIZAOS_CLOUD_API_KEY: "@elizaos/plugin-elizacloud",
+	ELIZAOS_CLOUD_ENABLED: "@elizaos/plugin-elizacloud"
+};
+/**
+* Optional feature plugins keyed by feature name.
+*
+* Mappings here support short IDs in allow-lists and feature toggles.
+* Keep this map in sync with optional plugin registration and tests.
+*/
+const OPTIONAL_PLUGIN_MAP = {
+	browser: "@elizaos/plugin-browser",
+	vision: "@elizaos/plugin-vision",
+	cron: "@elizaos/plugin-cron",
+	cua: "@elizaos/plugin-cua",
+	computeruse: "@elizaos/plugin-computeruse",
+	obsidian: "@elizaos/plugin-obsidian",
+	repoprompt: "@elizaos/plugin-repoprompt",
+	repoPrompt: "@elizaos/plugin-repoprompt",
+	"pi-ai": PI_AI_PLUGIN_PACKAGE,
+	piAi: PI_AI_PLUGIN_PACKAGE,
+	x402: "@elizaos/plugin-x402",
+	"coding-agent": "@milaidy/plugin-coding-agent"
+};
+function looksLikePlugin(value) {
+	if (!value || typeof value !== "object") return false;
+	const obj = value;
+	if (typeof obj.name !== "string" || typeof obj.description !== "string") return false;
+	return Array.isArray(obj.services) || Array.isArray(obj.providers) || Array.isArray(obj.actions) || Array.isArray(obj.routes) || Array.isArray(obj.events) || typeof obj.init === "function";
+}
+function looksLikePluginBasic(value) {
+	if (!value || typeof value !== "object") return false;
+	const obj = value;
+	return typeof obj.name === "string" && typeof obj.description === "string";
+}
+function findRuntimePluginExport(mod) {
+	if (looksLikePlugin(mod.default)) return mod.default;
+	if (looksLikePlugin(mod.plugin)) return mod.plugin;
+	if (looksLikePlugin(mod)) return mod;
+	const namedKeys = Object.keys(mod).filter((key) => key !== "default" && key !== "plugin");
+	const preferredKeys = namedKeys.filter((key) => /plugin$/i.test(key) || /^plugin/i.test(key));
+	const fallbackKeys = namedKeys.filter((key) => !preferredKeys.includes(key));
+	for (const key of [...preferredKeys, ...fallbackKeys]) {
+		const value = mod[key];
+		if (looksLikePlugin(value)) return value;
+	}
+	for (const key of preferredKeys) {
+		const value = mod[key];
+		if (looksLikePluginBasic(value)) return value;
+	}
+	if (looksLikePluginBasic(mod)) return mod;
+	if (looksLikePluginBasic(mod.default)) return mod.default;
+	if (looksLikePluginBasic(mod.plugin)) return mod.plugin;
+	return null;
+}
+/**
+* Collect the set of plugin package names that should be loaded
+* based on config, environment variables, and feature flags.
+*/
+/** @internal Exported for testing. */
+function collectPluginNames(config) {
+	const shellPluginDisabled = config.features?.shellEnabled === false;
+	const cloudMode = config.cloud?.enabled;
+	const cloudHasApiKey = Boolean(config.cloud?.apiKey);
+	const cloudExplicitlyDisabled = cloudMode === false;
+	const cloudEffectivelyEnabled = cloudMode === true || !cloudExplicitlyDisabled && cloudHasApiKey;
+	const configEnv = config.env;
+	const configPiAiFlag = (configEnv?.vars && typeof configEnv.vars === "object" && !Array.isArray(configEnv.vars) ? configEnv.vars.MILAIDY_USE_PI_AI : void 0) ?? configEnv?.MILAIDY_USE_PI_AI;
+	const piAiEnabled = isPiAiEnabledFromEnv(process.env) || typeof configPiAiFlag === "string" && isPiAiEnabledFromEnv({ MILAIDY_USE_PI_AI: configPiAiFlag });
+	const pluginEntries = config.plugins?.entries;
+	const isPluginExplicitlyDisabled = (pluginPackageName) => {
+		const markerIndex = pluginPackageName.lastIndexOf("/plugin-");
+		const pluginId = markerIndex >= 0 ? pluginPackageName.slice(markerIndex + 8) : pluginPackageName;
+		return pluginEntries?.[pluginId]?.enabled === false;
+	};
+	const providerPluginIdSet = new Set(Object.values(PROVIDER_PLUGIN_MAP).map((pluginPackageName) => {
+		const markerIndex = pluginPackageName.lastIndexOf("/plugin-");
+		return markerIndex >= 0 ? pluginPackageName.slice(markerIndex + 8) : pluginPackageName;
+	}));
+	const hasExplicitEnabledProvider = Object.entries(pluginEntries ?? {}).filter(([pluginId]) => providerPluginIdSet.has(pluginId)).some(([, entry]) => entry?.enabled === true);
+	const allowList = config.plugins?.allow;
+	const pluginsToLoad = new Set(CORE_PLUGINS);
+	if (allowList && allowList.length > 0) for (const item of allowList) {
+		const pluginName = CHANNEL_PLUGIN_MAP[item] ?? OPTIONAL_PLUGIN_MAP[item] ?? item;
+		pluginsToLoad.add(pluginName);
+	}
+	const connectors = config.connectors ?? config.channels ?? {};
+	for (const [channelName, channelConfig] of Object.entries(connectors)) 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 (envKey === "MILAIDY_USE_PI_AI") continue;
+		if (cloudExplicitlyDisabled && (envKey === "ELIZAOS_CLOUD_API_KEY" || envKey === "ELIZAOS_CLOUD_ENABLED")) continue;
+		if (isPluginExplicitlyDisabled(pluginName)) continue;
+		if (hasExplicitEnabledProvider) {
+			const markerIndex = pluginName.lastIndexOf("/plugin-");
+			const pluginId = markerIndex >= 0 ? pluginName.slice(markerIndex + 8) : pluginName;
+			if (pluginEntries?.[pluginId]?.enabled !== true) continue;
+		}
+		if (process.env[envKey]?.trim()) pluginsToLoad.add(pluginName);
+	}
+	const shouldEnablePiAi = piAiEnabled && pluginEntries?.["pi-ai"]?.enabled !== false;
+	const applyProviderPrecedence = () => {
+		if (cloudEffectivelyEnabled) {
+			pluginsToLoad.add("@elizaos/plugin-elizacloud");
+			const directProviders = new Set(Object.values(PROVIDER_PLUGIN_MAP));
+			directProviders.delete("@elizaos/plugin-elizacloud");
+			for (const p of directProviders) pluginsToLoad.delete(p);
+			return;
+		}
+		if (shouldEnablePiAi) {
+			pluginsToLoad.add(PI_AI_PLUGIN_PACKAGE);
+			const directProviders = new Set(Object.values(PROVIDER_PLUGIN_MAP));
+			directProviders.delete(PI_AI_PLUGIN_PACKAGE);
+			for (const p of directProviders) pluginsToLoad.delete(p);
+			pluginsToLoad.delete("@elizaos/plugin-elizacloud");
+			return;
+		}
+		if (cloudExplicitlyDisabled) pluginsToLoad.delete("@elizaos/plugin-elizacloud");
+	};
+	applyProviderPrecedence();
+	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 = CHANNEL_PLUGIN_MAP[key] ?? OPTIONAL_PLUGIN_MAP[key] ?? (key.includes("/") ? key : `@elizaos/plugin-${key}`);
+			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);
+		}
+	}
+	if (config.x402?.enabled) pluginsToLoad.add("@elizaos/plugin-x402");
+	const installs = config.plugins?.installs;
+	if (installs && typeof installs === "object") {
+		for (const [packageName, record] of Object.entries(installs)) if (record && typeof record === "object") pluginsToLoad.add(packageName);
+	}
+	applyProviderPrecedence();
+	if (shellPluginDisabled) pluginsToLoad.delete("@elizaos/plugin-shell");
+	if (isPluginExplicitlyDisabled("@milaidy/plugin-coding-agent")) pluginsToLoad.delete("@milaidy/plugin-coding-agent");
+	return pluginsToLoad;
+}
+/** Subdirectory under the Milady state dir for drop-in custom plugins. */
+const CUSTOM_PLUGINS_DIRNAME = "plugins/custom";
+/** Subdirectory under the Milady state dir for ejected plugins. */
+const EJECTED_PLUGINS_DIRNAME = "plugins/ejected";
+/**
+* Scan a directory for drop-in plugin packages. Each immediate subdirectory
+* is treated as a plugin; name comes from package.json or the directory name.
+*/
+async function scanDropInPlugins(dir) {
+	const records = {};
+	let entries;
+	try {
+		entries = await fs$1.readdir(dir, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT") return records;
+		throw err;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const pluginDir = path.join(dir, entry.name);
+		let pluginName = entry.name;
+		let version = "0.0.0";
+		try {
+			const raw = await fs$1.readFile(path.join(pluginDir, "package.json"), "utf-8");
+			const pkg = JSON.parse(raw);
+			if (typeof pkg.name === "string" && pkg.name.trim()) pluginName = pkg.name.trim();
+			if (typeof pkg.version === "string" && pkg.version.trim()) version = pkg.version.trim();
+		} catch (err) {
+			if (err.code !== "ENOENT" && !(err instanceof SyntaxError)) throw err;
+		}
+		records[pluginName] = {
+			source: "path",
+			installPath: pluginDir,
+			version
+		};
+	}
+	return records;
+}
+/**
+* Merge drop-in plugins into the load set. Filters out denied, core-colliding,
+* and already-installed names. Mutates `pluginsToLoad` and `installRecords`.
+*/
+function mergeDropInPlugins(params) {
+	const { dropInRecords, installRecords, corePluginNames, denyList, pluginsToLoad } = params;
+	const accepted = [];
+	const skipped = [];
+	for (const [name, record] of Object.entries(dropInRecords)) {
+		if (denyList.has(name) || installRecords[name]) continue;
+		if (corePluginNames.has(name)) {
+			skipped.push(`[milady] Custom plugin "${name}" collides with core plugin — skipping`);
+			continue;
+		}
+		pluginsToLoad.add(name);
+		installRecords[name] = record;
+		accepted.push(name);
+	}
+	return {
+		accepted,
+		skipped
+	};
+}
+const WORKSPACE_PLUGIN_OVERRIDES = /* @__PURE__ */ new Set([]);
+function getWorkspacePluginOverridePath(pluginName) {
+	if (process.env.MILADY_DISABLE_WORKSPACE_PLUGIN_OVERRIDES === "1") return null;
+	if (!WORKSPACE_PLUGIN_OVERRIDES.has(pluginName)) return null;
+	const pluginSegment = pluginName.match(/^@[^/]+\/(plugin-[^/]+)$/)?.[1];
+	if (!pluginSegment) return null;
+	const thisDir = path.dirname(fileURLToPath(import.meta.url));
+	const miladyRoot = path.resolve(thisDir, "..", "..");
+	const workspaceRoot = path.resolve(miladyRoot, "..");
+	const candidates = [
+		path.join(miladyRoot, "plugins", pluginSegment, "typescript"),
+		path.join(workspaceRoot, "plugins", pluginSegment, "typescript"),
+		path.join(miladyRoot, "plugins", pluginSegment),
+		path.join(workspaceRoot, "plugins", pluginSegment),
+		path.join(miladyRoot, "packages", pluginSegment),
+		path.join(workspaceRoot, "packages", pluginSegment)
+	];
+	for (const candidate of candidates) if (existsSync(path.join(candidate, "package.json"))) return candidate;
+	return null;
+}
+/**
+* The `@elizaos/plugin-browser` npm package expects a `dist/server/` directory
+* containing the compiled stagehand-server, but the npm publish doesn't include
+* it.  The actual source/build lives in the workspace at
+* `plugins/plugin-browser/stagehand-server/`.
+*
+* This function checks whether the server is reachable from the installed
+* package and, if not, creates a symlink so the plugin's process-manager can
+* find it.  Returns `true` when the server index.js is available (or was made
+* available via symlink), `false` otherwise.
+*/
+/**
+* Returns true if the given env var key is safe to forward to runtime.settings.
+* Blocks blockchain private keys, secrets, passwords, tokens, credentials,
+* mnemonics, and seed phrases while allowing API keys that plugins need.
+*/
+function isEnvKeyAllowedForForwarding(key) {
+	const upper = key.toUpperCase();
+	if (upper.includes("PRIVATE_KEY")) return false;
+	if (upper.startsWith("EVM_") || upper.startsWith("SOLANA_")) return false;
+	if (/(SECRET|PASSWORD|CREDENTIAL|MNEMONIC|SEED_PHRASE)/i.test(key)) return false;
+	if (/(ACCESS_TOKEN|REFRESH_TOKEN|SESSION_TOKEN|AUTH_TOKEN)$/i.test(key)) return false;
+	return true;
+}
+function ensureBrowserServerLink() {
+	try {
+		const pkgJsonPath = createRequire(import.meta.url).resolve("@elizaos/plugin-browser/package.json");
+		const pluginRoot = path.dirname(pkgJsonPath);
+		const serverDir = path.join(pluginRoot, "dist", "server");
+		if (existsSync(path.join(serverDir, "dist", "index"))) return true;
+		const thisDir = path.dirname(fileURLToPath(import.meta.url));
+		const miladyRoot = path.resolve(thisDir, "..", "..");
+		const workspaceRoot = path.resolve(miladyRoot, "..");
+		const stagehandDir = path.join(workspaceRoot, "plugins", "plugin-browser", "stagehand-server");
+		if (!existsSync(path.join(stagehandDir, "dist", "index"))) {
+			logger.info(`[milady] Browser server not found at ${stagehandDir} — @elizaos/plugin-browser will not be loaded`);
+			return false;
+		}
+		symlinkSync(stagehandDir, serverDir, "dir");
+		logger.info(`[milady] Linked browser server: ${serverDir} -> ${stagehandDir}`);
+		return true;
+	} catch (err) {
+		logger.debug(`[milady] Could not link browser server: ${formatError(err)}`);
+		return false;
+	}
+}
+/**
+* Resolve Milady plugins from config and auto-enable logic.
+* Returns an array of ElizaOS Plugin instances ready for AgentRuntime.
+*
+* Handles three categories of plugins:
+* 1. Built-in/npm plugins — imported by package name
+* 2. User-installed plugins — from ~/.milady/plugins/installed/
+* 3. Custom/drop-in plugins — from ~/.milady/plugins/custom/ and plugins.load.paths
+*
+* Each plugin is loaded inside an error boundary so a single failing plugin
+* cannot crash the entire agent startup.
+*/
+async function resolvePlugins(config, opts) {
+	const plugins = [];
+	const failedPlugins = [];
+	const repairedInstallRecords = /* @__PURE__ */ new Set();
+	applyPluginAutoEnable({
+		config,
+		env: process.env
+	});
+	const pluginsToLoad = collectPluginNames(config);
+	const corePluginSet = new Set(CORE_PLUGINS);
+	const installRecords = { ...config.plugins?.installs ?? {} };
+	const denyList = new Set(config.plugins?.deny ?? []);
+	const ejectedRecords = await scanDropInPlugins(path.join(resolveStateDir(), EJECTED_PLUGINS_DIRNAME));
+	const ejectedPluginNames = [];
+	for (const [name, _record] of Object.entries(ejectedRecords)) {
+		if (denyList.has(name)) continue;
+		pluginsToLoad.add(name);
+		ejectedPluginNames.push(name);
+	}
+	if (ejectedPluginNames.length > 0) logger.info(`[milady] Discovered ${ejectedPluginNames.length} ejected plugin(s): ${ejectedPluginNames.join(", ")}`);
+	const scanDirs = [path.join(resolveStateDir(), CUSTOM_PLUGINS_DIRNAME), ...(config.plugins?.load?.paths ?? []).map(resolveUserPath)];
+	const dropInRecords = {};
+	for (const dir of scanDirs) for (const [name, record] of Object.entries(await scanDropInPlugins(dir))) if (!dropInRecords[name]) dropInRecords[name] = record;
+	const { accepted: customPluginNames, skipped } = mergeDropInPlugins({
+		dropInRecords,
+		installRecords,
+		corePluginNames: corePluginSet,
+		denyList,
+		pluginsToLoad
+	});
+	for (const msg of skipped) logger.warn(msg);
+	if (customPluginNames.length > 0) logger.info(`[milady] Discovered ${customPluginNames.length} custom plugin(s): ${customPluginNames.join(", ")}`);
+	logger.info(`[milady] Resolving ${pluginsToLoad.size} plugins...`);
+	const loadStartTime = Date.now();
+	async function loadSinglePlugin(pluginName) {
+		const isCore = corePluginSet.has(pluginName);
+		const ejectedRecord = ejectedRecords[pluginName];
+		const installRecord = installRecords[pluginName];
+		const workspaceOverridePath = getWorkspacePluginOverridePath(pluginName);
+		if (pluginName === "@elizaos/plugin-browser") {
+			if (!ensureBrowserServerLink()) {
+				failedPlugins.push({
+					name: pluginName,
+					error: "browser server binary not found"
+				});
+				logger.warn(`[milady] Skipping ${pluginName}: browser server not available. Build the stagehand-server or remove the plugin from plugins.allow.`);
+				return null;
+			}
+		}
+		try {
+			let mod;
+			if (ejectedRecord?.installPath) {
+				logger.debug(`[milady] Loading ejected plugin: ${pluginName} from ${ejectedRecord.installPath}`);
+				mod = await importFromPath(ejectedRecord.installPath, pluginName);
+			} else if (workspaceOverridePath) {
+				logger.debug(`[milady] Loading workspace plugin override: ${pluginName} from ${workspaceOverridePath}`);
+				mod = await importFromPath(workspaceOverridePath, pluginName);
+			} else if (installRecord?.installPath) if (pluginName.startsWith("@elizaos/plugin-")) try {
+				mod = await import(pluginName);
+				if (repairBrokenInstallRecord(config, pluginName)) repairedInstallRecords.add(pluginName);
+			} catch (npmErr) {
+				logger.warn(`[milady] Node_modules resolution failed for ${pluginName} (${formatError(npmErr)}). Trying installed path at ${installRecord.installPath}.`);
+				mod = await importFromPath(installRecord.installPath, pluginName);
+			}
+			else try {
+				mod = await importFromPath(installRecord.installPath, pluginName);
+			} catch (installErr) {
+				logger.warn(`[milady] Installed plugin ${pluginName} failed at ${installRecord.installPath} (${formatError(installErr)}). Falling back to node_modules resolution.`);
+				mod = await import(pluginName);
+				if (repairBrokenInstallRecord(config, pluginName)) repairedInstallRecords.add(pluginName);
+			}
+			else if (pluginName.startsWith("@milady/plugin-")) {
+				const shortName = pluginName.replace("@milady/plugin-", "");
+				const thisDir = path.dirname(fileURLToPath(import.meta.url));
+				const distRoot = thisDir.endsWith("runtime") ? path.resolve(thisDir, "..") : thisDir;
+				mod = await import(pathToFileURL(path.resolve(distRoot, "plugins", shortName, "index.js")).href);
+			} else mod = await import(pluginName);
+			const pluginInstance = findRuntimePluginExport(mod);
+			if (pluginInstance) {
+				const wrappedPlugin = wrapPluginWithErrorBoundary(pluginName, pluginInstance);
+				logger.debug(`[milady] ✓ Loaded plugin: ${pluginName}`);
+				return {
+					name: pluginName,
+					plugin: wrappedPlugin
+				};
+			} else {
+				const msg = `[milady] Plugin ${pluginName} did not export a valid Plugin object`;
+				failedPlugins.push({
+					name: pluginName,
+					error: "no valid Plugin export"
+				});
+				if (isCore) logger.error(msg);
+				else logger.warn(msg);
+				return null;
+			}
+		} catch (err) {
+			const msg = formatError(err);
+			failedPlugins.push({
+				name: pluginName,
+				error: msg
+			});
+			if (isCore) logger.error(`[milady] Failed to load core plugin ${pluginName}: ${msg}`);
+			else if (new Set([...Object.values(OPTIONAL_PLUGIN_MAP), ...Object.values(CHANNEL_PLUGIN_MAP)]).has(pluginName)) logger.debug(`[milady] Optional plugin ${pluginName} not available: ${msg}`);
+			else logger.info(`[milady] Could not load plugin ${pluginName}: ${msg}`);
+			return null;
+		}
+	}
+	const pluginResults = await Promise.all(Array.from(pluginsToLoad).map(loadSinglePlugin));
+	for (const result of pluginResults) if (result) plugins.push(result);
+	const loadDuration = Date.now() - loadStartTime;
+	logger.info(`[milady] Plugin loading took ${loadDuration}ms`);
+	logger.info(`[milady] Plugin resolution complete: ${plugins.length}/${pluginsToLoad.size} loaded` + (failedPlugins.length > 0 ? `, ${failedPlugins.length} failed` : ""));
+	if (failedPlugins.length > 0) logger.info(`[milady] Failed plugins: ${failedPlugins.map((f) => `${f.name} (${f.error})`).join(", ")}`);
+	const diagnostic = diagnoseNoAIProvider(plugins.map((p) => p.name), failedPlugins);
+	if (diagnostic) if (opts?.quiet) logger.info(`[milady] ${diagnostic}`);
+	else logger.error(`[milady] ${diagnostic}`);
+	if (repairedInstallRecords.size > 0) try {
+		saveMiladyConfig(config);
+		logger.info(`[milady] Repaired ${repairedInstallRecords.size} plugin install record(s): ${Array.from(repairedInstallRecords).join(", ")}`);
+	} catch (err) {
+		logger.warn(`[milady] Failed to persist plugin install repairs: ${formatError(err)}`);
+	}
+	return plugins;
+}
+/** @internal Exported for testing. */
+function repairBrokenInstallRecord(config, pluginName) {
+	const record = config.plugins?.installs?.[pluginName];
+	if (!record || typeof record.installPath !== "string") return false;
+	if (!record.installPath.trim()) return false;
+	record.installPath = "";
+	record.source = "npm";
+	return true;
+}
+/**
+* Wrap a plugin's `init` and `providers` with error boundaries so that a
+* crash in any single plugin does not take down the entire agent or GUI.
+*
+* NOTE: Actions are NOT wrapped here because ElizaOS's action dispatch
+* already has its own error boundary.  Only `init` (startup) and
+* `providers` (called every turn) need protection at this layer.
+*
+* The wrapper catches errors, logs them with the plugin name for easy
+* debugging, and continues execution.
+*/
+function wrapPluginWithErrorBoundary(pluginName, plugin) {
+	const wrapped = { ...plugin };
+	if (plugin.init) {
+		const originalInit = plugin.init;
+		wrapped.init = async (...args) => {
+			try {
+				return await originalInit(...args);
+			} catch (err) {
+				logger.error(`[milady] Plugin "${pluginName}" crashed during init: ${formatError(err)}`);
+				logger.warn(`[milady] Plugin "${pluginName}" will run in degraded mode (init failed)`);
+			}
+		};
+	}
+	if (plugin.providers && plugin.providers.length > 0) wrapped.providers = plugin.providers.map((provider) => ({
+		...provider,
+		get: async (...args) => {
+			try {
+				return await provider.get(...args);
+			} catch (err) {
+				const msg = formatError(err);
+				logger.error(`[milady] Provider "${provider.name}" (plugin: ${pluginName}) crashed: ${msg}`);
+				return {
+					text: `[Provider ${provider.name} error: ${msg}]`,
+					data: { _providerError: true }
+				};
+			}
+		}
+	}));
+	return wrapped;
+}
+/**
+* Import a plugin module from its install directory on disk.
+*
+* Handles two install layouts:
+*   1. npm layout:  <installPath>/node_modules/@scope/package/  (from `bun add`)
+*   2. git layout:  <installPath>/ is the package root directly  (from `git clone`)
+*
+* @param installPath  Root directory of the installation (e.g. ~/.milady/plugins/installed/foo/).
+* @param packageName  The npm package name (e.g. "@elizaos/plugin-discord") — used
+*                     to navigate directly into node_modules when present.
+*/
+async function importFromPath(installPath, packageName) {
+	const absPath = path.resolve(installPath);
+	const nmCandidate = path.join(absPath, "node_modules", ...packageName.split("/"));
+	let pkgRoot = absPath;
+	try {
+		if ((await fs$1.stat(nmCandidate)).isDirectory()) pkgRoot = nmCandidate;
+	} catch (err) {
+		if (err.code !== "ENOENT") throw err;
+	}
+	return await import(pathToFileURL(await resolvePackageEntry(pkgRoot)).href);
+}
+/** Read package.json exports/main to find the importable entry file. */
+/** @internal Exported for testing. */
+async function resolvePackageEntry(pkgRoot) {
+	const fallback = path.join(pkgRoot, "dist", "index");
+	const fallbackCandidates = [
+		fallback,
+		path.join(pkgRoot, "index"),
+		path.join(pkgRoot, "index.mjs"),
+		path.join(pkgRoot, "index.ts"),
+		path.join(pkgRoot, "src", "index"),
+		path.join(pkgRoot, "src", "index.mjs"),
+		path.join(pkgRoot, "src", "index.ts")
+	];
+	const chooseExisting = (...paths) => {
+		const seen = /* @__PURE__ */ new Set();
+		for (const p of paths) {
+			const resolved = path.resolve(p);
+			if (seen.has(resolved)) continue;
+			seen.add(resolved);
+			if (existsSync(resolved)) return resolved;
+		}
+		return path.resolve(paths[0] ?? fallback);
+	};
+	try {
+		const raw = await fs$1.readFile(path.join(pkgRoot, "package.json"), "utf-8");
+		const pkg = JSON.parse(raw);
+		if (typeof pkg.exports === "object" && pkg.exports["."] !== void 0) {
+			const dot = pkg.exports["."];
+			const resolved = typeof dot === "string" ? dot : dot.import || dot.default;
+			if (typeof resolved === "string") return chooseExisting(path.resolve(pkgRoot, resolved), ...fallbackCandidates);
+		}
+		if (typeof pkg.exports === "string") return chooseExisting(path.resolve(pkgRoot, pkg.exports), ...fallbackCandidates);
+		if (pkg.main) return chooseExisting(path.resolve(pkgRoot, pkg.main), ...fallbackCandidates);
+		return chooseExisting(...fallbackCandidates);
+	} catch (err) {
+		if (err.code === "ENOENT") return chooseExisting(...fallbackCandidates);
+		throw err;
+	}
+}
+/**
+* Propagate channel credentials from Milady config into process.env so
+* that ElizaOS plugins can find them.
+*/
+/** @internal Exported for testing. */
+function applyConnectorSecretsToEnv(config) {
+	const connectors = config.connectors ?? config.channels ?? {};
+	for (const [channelName, channelConfig] of Object.entries(connectors)) {
+		if (!channelConfig || typeof channelConfig !== "object") continue;
+		const configObj = channelConfig;
+		if (channelName === "discord") {
+			const tokenValue = typeof configObj.token === "string" && configObj.token.trim() || typeof configObj.botToken === "string" && configObj.botToken.trim() || "";
+			if (tokenValue) {
+				if (!process.env.DISCORD_API_TOKEN) process.env.DISCORD_API_TOKEN = tokenValue;
+				if (!process.env.DISCORD_BOT_TOKEN) process.env.DISCORD_BOT_TOKEN = tokenValue;
+			}
+		}
+		const envMap = CHANNEL_ENV_MAP[channelName];
+		if (!envMap) continue;
+		for (const [configField, envKey] of Object.entries(envMap)) {
+			const value = configObj[configField];
+			if (typeof value === "string" && value.trim() && !process.env[envKey]) process.env[envKey] = value;
+		}
+	}
+}
+/**
+* Auto-resolve Discord Application ID from the bot token via Discord API.
+* Called during async runtime init so that users only need a bot token.
+*/
+/** @internal Exported for testing. */
+async function autoResolveDiscordAppId() {
+	if (process.env.DISCORD_APPLICATION_ID) return;
+	const discordToken = process.env.DISCORD_API_TOKEN || process.env.DISCORD_BOT_TOKEN;
+	if (!discordToken) return;
+	try {
+		const res = await fetch("https://discord.com/api/v10/oauth2/applications/@me", { headers: { Authorization: `Bot ${discordToken}` } });
+		if (!res.ok) {
+			logger.warn(`[milady] Failed to auto-resolve Discord Application ID: ${res.status}`);
+			return;
+		}
+		const app = await res.json();
+		if (!app.id) return;
+		process.env.DISCORD_APPLICATION_ID = app.id;
+		logger.info(`[milady] Auto-resolved Discord Application ID: ${app.id}`);
+	} catch (err) {
+		logger.warn(`[milady] Could not auto-resolve Discord Application ID: ${err}`);
+	}
+}
+/**
+* Propagate cloud config from Milady config into process.env so the
+* ElizaCloud plugin can discover settings at startup.
+*/
+/** @internal Exported for testing. */
+function applyCloudConfigToEnv(config) {
+	const cloud = config.cloud;
+	if (!cloud) return;
+	const cloudMode = cloud.enabled;
+	const hasApiKey = Boolean(cloud.apiKey);
+	const effectivelyEnabled = cloudMode === true || !(cloudMode === false) && hasApiKey;
+	if (effectivelyEnabled) {
+		process.env.ELIZAOS_CLOUD_ENABLED = "true";
+		logger.info(`[milady] Cloud config: enabled=${cloud.enabled}, hasApiKey=${Boolean(cloud.apiKey)}, baseUrl=${cloud.baseUrl ?? "(default)"}`);
+	} else {
+		delete process.env.ELIZAOS_CLOUD_ENABLED;
+		delete process.env.ELIZAOS_CLOUD_SMALL_MODEL;
+		delete process.env.ELIZAOS_CLOUD_LARGE_MODEL;
+	}
+	if (cloud.apiKey) process.env.ELIZAOS_CLOUD_API_KEY = cloud.apiKey;
+	else delete process.env.ELIZAOS_CLOUD_API_KEY;
+	if (cloud.baseUrl) process.env.ELIZAOS_CLOUD_BASE_URL = cloud.baseUrl;
+	else delete process.env.ELIZAOS_CLOUD_BASE_URL;
+	const models = config.models;
+	if (effectivelyEnabled) {
+		const small = models?.small || "openai/gpt-5-mini";
+		const large = models?.large || "anthropic/claude-sonnet-4.5";
+		process.env.SMALL_MODEL = small;
+		process.env.LARGE_MODEL = large;
+		process.env.ELIZAOS_CLOUD_SMALL_MODEL = small;
+		process.env.ELIZAOS_CLOUD_LARGE_MODEL = large;
+	}
+}
+/**
+* Translate `config.database` into the environment variables that
+* `@elizaos/plugin-sql` reads at init time (`POSTGRES_URL`, `PGLITE_DATA_DIR`).
+*
+* When the provider is "postgres", we build a connection string from the
+* credentials (or use the explicit `connectionString` field) and set
+* `POSTGRES_URL`. When the provider is "pglite" (the default), we set
+* `PGLITE_DATA_DIR` to either the configured value or a stable workspace
+* default (`~/.milady/workspace/.eliza/.elizadb`) and remove any stale
+* `POSTGRES_URL`.
+*/
+/** @internal Exported for testing. */
+function applyX402ConfigToEnv(config) {
+	const x402 = config.x402;
+	if (!x402?.enabled) return;
+	if (!process.env.X402_ENABLED) process.env.X402_ENABLED = "true";
+	if (x402.apiKey && !process.env.X402_API_KEY) process.env.X402_API_KEY = x402.apiKey;
+	if (x402.baseUrl && !process.env.X402_BASE_URL) process.env.X402_BASE_URL = x402.baseUrl;
+}
+function resolveDefaultPgliteDataDir(config) {
+	const workspaceDir = config.agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
+	return path.join(resolveUserPath(workspaceDir), ".eliza", ".elizadb");
+}
+/** @internal Exported for testing. */
+function applyDatabaseConfigToEnv(config) {
+	const db = config.database;
+	if ((db?.provider ?? "pglite") === "postgres" && db?.postgres) {
+		const pg = db.postgres;
+		let url = pg.connectionString;
+		if (!url) {
+			const host = pg.host ?? "localhost";
+			const port = pg.port ?? 5432;
+			const user = encodeURIComponent(pg.user ?? "postgres");
+			const password = pg.password ? encodeURIComponent(pg.password) : "";
+			const database = pg.database ?? "postgres";
+			url = `postgresql://${password ? `${user}:${password}` : user}@${host}:${port}/${database}${pg.ssl ? "?sslmode=require" : ""}`;
+		}
+		process.env.POSTGRES_URL = url;
+		delete process.env.PGLITE_DATA_DIR;
+	} else {
+		delete process.env.POSTGRES_URL;
+		const configuredDataDir = db?.pglite?.dataDir?.trim();
+		if (configuredDataDir) process.env.PGLITE_DATA_DIR = resolveUserPath(configuredDataDir);
+		if (!process.env.PGLITE_DATA_DIR?.trim()) process.env.PGLITE_DATA_DIR = resolveDefaultPgliteDataDir(config);
+		const dataDir = process.env.PGLITE_DATA_DIR;
+		if (dataDir) {
+			const alreadyExisted = existsSync(dataDir);
+			mkdirSync(dataDir, { recursive: true });
+			logger.info(`[milady] PGlite data dir: ${dataDir} (${alreadyExisted ? "existed" : "created"})`);
+		}
+	}
+}
+function collectErrorMessages(err) {
+	const messages = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = err;
+	while (current && !seen.has(current)) {
+		seen.add(current);
+		if (typeof current === "string") {
+			messages.push(current);
+			break;
+		}
+		if (current instanceof Error) {
+			if (current.message) messages.push(current.message);
+			if (current.stack) messages.push(current.stack);
+			current = current.cause;
+			continue;
+		}
+		if (typeof current === "object") {
+			const maybeErr = current;
+			if (typeof maybeErr.message === "string" && maybeErr.message) messages.push(maybeErr.message);
+			if (maybeErr.cause !== void 0) {
+				current = maybeErr.cause;
+				continue;
+			}
+		}
+		break;
+	}
+	return messages;
+}
+/** @internal Exported for testing. */
+function isRecoverablePgliteInitError(err) {
+	const haystack = collectErrorMessages(err).join("\n").toLowerCase();
+	if (!haystack) return false;
+	const hasAbort = haystack.includes("aborted(). build with -sassertions");
+	const hasPglite = haystack.includes("pglite");
+	const hasSqlite = haystack.includes("sqlite");
+	const hasMigrationsSchema = haystack.includes("create schema if not exists migrations") || haystack.includes("failed query: create schema if not exists migrations");
+	const hasRecoverableStorageSignal = [
+		"database disk image is malformed",
+		"file is not a database",
+		"malformed database schema",
+		"database is locked",
+		"lock file already exists",
+		"wal file",
+		"checkpoint failed",
+		"checksum mismatch",
+		"corrupt"
+	].some((needle) => haystack.includes(needle));
+	if (hasMigrationsSchema) return true;
+	if (hasAbort && hasPglite) return true;
+	if (hasRecoverableStorageSignal && (hasPglite || hasSqlite)) return true;
+	return false;
+}
+function resolveActivePgliteDataDir(config) {
+	if ((config.database?.provider ?? "pglite") === "postgres") return null;
+	return resolveUserPath(process.env.PGLITE_DATA_DIR?.trim() || resolveDefaultPgliteDataDir(config));
+}
+async function resetPgliteDataDir(dataDir) {
+	const normalized = path.resolve(dataDir);
+	if (normalized === path.parse(normalized).root) throw new Error(`Refusing to reset unsafe PGLite path: ${normalized}`);
+	const backupDir = `${normalized}.corrupt-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..*$/, "").replace("T", "-")}`;
+	if (existsSync(normalized)) try {
+		await fs$1.rename(normalized, backupDir);
+		logger.warn(`[milady] Backed up existing PGLite data dir to ${backupDir}`);
+	} catch (err) {
+		logger.warn(`[milady] Failed to back up PGLite data dir (${formatError(err)}); deleting ${normalized} instead`);
+		await fs$1.rm(normalized, {
+			recursive: true,
+			force: true
+		});
+	}
+	await fs$1.mkdir(normalized, { recursive: true });
+}
+async function initializeDatabaseAdapter(runtime, config) {
+	if (!runtime.adapter || await runtime.adapter.isReady()) return;
+	try {
+		await runtime.adapter.init();
+		logger.info("[milady] Database adapter initialized early (before plugin inits)");
+	} catch (err) {
+		const pgliteDataDir = resolveActivePgliteDataDir(config);
+		if (!pgliteDataDir || !isRecoverablePgliteInitError(err)) throw err;
+		logger.warn(`[milady] PGLite init failed (${formatError(err)}). Resetting local DB at ${pgliteDataDir} and retrying once.`);
+		await resetPgliteDataDir(pgliteDataDir);
+		process.env.PGLITE_DATA_DIR = pgliteDataDir;
+		await runtime.adapter.init();
+		logger.info("[milady] Database adapter recovered after resetting PGLite data");
+	}
+	await verifyPgliteDataDir(config);
+}
+/**
+* Verify PGlite data directory contains files after init.
+* Warns if the directory is empty (suggests ephemeral/in-memory fallback).
+*/
+async function verifyPgliteDataDir(config) {
+	const pgliteDataDir = resolveActivePgliteDataDir(config);
+	if (!pgliteDataDir || !existsSync(pgliteDataDir)) return;
+	try {
+		const files = await fs$1.readdir(pgliteDataDir);
+		logger.info(`[milady] PGlite health check: ${files.length} file(s) in ${pgliteDataDir}`);
+		if (files.length === 0) logger.warn(`[milady] PGlite data directory is empty after init — data may not persist across restarts`);
+	} catch (err) {
+		logger.warn(`[milady] PGlite health check failed: ${formatError(err)}`);
+	}
+}
+function isPluginAlreadyRegisteredError(err) {
+	return formatError(err).toLowerCase().includes("already registered");
+}
+function installRuntimeMethodBindings(runtime) {
+	const runtimeWithBindings = runtime;
+	if (runtimeWithBindings.__miladyMethodBindingsInstalled) return;
+	runtime.getConversationLength = runtime.getConversationLength.bind(runtime);
+	const GETSETTING_ENV_ALLOWLIST = new Set([
+		"ANTHROPIC_API_KEY",
+		"OPENAI_API_KEY",
+		"GOOGLE_GENERATIVE_AI_API_KEY",
+		"GOOGLE_API_KEY",
+		"GEMINI_API_KEY",
+		"GROQ_API_KEY",
+		"XAI_API_KEY",
+		"DEEPSEEK_API_KEY",
+		"OPENROUTER_API_KEY",
+		"GOOGLE_SMALL_MODEL",
+		"GOOGLE_LARGE_MODEL",
+		"GITHUB_TOKEN",
+		"GITHUB_OAUTH_CLIENT_ID",
+		"PARALLAX_CLAUDE_MODEL_POWERFUL",
+		"PARALLAX_CLAUDE_MODEL_FAST",
+		"PARALLAX_GEMINI_MODEL_POWERFUL",
+		"PARALLAX_GEMINI_MODEL_FAST",
+		"PARALLAX_CODEX_MODEL_POWERFUL",
+		"PARALLAX_CODEX_MODEL_FAST",
+		"PARALLAX_AIDER_PROVIDER",
+		"PARALLAX_AIDER_MODEL_POWERFUL",
+		"PARALLAX_AIDER_MODEL_FAST",
+		"CUSTOM_CREDENTIAL_KEYS"
+	]);
+	const originalGetSetting = runtime.getSetting.bind(runtime);
+	runtime.getSetting = (key) => {
+		const result = originalGetSetting(key);
+		if (result !== null && result !== void 0) return result;
+		if (GETSETTING_ENV_ALLOWLIST.has(key)) {
+			const envVal = process.env[key];
+			if (envVal !== void 0 && envVal.trim() !== "") return envVal;
+		}
+		return result;
+	};
+	runtimeWithBindings.__miladyMethodBindingsInstalled = true;
+}
+function installActionAliases(runtime) {
+	const runtimeWithAliases = runtime;
+	if (runtimeWithAliases.__miladyActionAliasesInstalled) return;
+	const actions = Array.isArray(runtimeWithAliases.actions) ? runtimeWithAliases.actions : [];
+	const compactSessionIndex = actions.findIndex((action) => action?.name?.toUpperCase() === "COMPACT_SESSION");
+	if (compactSessionIndex !== -1) {
+		actions.splice(compactSessionIndex, 1);
+		logger.info("[milady] Disabled manual COMPACT_SESSION action; auto-compaction remains enabled");
+	}
+	const createTaskAction = actions.find((action) => action?.name?.toUpperCase() === "CREATE_TASK");
+	if (createTaskAction) {
+		const similes = Array.isArray(createTaskAction.similes) ? createTaskAction.similes : [];
+		if (!similes.some((simile) => simile.toUpperCase() === "CODE_TASK")) {
+			createTaskAction.similes = [...similes, "CODE_TASK"];
+			logger.info("[milady] Added action alias CODE_TASK -> CREATE_TASK for agent-orchestrator");
+		}
+	}
+	runtimeWithAliases.__miladyActionAliasesInstalled = true;
+}
+async function registerSqlPluginWithRecovery(runtime, sqlPlugin, config) {
+	let registerError = null;
+	try {
+		await runtime.registerPlugin(sqlPlugin.plugin);
+	} catch (err) {
+		registerError = err;
+	}
+	if (registerError) {
+		const pgliteDataDir = resolveActivePgliteDataDir(config);
+		if (!pgliteDataDir || !isRecoverablePgliteInitError(registerError)) throw registerError;
+		logger.warn(`[milady] SQL plugin registration failed (${formatError(registerError)}). Resetting local PGLite DB at ${pgliteDataDir} and retrying once.`);
+		await resetPgliteDataDir(pgliteDataDir);
+		process.env.PGLITE_DATA_DIR = pgliteDataDir;
+		try {
+			await runtime.registerPlugin(sqlPlugin.plugin);
+		} catch (retryErr) {
+			if (!isPluginAlreadyRegisteredError(retryErr)) throw retryErr;
+		}
+	}
+	await initializeDatabaseAdapter(runtime, config);
+}
+/**
+* Build an ElizaOS Character from the Milady config.
+*
+* Resolves the agent name from `config.agents.list` (first entry) or
+* `config.ui.assistant.name`, falling back to "Milady".  Character
+* personality data (bio, system prompt, style, etc.) is stored in the
+* database — not the config file — so we only provide sensible defaults
+* here for the initial bootstrap.
+*/
+/** @internal Exported for testing. */
+function buildCharacterFromConfig(config) {
+	const agentEntry = config.agents?.list?.[0];
+	const name = agentEntry?.name ?? config.ui?.assistant?.name ?? "Milady";
+	const bio = agentEntry?.bio ?? ["{{name}} is an AI assistant powered by Milady and ElizaOS."];
+	const systemPrompt = agentEntry?.system ?? "You are {{name}}, an autonomous AI agent powered by ElizaOS.";
+	const style = agentEntry?.style;
+	const adjectives = agentEntry?.adjectives;
+	const topics = agentEntry?.topics;
+	const postExamples = agentEntry?.postExamples;
+	const messageExamples = agentEntry?.messageExamples;
+	const secretKeys = [
+		"ANTHROPIC_API_KEY",
+		"OPENAI_API_KEY",
+		"GEMINI_API_KEY",
+		"GOOGLE_API_KEY",
+		"GOOGLE_GENERATIVE_AI_API_KEY",
+		"GROQ_API_KEY",
+		"XAI_API_KEY",
+		"OPENROUTER_API_KEY",
+		"AI_GATEWAY_API_KEY",
+		"AIGATEWAY_API_KEY",
+		"AI_GATEWAY_BASE_URL",
+		"AI_GATEWAY_SMALL_MODEL",
+		"AI_GATEWAY_LARGE_MODEL",
+		"AI_GATEWAY_EMBEDDING_MODEL",
+		"AI_GATEWAY_EMBEDDING_DIMENSIONS",
+		"AI_GATEWAY_IMAGE_MODEL",
+		"AI_GATEWAY_TIMEOUT_MS",
+		"OLLAMA_BASE_URL",
+		"DISCORD_API_TOKEN",
+		"DISCORD_APPLICATION_ID",
+		"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",
+		"ELIZAOS_CLOUD_API_KEY",
+		"ELIZAOS_CLOUD_BASE_URL",
+		"ELIZAOS_CLOUD_ENABLED",
+		"EVM_PRIVATE_KEY",
+		"SOLANA_PRIVATE_KEY",
+		"ALCHEMY_API_KEY",
+		"HELIUS_API_KEY",
+		"BIRDEYE_API_KEY",
+		"SOLANA_RPC_URL",
+		"X402_PRIVATE_KEY",
+		"X402_NETWORK",
+		"X402_PAY_TO",
+		"X402_FACILITATOR_URL",
+		"X402_MAX_PAYMENT_USD",
+		"X402_MAX_TOTAL_USD",
+		"X402_ENABLED",
+		"X402_DB_PATH",
+		"GITHUB_TOKEN",
+		"GITHUB_OAUTH_CLIENT_ID"
+	];
+	const secrets = {};
+	for (const key of secretKeys) {
+		const value = process.env[key];
+		if (value?.trim()) secrets[key] = value;
+	}
+	const mappedExamples = messageExamples?.map((convo) => convo.map((msg) => ({
+		...msg,
+		name: msg.user
+	})));
+	return mergeCharacterDefaults({
+		name,
+		bio,
+		system: systemPrompt,
+		...style ? { style } : {},
+		...adjectives ? { adjectives } : {},
+		...topics ? { topics } : {},
+		...postExamples ? { postExamples } : {},
+		...mappedExamples ? { messageExamples: mappedExamples } : {},
+		secrets
+	});
+}
+/**
+* Resolve the primary model identifier from Milady config.
+*
+* Milady 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).
+*/
+/** @internal Exported for testing. */
+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 run the onboarding flow:
+*
+*   1. Welcome banner
+*   2. Name selector (4 random + Custom)
+*   3. Catchphrase / writing-style selector
+*   4. Persist agent name to `agents.list[0]` in config
+*
+* Character personality (bio, system prompt, style) is stored in the
+* database at runtime — only the agent name lives in config.
+*
+* Subsequent runs skip this entirely.
+*/
+async function runFirstTimeSetup(config) {
+	const agentEntry = config.agents?.list?.[0];
+	if (Boolean(agentEntry?.name || config.ui?.assistant?.name)) return config;
+	if (!process.stdin.isTTY) return config;
+	clack.intro("WELCOME TO MILADY!");
+	const randomNames = pickRandomNames(4);
+	const nameChoice = await clack.select({
+		message: "♡♡milady♡♡: Hey there, I'm.... err, what was my name again?",
+		options: [...randomNames.map((n) => ({
+			value: n,
+			label: n
+		})), {
+			value: "_custom_",
+			label: "Custom...",
+			hint: "type your own"
+		}]
+	});
+	if (clack.isCancel(nameChoice)) cancelOnboarding();
+	let name;
+	if (nameChoice === "_custom_") {
+		const customName = await clack.text({
+			message: "OK, what should I be called?",
+			placeholder: "Milady"
+		});
+		if (clack.isCancel(customName)) cancelOnboarding();
+		name = customName.trim() || "Milady";
+	} else name = nameChoice;
+	clack.log.message(`♡♡${name}♡♡: Oh that's right, I'm ${name}!`);
+	const styleChoice = await clack.select({
+		message: `${name}: Now... how do I like to talk again?`,
+		options: STYLE_PRESETS.map((preset) => ({
+			value: preset.catchphrase,
+			label: preset.catchphrase,
+			hint: preset.hint
+		}))
+	});
+	if (clack.isCancel(styleChoice)) cancelOnboarding();
+	const chosenTemplate = STYLE_PRESETS.find((p) => p.catchphrase === styleChoice);
+	const PROVIDER_OPTIONS = [
+		{
+			id: "anthropic",
+			label: "Anthropic (Claude)",
+			envKey: "ANTHROPIC_API_KEY",
+			detectKeys: ["ANTHROPIC_API_KEY"],
+			hint: "sk-ant-..."
+		},
+		{
+			id: "openai",
+			label: "OpenAI (GPT)",
+			envKey: "OPENAI_API_KEY",
+			detectKeys: ["OPENAI_API_KEY"],
+			hint: "sk-..."
+		},
+		{
+			id: "openrouter",
+			label: "OpenRouter",
+			envKey: "OPENROUTER_API_KEY",
+			detectKeys: ["OPENROUTER_API_KEY"],
+			hint: "sk-or-..."
+		},
+		{
+			id: "vercel-ai-gateway",
+			label: "Vercel AI Gateway",
+			envKey: "AI_GATEWAY_API_KEY",
+			detectKeys: ["AI_GATEWAY_API_KEY", "AIGATEWAY_API_KEY"],
+			hint: "aigw_..."
+		},
+		{
+			id: "gemini",
+			label: "Google Gemini",
+			envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+			detectKeys: [
+				"GOOGLE_GENERATIVE_AI_API_KEY",
+				"GOOGLE_API_KEY",
+				"GEMINI_API_KEY"
+			],
+			hint: "AI..."
+		},
+		{
+			id: "grok",
+			label: "xAI (Grok)",
+			envKey: "XAI_API_KEY",
+			detectKeys: ["XAI_API_KEY"],
+			hint: "xai-..."
+		},
+		{
+			id: "groq",
+			label: "Groq",
+			envKey: "GROQ_API_KEY",
+			detectKeys: ["GROQ_API_KEY"],
+			hint: "gsk_..."
+		},
+		{
+			id: "deepseek",
+			label: "DeepSeek",
+			envKey: "DEEPSEEK_API_KEY",
+			detectKeys: ["DEEPSEEK_API_KEY"],
+			hint: "sk-..."
+		},
+		{
+			id: "mistral",
+			label: "Mistral",
+			envKey: "MISTRAL_API_KEY",
+			detectKeys: ["MISTRAL_API_KEY"],
+			hint: ""
+		},
+		{
+			id: "together",
+			label: "Together AI",
+			envKey: "TOGETHER_API_KEY",
+			detectKeys: ["TOGETHER_API_KEY"],
+			hint: ""
+		},
+		{
+			id: "ollama",
+			label: "Ollama (local, free)",
+			envKey: "OLLAMA_BASE_URL",
+			detectKeys: ["OLLAMA_BASE_URL"],
+			hint: "http://localhost:11434"
+		}
+	];
+	const detectedProvider = PROVIDER_OPTIONS.find((p) => p.detectKeys.some((key) => process.env[key]?.trim()));
+	let providerEnvKey;
+	let providerApiKey;
+	if (detectedProvider) clack.log.success(`Found existing ${detectedProvider.label} key in environment (${detectedProvider.envKey})`);
+	else {
+		const providerChoice = await clack.select({
+			message: `${name}: One more thing — which AI provider should I use?`,
+			options: [...PROVIDER_OPTIONS.map((p) => ({
+				value: p.id,
+				label: p.label,
+				hint: p.id === "ollama" ? "no API key needed" : void 0
+			})), {
+				value: "_skip_",
+				label: "Skip for now",
+				hint: "set an API key later via env or config"
+			}]
+		});
+		if (clack.isCancel(providerChoice)) cancelOnboarding();
+		if (providerChoice !== "_skip_") {
+			const chosen = PROVIDER_OPTIONS.find((p) => p.id === providerChoice);
+			if (chosen) {
+				providerEnvKey = chosen.envKey;
+				if (chosen.id === "ollama") {
+					const ollamaUrl = await clack.text({
+						message: "Ollama base URL:",
+						placeholder: "http://localhost:11434",
+						defaultValue: "http://localhost:11434"
+					});
+					if (clack.isCancel(ollamaUrl)) cancelOnboarding();
+					providerApiKey = ollamaUrl.trim() || "http://localhost:11434";
+				} else {
+					const apiKeyInput = await clack.password({ message: `Paste your ${chosen.label} API key:` });
+					if (clack.isCancel(apiKeyInput)) cancelOnboarding();
+					providerApiKey = apiKeyInput.trim();
+				}
+			}
+		}
+	}
+	const { generateWalletKeys, importWallet } = await import("../api/wallet.js");
+	const hasEvmKey = Boolean(process.env.EVM_PRIVATE_KEY?.trim());
+	const hasSolKey = Boolean(process.env.SOLANA_PRIVATE_KEY?.trim());
+	if (!hasEvmKey || !hasSolKey) {
+		const walletAction = await clack.select({
+			message: `${name}: Do you want me to set up crypto wallets? (for trading, NFTs, DeFi)`,
+			options: [
+				{
+					value: "generate",
+					label: "Generate new wallets",
+					hint: "creates fresh EVM + Solana keypairs"
+				},
+				{
+					value: "import",
+					label: "Import existing wallets",
+					hint: "paste your private keys"
+				},
+				{
+					value: "skip",
+					label: "Skip for now",
+					hint: "wallets can be added later"
+				}
+			]
+		});
+		if (clack.isCancel(walletAction)) cancelOnboarding();
+		if (walletAction === "generate") {
+			const keys = generateWalletKeys();
+			if (!hasEvmKey) {
+				process.env.EVM_PRIVATE_KEY = keys.evmPrivateKey;
+				clack.log.success(`Generated EVM wallet: ${keys.evmAddress}`);
+			}
+			if (!hasSolKey) {
+				process.env.SOLANA_PRIVATE_KEY = keys.solanaPrivateKey;
+				clack.log.success(`Generated Solana wallet: ${keys.solanaAddress}`);
+			}
+		} else if (walletAction === "import") {
+			if (!hasEvmKey) {
+				const evmKeyInput = await clack.password({ message: "Paste your EVM private key (0x... hex, or skip):" });
+				if (!clack.isCancel(evmKeyInput) && evmKeyInput.trim()) {
+					const result = importWallet("evm", evmKeyInput.trim());
+					if (result.success) clack.log.success(`Imported EVM wallet: ${result.address}`);
+					else clack.log.warn(`EVM import failed: ${result.error}`);
+				}
+			}
+			if (!hasSolKey) {
+				const solKeyInput = await clack.password({ message: "Paste your Solana private key (base58, or skip):" });
+				if (!clack.isCancel(solKeyInput) && solKeyInput.trim()) {
+					const result = importWallet("solana", solKeyInput.trim());
+					if (result.success) clack.log.success(`Imported Solana wallet: ${result.address}`);
+					else clack.log.warn(`Solana import failed: ${result.error}`);
+				}
+			}
+		}
+	}
+	const hasSkillsRegistry = Boolean(process.env.SKILLS_REGISTRY?.trim() || process.env.CLAWHUB_REGISTRY?.trim());
+	const hasSkillsmpKey = Boolean(process.env.SKILLSMP_API_KEY?.trim());
+	if (!hasSkillsRegistry) process.env.SKILLS_REGISTRY = "https://clawhub.ai";
+	const hasGithubToken = Boolean(process.env.GITHUB_TOKEN?.trim());
+	const hasGithubOAuth = Boolean(process.env.GITHUB_OAUTH_CLIENT_ID?.trim());
+	if (!hasGithubToken) {
+		const options = [{
+			value: "skip",
+			label: "Skip for now",
+			hint: "you can add this later"
+		}, {
+			value: "pat",
+			label: "Paste a Personal Access Token",
+			hint: "github.com/settings/tokens"
+		}];
+		if (hasGithubOAuth) options.push({
+			value: "oauth",
+			label: "Use OAuth (authorize in browser)",
+			hint: "recommended"
+		});
+		const githubChoice = await clack.select({
+			message: "Configure GitHub access? (needed for coding agents, issue management, PRs)",
+			options
+		});
+		if (!clack.isCancel(githubChoice) && githubChoice === "pat") {
+			const tokenInput = await clack.password({ message: "Paste your GitHub token (or skip):" });
+			if (!clack.isCancel(tokenInput) && tokenInput.trim()) {
+				process.env.GITHUB_TOKEN = tokenInput.trim();
+				clack.log.success("GitHub token configured.");
+			}
+		} else if (!clack.isCancel(githubChoice) && githubChoice === "oauth") clack.log.info("GitHub OAuth will activate when coding agents need access.");
+	}
+	const existingList = config.agents?.list ?? [];
+	const agentConfigEntry = {
+		...existingList[0] ?? {
+			id: "main",
+			default: true
+		},
+		name
+	};
+	if (chosenTemplate) {
+		agentConfigEntry.bio = chosenTemplate.bio;
+		agentConfigEntry.system = chosenTemplate.system;
+		agentConfigEntry.style = chosenTemplate.style;
+		agentConfigEntry.adjectives = chosenTemplate.adjectives;
+		agentConfigEntry.topics = chosenTemplate.topics;
+		agentConfigEntry.postExamples = chosenTemplate.postExamples;
+		agentConfigEntry.messageExamples = chosenTemplate.messageExamples;
+	}
+	const updatedList = [agentConfigEntry, ...existingList.slice(1)];
+	const updated = {
+		...config,
+		agents: {
+			...config.agents,
+			list: updatedList
+		}
+	};
+	if (!updated.env) updated.env = {};
+	const envBucket = updated.env;
+	if (providerEnvKey && providerApiKey) {
+		envBucket[providerEnvKey] = providerApiKey;
+		process.env[providerEnvKey] = providerApiKey;
+	}
+	if (process.env.EVM_PRIVATE_KEY && !hasEvmKey) envBucket.EVM_PRIVATE_KEY = process.env.EVM_PRIVATE_KEY;
+	if (process.env.SOLANA_PRIVATE_KEY && !hasSolKey) envBucket.SOLANA_PRIVATE_KEY = process.env.SOLANA_PRIVATE_KEY;
+	if (process.env.SKILLS_REGISTRY && !hasSkillsRegistry) envBucket.SKILLS_REGISTRY = process.env.SKILLS_REGISTRY;
+	if (process.env.SKILLSMP_API_KEY && !hasSkillsmpKey) envBucket.SKILLSMP_API_KEY = process.env.SKILLSMP_API_KEY;
+	if (process.env.GITHUB_TOKEN && !hasGithubToken) envBucket.GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+	if (process.env.GITHUB_OAUTH_CLIENT_ID && !hasGithubOAuth) envBucket.GITHUB_OAUTH_CLIENT_ID = process.env.GITHUB_OAUTH_CLIENT_ID;
+	try {
+		saveMiladyConfig(updated);
+	} catch (err) {
+		clack.log.warn(`Could not save config: ${formatError(err)}`);
+	}
+	clack.log.message(`${name}: ${styleChoice} Alright, that's me.`);
+	clack.outro("Let's get started!");
+	return updated;
+}
+/**
+* Boot the ElizaOS runtime without starting the readline chat loop.
+*
+* This is a convenience wrapper around {@link startEliza} in headless mode,
+* with optional config guards.
+*/
+async function bootElizaRuntime(opts = {}) {
+	if (opts.requireConfig && !configFileExists()) throw new Error("No config found. Run `milady start` once to complete setup.");
+	const runtime = await startEliza({ headless: true });
+	if (!runtime) throw new Error("Failed to boot runtime");
+	return runtime;
+}
+const LEVEL_TO_NAME = {
+	10: "trace",
+	20: "debug",
+	27: "success",
+	28: "progress",
+	29: "log",
+	30: "info",
+	40: "warn",
+	50: "error",
+	60: "fatal"
+};
+const logToChatListener = (entry) => {
+	if (entry.roomId && entry.runtime) {
+		const runtime = entry.runtime;
+		if (runtime.logLevelOverrides?.get(String(entry.roomId))) {
+			const levelKey = entry.level;
+			const content = `${`[${(levelKey && LEVEL_TO_NAME[levelKey] ? LEVEL_TO_NAME[levelKey] : "log").toUpperCase()}]`} ${entry.msg}`;
+			runtime.sendMessageToTarget({ roomId: entry.roomId }, {
+				text: `\`\`\`\n${content}\n\`\`\``,
+				source: "system",
+				isLog: "true"
+			}).catch(() => {});
+		}
+	}
+};
+/**
+* Start the ElizaOS runtime with Milady's configuration.
+*
+* In headless mode the runtime is returned instead of entering the
+* interactive readline loop.
+*/
+async function startEliza(opts) {
+	const { captureEarlyLogs } = await import("../api/early-logs.js");
+	captureEarlyLogs();
+	addLogListener(logToChatListener);
+	let config;
+	try {
+		config = loadMiladyConfig();
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			logger.warn("[milady] No config found, using defaults");
+			config = {};
+		} else throw err;
+	}
+	if (!opts?.headless) config = await runFirstTimeSetup(config);
+	if (!process.env.LOG_LEVEL) process.env.LOG_LEVEL = config.logging?.level ?? "error";
+	applyConnectorSecretsToEnv(config);
+	await autoResolveDiscordAppId();
+	applyCloudConfigToEnv(config);
+	applyX402ConfigToEnv(config);
+	applyDatabaseConfigToEnv(config);
+	if (config.env && typeof config.env === "object" && !Array.isArray(config.env)) {
+		for (const [key, value] of Object.entries(config.env)) if (typeof value === "string" && !process.env[key]) process.env[key] = value;
+	}
+	{
+		const dbProvider = config.database?.provider ?? "pglite";
+		const pgliteDir = process.env.PGLITE_DATA_DIR;
+		const postgresUrl = process.env.POSTGRES_URL;
+		logger.info(`[milady] Database provider: ${dbProvider}` + (dbProvider === "pglite" && pgliteDir ? ` | data dir: ${pgliteDir}` : "") + (dbProvider === "postgres" && postgresUrl ? ` | connection: ${postgresUrl.replace(/:\/\/([^:]+):([^@]+)@/, "://$1:***@")}` : ""));
+	}
+	try {
+		const { initializeOGCode } = await import("../api/og-tracker.js");
+		initializeOGCode();
+	} catch {}
+	if (!process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS) process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS = "true";
+	if (!process.env.IGNORE_BOOTSTRAP) process.env.IGNORE_BOOTSTRAP = "true";
+	if (!process.env.SECRET_SALT) {
+		process.env.SECRET_SALT = crypto.randomBytes(32).toString("hex");
+		logger.info("[milady] Generated random SECRET_SALT for this session");
+	}
+	for (const gkey of [
+		"GEMINI_API_KEY",
+		"GOOGLE_API_KEY",
+		"GOOGLE_GENERATIVE_AI_API_KEY"
+	]) {
+		const val = process.env[gkey]?.trim();
+		if (val && (val.length < 20 || val === "your-key-here" || val.startsWith("sk-"))) {
+			logger.warn(`[milady] ${gkey} appears invalid (length/format), clearing to skip Google AI plugin`);
+			delete process.env[gkey];
+		}
+	}
+	try {
+		const { applySubscriptionCredentials } = await import("../auth/index.js");
+		await applySubscriptionCredentials(config);
+	} catch (err) {
+		logger.warn(`[milady] Failed to apply subscription credentials: ${err}`);
+	}
+	const character = buildCharacterFromConfig(config);
+	const primaryModel = resolvePrimaryModel(config);
+	const workspaceDir = config.agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
+	await ensureAgentWorkspace({
+		dir: workspaceDir,
+		ensureBootstrapFiles: true
+	});
+	await fs$1.mkdir(path.join(resolveStateDir(), CUSTOM_PLUGINS_DIRNAME), { recursive: true });
+	const agentId = character.name?.toLowerCase().replace(/\s+/g, "-") ?? "main";
+	const miladyPlugin = createMiladyPlugin({
+		workspaceDir,
+		bootstrapMaxChars: config.agents?.defaults?.bootstrapMaxChars,
+		agentId
+	});
+	const preOnboarding = opts?.headless && !config.agents;
+	const resolvedPlugins = await resolvePlugins(config, { quiet: preOnboarding });
+	if (resolvedPlugins.length === 0) if (preOnboarding) logger.info("[milady] No plugins loaded yet — the onboarding wizard will configure a model provider");
+	else {
+		logger.error("[milady] No plugins loaded — at least one model provider plugin is required");
+		logger.error("[milady] Set an API key (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY) in your environment");
+		throw new Error("No plugins loaded");
+	}
+	{
+		const pluginNames = resolvedPlugins.map((p) => p.name);
+		const providerNames = resolvedPlugins.flatMap((p) => p.plugin.providers ?? []).map((prov) => prov.name);
+		const contextSummary = {
+			agentName: character.name,
+			pluginCount: resolvedPlugins.length,
+			providerCount: providerNames.length,
+			primaryModel: primaryModel ?? "(auto-detect)",
+			workspaceDir
+		};
+		debugLogResolvedContext(pluginNames, providerNames, contextSummary, (msg) => logger.debug(msg));
+		const contextValidation = validateRuntimeContext(contextSummary);
+		if (!contextValidation.valid) {
+			const issues = [];
+			if (contextValidation.nullFields.length > 0) issues.push(`null: ${contextValidation.nullFields.join(", ")}`);
+			if (contextValidation.undefinedFields.length > 0) issues.push(`undefined: ${contextValidation.undefinedFields.join(", ")}`);
+			if (contextValidation.emptyFields.length > 0) issues.push(`empty: ${contextValidation.emptyFields.join(", ")}`);
+			logger.warn(`[milady] Context validation issues detected: ${issues.join("; ")}`);
+		}
+	}
+	const PREREGISTER_PLUGINS = new Set(["@elizaos/plugin-sql", "@elizaos/plugin-local-embedding"]);
+	const sqlPlugin = resolvedPlugins.find((p) => p.name === "@elizaos/plugin-sql");
+	const localEmbeddingPlugin = resolvedPlugins.find((p) => p.name === "@elizaos/plugin-local-embedding");
+	const otherPlugins = resolvedPlugins.filter((p) => !PREREGISTER_PLUGINS.has(p.name));
+	const runtimeLogLevel = (() => {
+		const lvl = process.env.LOG_LEVEL ?? config.logging?.level ?? "error";
+		if (lvl === "silent") return "fatal";
+		return lvl;
+	})();
+	let bundledSkillsDir = null;
+	try {
+		const { getSkillsDir } = await import("@elizaos/skills");
+		bundledSkillsDir = getSkillsDir();
+		logger.info(`[milady] Bundled skills dir: ${bundledSkillsDir}`);
+	} catch {
+		logger.debug("[milady] @elizaos/skills not available — bundled skills will not be loaded");
+	}
+	const workspaceSkillsDir = workspaceDir ? `${workspaceDir}/skills` : null;
+	const sandboxConfig = config.agents?.defaults?.sandbox;
+	const sandboxModeStr = sandboxConfig?.mode;
+	const sandboxMode = sandboxModeStr === "light" || sandboxModeStr === "standard" || sandboxModeStr === "max" ? sandboxModeStr : "off";
+	const isSandboxActive = sandboxMode !== "off";
+	let sandboxManager = null;
+	let sandboxAuditLog = null;
+	if (isSandboxActive) {
+		logger.info(`[milady] Sandbox mode: ${sandboxMode}`);
+		sandboxAuditLog = new SandboxAuditLog({ console: true });
+		if (sandboxMode === "standard" || sandboxMode === "max") {
+			const dockerSettings = sandboxConfig?.docker;
+			const browserSettings = sandboxConfig?.browser;
+			sandboxManager = new SandboxManager({
+				mode: sandboxMode,
+				image: dockerSettings?.image ?? void 0,
+				containerPrefix: dockerSettings?.containerPrefix ?? void 0,
+				network: dockerSettings?.network ?? void 0,
+				memory: dockerSettings?.memory ?? void 0,
+				cpus: dockerSettings?.cpus ?? void 0,
+				workspaceRoot: workspaceDir ?? void 0,
+				browser: browserSettings ? {
+					enabled: browserSettings.enabled ?? false,
+					image: browserSettings.image ?? void 0,
+					cdpPort: browserSettings.cdpPort ?? void 0,
+					autoStart: browserSettings.autoStart ?? true
+				} : void 0
+			});
+			try {
+				await sandboxManager.start();
+				logger.info("[milady] Sandbox manager started");
+			} catch (err) {
+				logger.error(`[milady] Sandbox manager failed to start: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		sandboxAuditLog.record({
+			type: "sandbox_lifecycle",
+			summary: `Sandbox initialized: mode=${sandboxMode}`,
+			severity: "info"
+		});
+	}
+	const pluginsForRuntime = otherPlugins.map((p) => p.plugin);
+	if (primaryModel) {
+		for (const plugin of pluginsForRuntime) if (plugin.name === primaryModel) {
+			plugin.priority = (plugin.priority ?? 0) + 10;
+			logger.info(`[milady] Boosted plugin "${plugin.name}" priority to ${plugin.priority} (model.primary)`);
+			break;
+		}
+	}
+	deduplicatePluginActions([miladyPlugin, ...pluginsForRuntime]);
+	let runtime = new AgentRuntime({
+		character,
+		actionPlanning: true,
+		plugins: [miladyPlugin, ...pluginsForRuntime],
+		...runtimeLogLevel ? { logLevel: runtimeLogLevel } : {},
+		...isSandboxActive ? {
+			sandboxMode: true,
+			sandboxAuditHandler: sandboxAuditLog ? (event) => {
+				sandboxAuditLog.recordTokenReplacement(event.direction, event.url, event.tokenIds);
+			} : void 0
+		} : {},
+		settings: {
+			VALIDATION_LEVEL: "fast",
+			...Object.fromEntries(Object.entries(collectConfigEnvVars(config)).filter(([key]) => isEnvKeyAllowedForForwarding(key))),
+			...primaryModel ? { MODEL_PROVIDER: primaryModel } : {},
+			...config.skills?.allowBundled ? { SKILLS_ALLOWLIST: config.skills.allowBundled.join(",") } : {},
+			...config.skills?.denyBundled ? { SKILLS_DENYLIST: config.skills.denyBundled.join(",") } : {},
+			...bundledSkillsDir ? { BUNDLED_SKILLS_DIRS: bundledSkillsDir } : {},
+			...workspaceSkillsDir ? { WORKSPACE_SKILLS_DIR: workspaceSkillsDir } : {},
+			...config.skills?.load?.extraDirs?.length ? { EXTRA_SKILLS_DIRS: config.skills.load.extraDirs.join(",") } : {},
+			...config.features?.vision === false ? { DISABLE_IMAGE_DESCRIPTION: "true" } : {}
+		}
+	});
+	installRuntimeMethodBindings(runtime);
+	if (sqlPlugin) await registerSqlPluginWithRecovery(runtime, sqlPlugin, config);
+	else {
+		const loadedNames = resolvedPlugins.map((p) => p.name).join(", ");
+		logger.error(`[milady] @elizaos/plugin-sql was NOT found among resolved plugins. Loaded: [${loadedNames}]`);
+		throw new Error("@elizaos/plugin-sql is required but was not loaded. Ensure the package is installed and built (check for import errors above).");
+	}
+	if (localEmbeddingPlugin) {
+		configureLocalEmbeddingPlugin(localEmbeddingPlugin.plugin, config);
+		await runtime.registerPlugin(localEmbeddingPlugin.plugin);
+		logger.info("[milady] plugin-local-embedding pre-registered (TEXT_EMBEDDING ready)");
+	} else logger.warn("[milady] @elizaos/plugin-local-embedding not found — embeddings will fall back to whatever TEXT_EMBEDDING handler is registered by other plugins (may incur cloud API costs)");
+	const warmAgentSkillsService = async () => {
+		try {
+			const skillServicePromise = runtime.getServiceLoadPromise("AGENT_SKILLS_SERVICE");
+			const timeout = new Promise((_resolve, reject) => {
+				setTimeout(() => {
+					reject(/* @__PURE__ */ new Error("AgentSkillsService warm-up timed out (10s) — non-blocking, agent will function without skills"));
+				}, 1e4);
+			});
+			await Promise.race([skillServicePromise, timeout]);
+			const svc = runtime.getService("AGENT_SKILLS_SERVICE");
+			if (svc?.getCatalogStats) {
+				const stats = svc.getCatalogStats();
+				logger.info(`[milady] AgentSkills ready — ${stats.loaded} skills loaded, ${stats.total} in catalog (storage: ${stats.storageType})`);
+			}
+			const svcAny = svc;
+			const origGetLoaded = svcAny?.getLoadedSkills;
+			if (origGetLoaded && svcAny) {
+				svcAny.getLoadedSkills = function(...args) {
+					const skills = origGetLoaded.apply(this, args);
+					for (const skill of skills) if (typeof skill.description !== "string") skill.description = skill.description == null ? "" : JSON.stringify(skill.description);
+					return skills;
+				};
+				logger.debug("[milady] Patched getLoadedSkills to guard descriptions");
+			}
+		} catch (err) {
+			logger.debug(`[milady] AgentSkillsService warm-up: ${formatError(err)}`);
+		}
+	};
+	const initializeRuntimeServices = async () => {
+		await runtime.initialize();
+		await waitForTrajectoryLoggerService(runtime, "runtime.initialize()");
+		ensureTrajectoryLoggerEnabled(runtime, "runtime.initialize()");
+		if (!runtime.getService("AUTONOMY")) try {
+			await AutonomyService.start(runtime);
+			logger.info("[milady] AutonomyService started for trigger dispatch");
+		} catch (err) {
+			logger.warn(`[milady] AutonomyService failed to start: ${formatError(err)}`);
+		}
+		warmAgentSkillsService();
+	};
+	try {
+		await initializeRuntimeServices();
+	} catch (err) {
+		const pgliteDataDir = resolveActivePgliteDataDir(config);
+		if (!(!opts?.pgliteRecoveryAttempted && pgliteDataDir && isRecoverablePgliteInitError(err)) || !pgliteDataDir) throw err;
+		logger.warn(`[milady] Runtime migrations failed (${formatError(err)}). Resetting local PGLite DB at ${pgliteDataDir} and retrying startup once.`);
+		await resetPgliteDataDir(pgliteDataDir);
+		process.env.PGLITE_DATA_DIR = pgliteDataDir;
+		try {
+			await runtime.stop();
+		} catch {}
+		return await startEliza({
+			...opts,
+			pgliteRecoveryAttempted: true
+		});
+	}
+	installActionAliases(runtime);
+	if (!opts?.headless) {
+		let isShuttingDown = false;
+		const shutdown = async () => {
+			if (isShuttingDown) return;
+			isShuttingDown = true;
+			try {
+				if (sandboxManager) try {
+					await sandboxManager.stop();
+					logger.info("[milady] Sandbox manager stopped");
+				} catch (err) {
+					logger.warn(`[milady] Sandbox stop error: ${err instanceof Error ? err.message : String(err)}`);
+				}
+			} catch (err) {
+				logger.warn(`[milady] Sandbox shutdown error: ${formatError(err)}`);
+			}
+			try {
+				await runtime.stop();
+			} catch (err) {
+				logger.warn(`[milady] Error during shutdown: ${formatError(err)}`);
+			}
+			process.exit(0);
+		};
+		process.on("SIGINT", () => void shutdown());
+		process.on("SIGTERM", () => void shutdown());
+	}
+	const loadHooksSystem = async () => {
+		try {
+			const internalHooksConfig = config.hooks?.internal;
+			await loadHooks({
+				workspacePath: workspaceDir,
+				internalConfig: internalHooksConfig,
+				miladyConfig: config
+			});
+			await triggerHook(createHookEvent("gateway", "startup", "system", { cfg: config }));
+		} catch (err) {
+			logger.warn(`[milady] Hooks system could not load: ${formatError(err)}`);
+		}
+	};
+	if (opts?.headless) {
+		loadHooksSystem();
+		logger.info("[milady] Runtime initialised in headless mode (autonomy enabled)");
+		return runtime;
+	}
+	await loadHooksSystem();
+	try {
+		const { startApiServer } = await import("../api/server.js");
+		const { port: actualApiPort } = await startApiServer({
+			port: Number(process.env.MILADY_PORT) || 2138,
+			runtime,
+			onRestart: async () => {
+				logger.info("[milady] Hot-reload: Restarting runtime...");
+				try {
+					try {
+						await runtime.stop();
+					} catch (stopErr) {
+						logger.warn(`[milady] Hot-reload: old runtime stop failed: ${formatError(stopErr)}`);
+					}
+					const freshConfig = loadMiladyConfig();
+					applyConnectorSecretsToEnv(freshConfig);
+					await autoResolveDiscordAppId();
+					applyCloudConfigToEnv(freshConfig);
+					applyX402ConfigToEnv(freshConfig);
+					applyDatabaseConfigToEnv(freshConfig);
+					try {
+						const { applySubscriptionCredentials } = await import("../auth/index.js");
+						await applySubscriptionCredentials(freshConfig);
+					} catch (subErr) {
+						logger.warn(`[milady] Hot-reload: subscription credentials: ${formatError(subErr)}`);
+					}
+					const resolvedPlugins = await resolvePlugins(freshConfig);
+					const freshCharacter = buildCharacterFromConfig(freshConfig);
+					const freshMiladyPlugin = createMiladyPlugin({
+						workspaceDir: freshConfig.agents?.defaults?.workspace ?? workspaceDir,
+						bootstrapMaxChars: freshConfig.agents?.defaults?.bootstrapMaxChars,
+						agentId: freshCharacter.name?.toLowerCase().replace(/\s+/g, "-") ?? "main"
+					});
+					const freshPrimaryModel = resolvePrimaryModel(freshConfig);
+					const freshPluginsForRuntime = resolvedPlugins.filter((p) => !PREREGISTER_PLUGINS.has(p.name)).map((p) => p.plugin);
+					if (freshPrimaryModel) {
+						for (const plugin of freshPluginsForRuntime) if (plugin.name === freshPrimaryModel) {
+							plugin.priority = (plugin.priority ?? 0) + 10;
+							break;
+						}
+					}
+					const newRuntime = new AgentRuntime({
+						character: freshCharacter,
+						plugins: [freshMiladyPlugin, ...freshPluginsForRuntime],
+						...runtimeLogLevel ? { logLevel: runtimeLogLevel } : {},
+						settings: {
+							...freshPrimaryModel ? { MODEL_PROVIDER: freshPrimaryModel } : {},
+							...freshConfig.features?.vision === false ? { DISABLE_IMAGE_DESCRIPTION: "true" } : {}
+						}
+					});
+					installRuntimeMethodBindings(newRuntime);
+					const freshSqlPlugin = resolvedPlugins.find((p) => p.name === "@elizaos/plugin-sql");
+					const freshLocalEmbeddingPlugin = resolvedPlugins.find((p) => p.name === "@elizaos/plugin-local-embedding");
+					if (freshSqlPlugin) await registerSqlPluginWithRecovery(newRuntime, freshSqlPlugin, freshConfig);
+					if (freshLocalEmbeddingPlugin) {
+						configureLocalEmbeddingPlugin(freshLocalEmbeddingPlugin.plugin, freshConfig);
+						await newRuntime.registerPlugin(freshLocalEmbeddingPlugin.plugin);
+					}
+					await newRuntime.initialize();
+					await waitForTrajectoryLoggerService(newRuntime, "hot-reload runtime.initialize()");
+					ensureTrajectoryLoggerEnabled(newRuntime, "hot-reload runtime.initialize()");
+					if (!newRuntime.getService("AUTONOMY")) try {
+						await AutonomyService.start(newRuntime);
+					} catch (err) {
+						logger.warn(`[milady] AutonomyService failed to start after hot-reload: ${formatError(err)}`);
+					}
+					installActionAliases(newRuntime);
+					runtime = newRuntime;
+					logger.info("[milady] Hot-reload: Runtime restarted successfully");
+					return newRuntime;
+				} catch (err) {
+					logger.error(`[milady] Hot-reload failed: ${formatError(err)}`);
+					return null;
+				}
+			}
+		});
+		const dashboardUrl = `http://localhost:${actualApiPort}`;
+		console.log(`[milady] Control UI: ${dashboardUrl}`);
+		logger.info(`[milady] API server listening on ${dashboardUrl}`);
+	} catch (apiErr) {
+		logger.warn(`[milady] Could not start API server: ${formatError(apiErr)}`);
+	}
+	if (opts?.serverOnly) {
+		logger.info("[milady] Running in server-only mode (no interactive chat)");
+		console.log("[milady] Server running. Press Ctrl+C to stop.");
+		const keepAlive = setInterval(() => {}, 1 << 30);
+		const cleanup = async () => {
+			clearInterval(keepAlive);
+			try {
+				await runtime.stop();
+			} catch (err) {
+				logger.warn(`[milady] Error stopping runtime: ${formatError(err)}`);
+			}
+			process.exit(0);
+		};
+		process.on("SIGINT", () => void cleanup());
+		process.on("SIGTERM", () => void cleanup());
+		return runtime;
+	}
+	const agentName = character.name ?? "Milady";
+	const userId = crypto.randomUUID();
+	let roomId = stringToUuid(`${agentName}-chat-room`);
+	try {
+		const worldId = stringToUuid(`${agentName}-chat-world`);
+		const messageServerId = stringToUuid(`${agentName}-cli-server`);
+		await runtime.ensureConnection({
+			entityId: userId,
+			roomId,
+			worldId,
+			userName: "User",
+			source: "cli",
+			channelId: `${agentName}-chat`,
+			type: ChannelType.DM,
+			messageServerId,
+			metadata: { ownership: { ownerId: userId } }
+		});
+		const world = await runtime.getWorld(worldId);
+		if (world) {
+			let needsUpdate = false;
+			if (!world.metadata) {
+				world.metadata = {};
+				needsUpdate = true;
+			}
+			if (!world.metadata.ownership || typeof world.metadata.ownership !== "object" || world.metadata.ownership.ownerId !== userId) {
+				world.metadata.ownership = { ownerId: userId };
+				needsUpdate = true;
+			}
+			if (needsUpdate) await runtime.updateWorld(world);
+		}
+	} catch (err) {
+		logger.warn(`[milady] Could not establish chat room, retrying with fresh IDs: ${formatError(err)}`);
+		roomId = crypto.randomUUID();
+		const freshWorldId = crypto.randomUUID();
+		const freshServerId = crypto.randomUUID();
+		try {
+			await runtime.ensureConnection({
+				entityId: userId,
+				roomId,
+				worldId: freshWorldId,
+				userName: "User",
+				source: "cli",
+				channelId: `${agentName}-chat`,
+				type: ChannelType.DM,
+				messageServerId: freshServerId,
+				metadata: { ownership: { ownerId: userId } }
+			});
+			const fallbackWorld = await runtime.getWorld(freshWorldId);
+			if (fallbackWorld) {
+				let needsUpdate = false;
+				if (!fallbackWorld.metadata) {
+					fallbackWorld.metadata = {};
+					needsUpdate = true;
+				}
+				if (!fallbackWorld.metadata.ownership || typeof fallbackWorld.metadata.ownership !== "object" || fallbackWorld.metadata.ownership.ownerId !== userId) {
+					fallbackWorld.metadata.ownership = { ownerId: userId };
+					needsUpdate = true;
+				}
+				if (needsUpdate) await runtime.updateWorld(fallbackWorld);
+			}
+		} catch (retryErr) {
+			logger.error(`[milady] Chat room setup failed after retry: ${formatError(retryErr)}`);
+			throw retryErr;
+		}
+	}
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.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();
+				try {
+					await runtime.stop();
+				} catch (err) {
+					logger.warn(`[milady] Error stopping runtime: ${formatError(err)}`);
+				}
+				process.exit(0);
+			}
+			if (!text) {
+				prompt();
+				return;
+			}
+			try {
+				const message = createMessageMemory({
+					id: crypto.randomUUID(),
+					entityId: userId,
+					roomId,
+					content: {
+						text,
+						source: "client_chat",
+						channelType: ChannelType.DM
+					}
+				});
+				process.stdout.write(`${agentName}: `);
+				if (!runtime.messageService) {
+					logger.error("[milady] runtime.messageService is not available — cannot process messages");
+					console.log("[Error: message service unavailable]\n");
+					prompt();
+					return;
+				}
+				await runtime.messageService.handleMessage(runtime, message, async (content) => {
+					if (content?.text) process.stdout.write(content.text);
+					return [];
+				});
+				console.log("\n");
+			} catch (err) {
+				console.log(`\n[Error: ${formatError(err)}]\n`);
+				logger.error(`[milady] Chat message handling failed: ${formatError(err)}`);
+			}
+			prompt();
+		});
+	};
+	prompt();
+}
+if ((() => {
+	const scriptArg = process.argv[1];
+	if (!scriptArg) return false;
+	const normalised = path.resolve(scriptArg);
+	if (import.meta.url === pathToFileURL(normalised).href) return true;
+	const base = path.basename(normalised);
+	return base === "eliza.ts" || base === "eliza";
+})()) startEliza().catch((err) => {
+	console.error("[milady] Fatal error:", err instanceof Error ? err.stack ?? err.message : err);
+	process.exit(1);
+});
+
+//#endregion
+export { CUSTOM_PLUGINS_DIRNAME, bootElizaRuntime, resolvePackageEntry, scanDropInPlugins, startEliza };