@elizaos/agent 2.0.0-beta.1 → 2.0.3-beta.2

package/runtime/plugin-resolver.js

@@ -0,0 +1,1593 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Plugin discovery and resolution logic.
+ *
+ * Resolves Eliza plugins from config and auto-enable logic, loading them
+ * from static imports, npm packages, workspace overrides, or drop-in
+ * directories. Each plugin is wrapped in an error boundary so a single
+ * failing plugin cannot crash the agent startup.
+ *
+ * Extracted from eliza.ts to reduce file size.
+ *
+ * @module plugin-resolver
+ */
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { logger } from "@elizaos/core";
+import { formatError, isMobilePlatform } from "@elizaos/shared";
+import { applyAppManifestDefaults, filterCandidatesByAppManifest, readAppManifest, } from "@elizaos/shared/config/app-manifest";
+import { applyPluginManifestVerdicts, evaluatePluginManifests, } from "@elizaos/shared/config/plugin-manifest";
+import { saveElizaConfig } from "../config/config.js";
+import { isLegacyAppsWorkspaceDiscoveryEnabled } from "../config/feature-flags.js";
+import { resolveStateDir, resolveUserPath } from "../config/paths.js";
+import { diagnoseNoAIProvider } from "../services/version-compat.js";
+import { BLOCKING_CORE_PLUGINS, CORE_PLUGINS, OPTIONAL_CORE_PLUGINS, } from "./core-plugins.js";
+import { CHANNEL_PLUGIN_MAP, collectPluginNames, OPTIONAL_PLUGIN_MAP, resolvePluginPackageAlias, } from "./plugin-collector.js";
+import { CUSTOM_PLUGINS_DIRNAME, EJECTED_PLUGINS_DIRNAME, ensureBrowserServerLink, findRuntimePluginExport, mergeDropInPlugins, repairBrokenInstallRecord, resolveElizaPluginImportSpecifier, resolvePackageEntry, STATIC_ELIZA_PLUGINS, scanDropInPlugins, } from "./plugin-types.js";
+const LAST_FAILED_PLUGIN_NAMES = Symbol.for("@elizaos/plugin-resolver/last-failed-plugin-names");
+const LAST_FAILED_PLUGIN_DETAILS = Symbol.for("@elizaos/plugin-resolver/last-failed-plugin-details");
+const RUNTIME_APP_PLUGIN_SUBPATHS = new Set([
+    "@elizaos/plugin-companion",
+    "@elizaos/plugin-contacts",
+    "@elizaos/plugin-elizamaker",
+    "@elizaos/plugin-inbox",
+    "@elizaos/plugin-personal-assistant",
+    "@elizaos/plugin-phone",
+    "@elizaos/plugin-polymarket-app",
+    "@elizaos/plugin-shopify-ui",
+    "@elizaos/plugin-steward-app",
+    "@elizaos/plugin-vincent",
+    "@elizaos/plugin-wifi",
+]);
+// ---------------------------------------------------------------------------
+// Helpers (private)
+// ---------------------------------------------------------------------------
+/** Missing npm package, Bun resolve, or browser stagehand — expected when optional plugins are allow-listed but not installed. */
+function isBenignOptionalPluginFailure(msg) {
+    return (msg.includes("Cannot find module") ||
+        msg.includes("MODULE_NOT_FOUND") ||
+        msg.includes("ResolveMessage") ||
+        msg === "browser server binary not found");
+}
+function redactUserSegments(filepath) {
+    // Replace /Users/<name>/ or /home/<name>/ with /Users/<redacted>/ etc.
+    return filepath.replace(/\/(Users|home)\/[^/]+\//g, "/$1/<redacted>/");
+}
+export function resolveRuntimePluginImportSpecifier(pluginName) {
+    if (pluginName.startsWith("@elizaos/plugin-")) {
+        return resolveRuntimeElizaPluginImportSpecifier(pluginName);
+    }
+    return runtimePluginImportSpecifier(pluginName);
+}
+function sanitizePluginCacheSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+const SOURCE_STAGED_WORKSPACE_DEPENDENCIES = new Set(["@elizaos/agent"]);
+const SOURCE_STAGED_ROOT_ENTRYPOINTS = {
+    "@elizaos/agent": {
+        path: "./src/staged-runtime-index.ts",
+        source: `export { extractActionParamsViaLlm } from "./actions/extract-params.js";
+export { renderGroundedActionReply } from "./actions/grounded-action-reply.js";
+export { extractConversationMetadataFromRoom, isPageScopedConversationMetadata } from "./api/conversation-metadata.js";
+export { handleConnectorAccountRoutes } from "./api/connector-account-routes.js";
+export { checkRateLimit } from "./api/rate-limiter.js";
+export { loadElizaConfig, saveElizaConfig } from "./config/config.js";
+export { loadOwnerContactRoutingHints, loadOwnerContactsConfig, resolveOwnerContactWithFallback } from "./config/owner-contacts.js";
+export { resolveOAuthDir, resolveStateDir } from "./config/paths.js";
+export { createIntegrationTelemetrySpan } from "./diagnostics/integration-observability.js";
+export { getAgentEventService } from "./runtime/agent-event-service.js";
+export { resolveOwnerEntityId } from "./runtime/owner-entity.js";
+export { hasOwnerAccess } from "./security/access.js";
+export { gatePluginSessionForHostedApp } from "./services/app-session-gate.js";
+export { registerEscalationChannel } from "./services/escalation.js";
+export { buildTriggerConfig, buildTriggerMetadata, computeNextCronRunAtMs, normalizeTriggerDraft, parseCronExpression } from "./triggers/scheduling.js";
+export { getTriggerLimit, listTriggerTasks, readTriggerConfig, taskToTriggerSummary, triggersFeatureEnabled, TRIGGER_TASK_NAME, TRIGGER_TASK_TAGS } from "./triggers/runtime.js";
+`,
+    },
+};
+function packageNodeModulesEntryPath(nodeModulesDir, packageName) {
+    return path.join(nodeModulesDir, ...packageName.split("/"));
+}
+async function pathEntryExists(targetPath) {
+    try {
+        await fs.lstat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readPluginPackageManifest(packageRoot) {
+    try {
+        return JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+function collectDeclaredPluginDependencies(manifest) {
+    const collected = new Map();
+    for (const name of Object.keys(manifest.dependencies ?? {})) {
+        collected.set(name, { name, optional: false });
+    }
+    for (const name of Object.keys(manifest.optionalDependencies ?? {})) {
+        if (!collected.has(name)) {
+            collected.set(name, { name, optional: true });
+        }
+    }
+    for (const name of Object.keys(manifest.peerDependencies ?? {})) {
+        if (collected.has(name)) {
+            continue;
+        }
+        const optional = manifest.peerDependenciesMeta?.[name]?.optional === true;
+        collected.set(name, { name, optional });
+    }
+    return [...collected.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+async function stageDependencyIntoNodeModules(params) {
+    const sourcePath = packageNodeModulesEntryPath(params.sourceNodeModulesDir, params.dependencyName);
+    if (!(await pathEntryExists(sourcePath))) {
+        return false;
+    }
+    const targetPath = packageNodeModulesEntryPath(params.targetNodeModulesDir, params.dependencyName);
+    if (await pathEntryExists(targetPath)) {
+        return true;
+    }
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    const stat = await fs.lstat(sourcePath);
+    if (stat.isSymbolicLink()) {
+        const linkTarget = await resolveSymlinkTargetIfPresent(sourcePath);
+        if (!linkTarget) {
+            return false;
+        }
+        await fs.symlink(linkTarget, targetPath);
+        return true;
+    }
+    if (!stat.isDirectory()) {
+        return false;
+    }
+    await fs.cp(sourcePath, targetPath, {
+        recursive: true,
+        force: true,
+        dereference: true,
+    });
+    return true;
+}
+function rewriteDistExportTargetToSource(value) {
+    if (typeof value === "string") {
+        return value.replace(/^\.(\/dist\/)/, "./src/").replace(/\.js$/, ".ts");
+    }
+    if (Array.isArray(value)) {
+        return value.map(rewriteDistExportTargetToSource);
+    }
+    if (!value || typeof value !== "object") {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+        key,
+        rewriteDistExportTargetToSource(entry),
+    ]));
+}
+async function writeSourceStagedPackageManifest(params) {
+    const sourcePackageJsonPath = path.join(params.sourcePackageRoot, "package.json");
+    const targetPackageJsonPath = path.join(params.targetPackageRoot, "package.json");
+    const manifest = JSON.parse(await fs.readFile(sourcePackageJsonPath, "utf8"));
+    const rootEntrypoint = SOURCE_STAGED_ROOT_ENTRYPOINTS[params.dependencyName];
+    const rootExport = rootEntrypoint
+        ? {
+            types: rootEntrypoint.path,
+            import: rootEntrypoint.path,
+            default: rootEntrypoint.path,
+        }
+        : undefined;
+    const rewrittenExports = rewriteDistExportTargetToSource(manifest.exports);
+    const rewrittenManifest = {
+        ...manifest,
+        main: rootEntrypoint?.path,
+        module: rootEntrypoint?.path,
+        types: rootEntrypoint?.path,
+        exports: rootExport && rewrittenExports && typeof rewrittenExports === "object"
+            ? { ...rewrittenExports, ".": rootExport }
+            : (rewrittenExports ?? rootEntrypoint?.path),
+    };
+    await fs.writeFile(targetPackageJsonPath, `${JSON.stringify(rewrittenManifest, null, 2)}\n`);
+}
+async function writeSourceStagedRootEntrypoint(params) {
+    const rootEntrypoint = SOURCE_STAGED_ROOT_ENTRYPOINTS[params.dependencyName];
+    if (!rootEntrypoint) {
+        return;
+    }
+    const relativeEntrypointPath = rootEntrypoint.path.replace(/^\.\//, "");
+    const targetPath = path.join(params.targetPackageRoot, relativeEntrypointPath);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, rootEntrypoint.source);
+}
+async function sourcePackageContainsRootEntrypointImports(params) {
+    const rootEntrypoint = SOURCE_STAGED_ROOT_ENTRYPOINTS[params.dependencyName];
+    if (!rootEntrypoint) {
+        return true;
+    }
+    const relativeEntrypointDir = path.dirname(rootEntrypoint.path.replace(/^\.\//, ""));
+    const relativeImports = [
+        ...rootEntrypoint.source.matchAll(/from\s+"(\.\/[^"]+)"/g),
+    ].map((match) => match[1]);
+    for (const relativeImport of relativeImports) {
+        const importedPath = path.join(relativeEntrypointDir, relativeImport);
+        const sourcePath = path.join(params.sourcePackageRoot, importedPath);
+        if (!(await pathEntryExists(sourcePath))) {
+            return false;
+        }
+    }
+    return true;
+}
+async function stageWorkspaceSourceDependencyIntoNodeModules(params) {
+    const sourcePath = packageNodeModulesEntryPath(params.sourceNodeModulesDir, params.dependencyName);
+    if (!(await pathEntryExists(sourcePath))) {
+        return false;
+    }
+    const resolvedSourcePath = (await resolveSymlinkTargetIfPresent(sourcePath)) ?? sourcePath;
+    const sourceSrcPath = path.join(resolvedSourcePath, "src");
+    const sourcePackageJsonPath = path.join(resolvedSourcePath, "package.json");
+    if (!(await pathEntryExists(sourceSrcPath)) ||
+        !(await pathEntryExists(sourcePackageJsonPath))) {
+        return false;
+    }
+    if (!(await sourcePackageContainsRootEntrypointImports({
+        dependencyName: params.dependencyName,
+        sourcePackageRoot: resolvedSourcePath,
+    }))) {
+        return false;
+    }
+    const targetPath = packageNodeModulesEntryPath(params.targetNodeModulesDir, params.dependencyName);
+    if (await pathEntryExists(targetPath)) {
+        return true;
+    }
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.cp(resolvedSourcePath, targetPath, {
+        recursive: true,
+        force: true,
+        dereference: true,
+        filter: (src) => {
+            const relativePath = path.relative(resolvedSourcePath, src);
+            if (!relativePath)
+                return true;
+            const [topLevel] = relativePath.split(path.sep);
+            return (topLevel === "src" ||
+                relativePath === "package.json" ||
+                relativePath === "vite-env.d.ts");
+        },
+    });
+    await writeSourceStagedPackageManifest({
+        dependencyName: params.dependencyName,
+        sourcePackageRoot: resolvedSourcePath,
+        targetPackageRoot: targetPath,
+    });
+    await writeSourceStagedRootEntrypoint({
+        dependencyName: params.dependencyName,
+        targetPackageRoot: targetPath,
+    });
+    return true;
+}
+async function ensureStagedPackageDependencies(params) {
+    const stagedNodeModulesPath = path.join(params.stagedPackageRoot, "node_modules");
+    await fs.mkdir(stagedNodeModulesPath, { recursive: true });
+    const manifest = await readPluginPackageManifest(params.packageRoot);
+    if (!manifest) {
+        return;
+    }
+    const dependencies = collectDeclaredPluginDependencies(manifest);
+    if (dependencies.length === 0) {
+        return;
+    }
+    const sourceNodeModulesDirs = uniquePaths([
+        path.join(params.packageRoot, "node_modules"),
+        path.join(params.installRoot, "node_modules"),
+        ...(await findAncestorNodeModulesDirs(params.packageRoot)),
+    ]);
+    for (const dependency of dependencies) {
+        const stagedDependencyPath = packageNodeModulesEntryPath(stagedNodeModulesPath, dependency.name);
+        const shouldStageFromSource = SOURCE_STAGED_WORKSPACE_DEPENDENCIES.has(dependency.name);
+        if (await pathEntryExists(stagedDependencyPath)) {
+            if (!shouldStageFromSource) {
+                continue;
+            }
+            await fs.rm(stagedDependencyPath, { recursive: true, force: true });
+        }
+        let staged = false;
+        for (const sourceNodeModulesDir of sourceNodeModulesDirs) {
+            staged = shouldStageFromSource
+                ? await stageWorkspaceSourceDependencyIntoNodeModules({
+                    dependencyName: dependency.name,
+                    sourceNodeModulesDir,
+                    targetNodeModulesDir: stagedNodeModulesPath,
+                })
+                : await stageDependencyIntoNodeModules({
+                    dependencyName: dependency.name,
+                    sourceNodeModulesDir,
+                    targetNodeModulesDir: stagedNodeModulesPath,
+                });
+            if (staged) {
+                break;
+            }
+        }
+        if (!staged && !dependency.optional) {
+            logger.warn(`[eliza] Staged plugin ${params.packageName} is missing declared dependency ${dependency.name}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Workspace plugin overrides
+// ---------------------------------------------------------------------------
+function uniquePaths(paths) {
+    const seen = new Set();
+    const ordered = [];
+    for (const candidate of paths) {
+        const resolved = path.resolve(candidate);
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            ordered.push(resolved);
+        }
+    }
+    return ordered;
+}
+function resolveWorkspaceRoots() {
+    const envRoot = process.env.ELIZA_WORKSPACE_ROOT?.trim();
+    if (envRoot) {
+        return uniquePaths([envRoot]);
+    }
+    // Search cwd by default. Repo-local ./eliza submodule +
+    // setup:upstreams symlinks handle plugin resolution for development. Set
+    // ELIZA_WORKSPACE_ROOT explicitly for external override scenarios.
+    return uniquePaths([process.cwd()]);
+}
+function getWorkspacePluginOverridePath(pluginName) {
+    if (process.env.ELIZA_DISABLE_WORKSPACE_PLUGIN_OVERRIDES === "1") {
+        return null;
+    }
+    const packageSegmentMatch = pluginName.match(/^@[^/]+\/((?:app|plugin)-[^/]+)$/);
+    const packageSegment = packageSegmentMatch?.[1];
+    if (!packageSegment)
+        return null;
+    for (const workspaceRoot of resolveWorkspaceRoots()) {
+        const candidates = [
+            path.join(workspaceRoot, "plugins", packageSegment, "typescript"),
+            path.join(workspaceRoot, "plugins", packageSegment),
+            path.join(workspaceRoot, "packages", packageSegment),
+            path.join(workspaceRoot, "eliza", "plugins", packageSegment, "typescript"),
+            path.join(workspaceRoot, "eliza", "plugins", packageSegment),
+            path.join(workspaceRoot, "eliza", "packages", packageSegment),
+        ];
+        if (isLegacyAppsWorkspaceDiscoveryEnabled()) {
+            // Opt-in for older external workspaces that have not moved
+            // app plugins from apps/app-* to plugins/app-* yet. The Eliza repo no
+            // longer depends on or scans top-level apps/* by default.
+            candidates.push(path.join(workspaceRoot, "apps", packageSegment), path.join(workspaceRoot, "eliza", "apps", packageSegment));
+        }
+        for (const candidate of uniquePaths(candidates)) {
+            if (existsSync(path.join(candidate, "package.json"))) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function runtimePluginExportSubpath(pluginName) {
+    return RUNTIME_APP_PLUGIN_SUBPATHS.has(pluginName) ? "./plugin" : ".";
+}
+function runtimePluginImportSpecifier(pluginName) {
+    return RUNTIME_APP_PLUGIN_SUBPATHS.has(pluginName)
+        ? `${pluginName}/plugin`
+        : pluginName;
+}
+function resolveRuntimeElizaPluginImportSpecifier(pluginName) {
+    const resolved = resolveElizaPluginImportSpecifier(pluginName);
+    if (!RUNTIME_APP_PLUGIN_SUBPATHS.has(pluginName))
+        return resolved;
+    if (resolved === pluginName)
+        return runtimePluginImportSpecifier(pluginName);
+    if (!resolved.startsWith("file://"))
+        return resolved;
+    const indexPath = fileURLToPath(resolved);
+    if (path.basename(indexPath) !== "index.js")
+        return resolved;
+    const pluginPath = path.join(path.dirname(indexPath), "plugin.js");
+    return existsSync(pluginPath) ? pathToFileURL(pluginPath).href : resolved;
+}
+async function hasNonSymlinkWorkspaceNodeModulesPackage(pluginName) {
+    for (const workspaceRoot of uniquePaths([
+        process.cwd(),
+        ...resolveWorkspaceRoots(),
+    ])) {
+        const candidate = path.join(workspaceRoot, "node_modules", ...pluginName.split("/"));
+        try {
+            const stat = await fs.lstat(candidate);
+            if (stat.isDirectory() && !stat.isSymbolicLink()) {
+                return true;
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Plugin error boundary wrapper
+// ---------------------------------------------------------------------------
+/**
+ * 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, _options) {
+    const wrapped = { ...plugin };
+    // Wrap init if present
+    if (plugin.init) {
+        const originalInit = plugin.init;
+        wrapped.init = async (...args) => {
+            try {
+                return await originalInit(...args);
+            }
+            catch (err) {
+                logger.error(`[eliza] Plugin "${pluginName}" crashed during init: ${formatError(err)}`);
+                throw err;
+            }
+        };
+    }
+    // Wrap providers with error boundaries
+    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(`[eliza] Provider "${provider.name}" (plugin: ${pluginName}) crashed: ${msg}`);
+                    throw err;
+                }
+            },
+        }));
+    }
+    return wrapped;
+}
+// ---------------------------------------------------------------------------
+// Import helpers
+// ---------------------------------------------------------------------------
+/**
+ * Process-local record of plugin package names that have already been imported
+ * in this process. The presence of a name is the decisive, race-free signal
+ * that a module record *may* exist for it — so any subsequent import of the
+ * same name is a hot-reload/re-import that MUST go through staging to bust the
+ * ESM module graph. The cold-boot fast-path is only safe on the very first
+ * import of a name, when this set does not yet contain it.
+ */
+const importedPluginPackageNames = new Set();
+/**
+ * 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. <stateDir>/plugins/installed/foo/).
+ * @param packageName  The npm package name (e.g. "@elizaos/plugin-discord") — used
+ *                     to navigate directly into node_modules when present.
+ */
+export async function importPluginModuleFromPath(installPath, packageName, exportSubpath = ".") {
+    const absPath = path.resolve(installPath);
+    // npm/bun layout:  installPath/node_modules/@scope/name/
+    // git layout:      installPath/ is the package itself
+    const nmCandidate = path.join(absPath, "node_modules", ...packageName.split("/"));
+    let pkgRoot = absPath;
+    try {
+        if ((await fs.stat(nmCandidate)).isDirectory())
+            pkgRoot = nmCandidate;
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+        /* git layout — pkgRoot stays as absPath */
+    }
+    const packageRelativePath = pkgRoot === absPath ? [] : ["node_modules", ...packageName.split("/")];
+    // Cold-boot fast-path (opt-in): on the FIRST import of this package in this
+    // process there is no ESM module record to bust, so staging's recursive
+    // `fs.cp` copy is pure I/O waste + unbounded `.runtime-imports/` growth.
+    // Import in place from the real package root instead, but ONLY when a stable
+    // built `dist/` exists. Any re-import (name already in the set) falls back to
+    // staging so hot-reloads still force a fresh module evaluation.
+    const useColdFastPath = coldImportInPlaceEnabled() &&
+        !importedPluginPackageNames.has(packageName) &&
+        existsSync(path.join(pkgRoot, "dist"));
+    const importRoot = useColdFastPath
+        ? pkgRoot
+        : await stagePluginImportRoot({
+            installRoot: absPath,
+            packageRoot: pkgRoot,
+            packageRelativePath,
+            packageName,
+        });
+    // Record the name BEFORE the import() can fail: if a cold in-place import
+    // throws during module evaluation, the caller's retry re-enters here, finds
+    // the name already recorded, and escalates to staging — a fresh staged URL
+    // busts any poisoned ESM module record left by the failed in-place attempt.
+    importedPluginPackageNames.add(packageName);
+    // Resolve entry point from the chosen import root. The staged path is a
+    // filesystem snapshot so reloads pick up updated relative modules and bundled
+    // dependencies instead of reusing the previous ESM module graph; the cold
+    // fast-path resolves directly from the real package root.
+    const entryPoint = await resolvePackageEntry(importRoot, exportSubpath);
+    return (await import(__rewriteRelativeImportExtension(pathToFileURL(entryPoint).href)));
+}
+async function findNearestNodeModulesDir(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(currentDir, "node_modules");
+        try {
+            if ((await fs.stat(candidate)).isDirectory()) {
+                return candidate;
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+function setLastFailedPlugins(failed) {
+    globalThis[LAST_FAILED_PLUGIN_NAMES] =
+        failed.map((plugin) => plugin.name);
+    globalThis[LAST_FAILED_PLUGIN_DETAILS] = failed.map((plugin) => ({ name: plugin.name, error: plugin.error }));
+}
+export function getLastFailedPluginNames() {
+    return [
+        ...(globalThis[LAST_FAILED_PLUGIN_NAMES] ?? []),
+    ];
+}
+/**
+ * Full {name,error} detail for the plugins that failed to load on the last
+ * resolve pass. getLastFailedPluginNames() returns only names; this preserves
+ * the error message (e.g. a missing-export from a stale @elizaos/* copy) so the
+ * dev boot-history endpoint can surface it without log scraping.
+ */
+export function getLastFailedPluginDetails() {
+    return [
+        ...(globalThis[LAST_FAILED_PLUGIN_DETAILS] ?? []),
+    ];
+}
+async function findAncestorNodeModulesDirs(startDir) {
+    const dirs = [];
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(currentDir, "node_modules");
+        try {
+            if ((await fs.stat(candidate)).isDirectory()) {
+                dirs.push(candidate);
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return dirs;
+        }
+        currentDir = parentDir;
+    }
+}
+async function linkAncestorNodeModulesIfNeeded(params) {
+    const stagedNodeModulesPath = path.join(params.stagedPackageRoot, "node_modules");
+    if (existsSync(stagedNodeModulesPath)) {
+        return;
+    }
+    const ancestorNodeModules = await findNearestNodeModulesDir(params.packageRoot);
+    if (!ancestorNodeModules) {
+        return;
+    }
+    const normalizedInstallRoot = path.resolve(params.installRoot);
+    const normalizedAncestorNodeModules = path.resolve(ancestorNodeModules);
+    if (normalizedAncestorNodeModules ===
+        path.join(normalizedInstallRoot, "node_modules") ||
+        normalizedAncestorNodeModules.startsWith(`${normalizedInstallRoot}${path.sep}`)) {
+        return;
+    }
+    await fs.mkdir(stagedNodeModulesPath, { recursive: true });
+    await linkMissingPackagesFromNodeModules({
+        sourceNodeModulesDir: ancestorNodeModules,
+        targetNodeModulesDir: stagedNodeModulesPath,
+    });
+}
+async function linkMissingPackagesFromNodeModules(params) {
+    const entries = await fs.readdir(params.sourceNodeModulesDir, {
+        withFileTypes: true,
+    });
+    for (const entry of entries) {
+        if (entry.name === ".bin" || entry.name.startsWith(".")) {
+            continue;
+        }
+        const sourcePath = path.join(params.sourceNodeModulesDir, entry.name);
+        const targetPath = path.join(params.targetNodeModulesDir, entry.name);
+        if (entry.isDirectory() && entry.name.startsWith("@")) {
+            await fs.mkdir(targetPath, { recursive: true });
+            const scopedEntries = await fs.readdir(sourcePath, {
+                withFileTypes: true,
+            });
+            for (const scopedEntry of scopedEntries) {
+                if (scopedEntry.name.startsWith(".")) {
+                    continue;
+                }
+                const scopedSourcePath = path.join(sourcePath, scopedEntry.name);
+                const scopedTargetPath = path.join(targetPath, scopedEntry.name);
+                if (existsSync(scopedTargetPath)) {
+                    continue;
+                }
+                if (!scopedEntry.isDirectory() && !scopedEntry.isSymbolicLink()) {
+                    continue;
+                }
+                const linkTarget = scopedEntry.isSymbolicLink()
+                    ? await resolveSymlinkTargetIfPresent(scopedSourcePath)
+                    : scopedSourcePath;
+                if (!linkTarget) {
+                    continue;
+                }
+                try {
+                    await fs.symlink(linkTarget, scopedTargetPath, "dir");
+                }
+                catch (error) {
+                    if (error.code !== "EEXIST") {
+                        throw error;
+                    }
+                }
+            }
+            continue;
+        }
+        if ((!entry.isDirectory() && !entry.isSymbolicLink()) ||
+            existsSync(targetPath)) {
+            continue;
+        }
+        const linkTarget = entry.isSymbolicLink()
+            ? await resolveSymlinkTargetIfPresent(sourcePath)
+            : sourcePath;
+        if (!linkTarget) {
+            continue;
+        }
+        try {
+            await fs.symlink(linkTarget, targetPath, "dir");
+        }
+        catch (error) {
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+    }
+}
+async function resolveSymlinkTargetIfPresent(sourcePath) {
+    try {
+        return await fs.realpath(sourcePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function stageNodeModulesEntries(params) {
+    const entries = await fs.readdir(params.sourceNodeModulesDir, {
+        withFileTypes: true,
+    });
+    for (const entry of entries) {
+        if (entry.name === ".bin" || entry.name.startsWith(".")) {
+            continue;
+        }
+        const sourcePath = path.join(params.sourceNodeModulesDir, entry.name);
+        const targetPath = path.join(params.targetNodeModulesDir, entry.name);
+        if (entry.isDirectory() && entry.name.startsWith("@")) {
+            await fs.mkdir(targetPath, { recursive: true });
+            const scopedEntries = await fs.readdir(sourcePath, {
+                withFileTypes: true,
+            });
+            for (const scopedEntry of scopedEntries) {
+                if (scopedEntry.name.startsWith(".")) {
+                    continue;
+                }
+                const scopedSourcePath = path.join(sourcePath, scopedEntry.name);
+                const scopedTargetPath = path.join(targetPath, scopedEntry.name);
+                if (existsSync(scopedTargetPath)) {
+                    continue;
+                }
+                if (scopedEntry.isSymbolicLink()) {
+                    const linkTarget = await resolveSymlinkTargetIfPresent(scopedSourcePath);
+                    if (!linkTarget)
+                        continue;
+                    await fs.symlink(linkTarget, scopedTargetPath);
+                    continue;
+                }
+                if (!scopedEntry.isDirectory()) {
+                    continue;
+                }
+                await fs.cp(scopedSourcePath, scopedTargetPath, {
+                    recursive: true,
+                    force: true,
+                    dereference: true,
+                });
+            }
+            continue;
+        }
+        if (existsSync(targetPath)) {
+            continue;
+        }
+        if (entry.isSymbolicLink()) {
+            const linkTarget = await resolveSymlinkTargetIfPresent(sourcePath);
+            if (!linkTarget)
+                continue;
+            await fs.symlink(linkTarget, targetPath);
+            continue;
+        }
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        await fs.cp(sourcePath, targetPath, {
+            recursive: true,
+            force: true,
+            dereference: true,
+        });
+    }
+}
+function stageAllHoistedNodeModulesEnabled() {
+    const raw = process.env.ELIZA_STAGE_ALL_HOISTED_NODE_MODULES;
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function stageFullPluginPackageEnabled() {
+    const raw = process.env.ELIZA_STAGE_FULL_PLUGIN_PACKAGE;
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+/**
+ * Cold-boot fast-path opt-in. When enabled, the *first* import of a given
+ * plugin package in this process is loaded in place from its real package root
+ * — skipping the `fs.cp` staging copy — provided a built `dist/` is present.
+ *
+ * Staging exists only to bust the ESM module graph when hot-reloading a mutated
+ * plugin (a fresh staged URL forces re-evaluation since ESM has no
+ * cache-eviction API). On a cold boot the plugin was never imported, so there
+ * is no module record to bust and staging is pure I/O waste. Default OFF; only
+ * the literal "1"/"true"/"yes" enables it.
+ */
+function coldImportInPlaceEnabled() {
+    const raw = process.env.ELIZA_PLUGIN_COLD_IMPORT_IN_PLACE;
+    if (!raw)
+        return false;
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+const DEFAULT_PLUGIN_INSTANCE_KEEP = 3;
+function pluginInstanceKeepCount() {
+    const raw = process.env.ELIZA_PLUGIN_INSTANCE_KEEP;
+    if (!raw)
+        return DEFAULT_PLUGIN_INSTANCE_KEEP;
+    const parsed = Number.parseInt(raw.trim(), 10);
+    if (!Number.isFinite(parsed) || parsed < 1) {
+        return DEFAULT_PLUGIN_INSTANCE_KEEP;
+    }
+    return parsed;
+}
+/**
+ * Prune sibling plugin staging directories under `stagingBaseDir`, keeping
+ * only the `keepCount` newest by mtime. Each call to `stagePluginImportRoot`
+ * mints a new `mkdtemp` directory and the previous ones are never reused, so
+ * without this cleanup the directory grows unbounded — on long-running dev
+ * boxes the same plugin can accumulate thousands of stale installs (each
+ * carrying its own `node_modules` copy) and consume hundreds of GB.
+ *
+ * Failures are logged but never thrown — staging the new install must not be
+ * blocked by failure to clean up old ones.
+ *
+ * Exported for unit testing.
+ */
+export async function pruneStalePluginInstances(stagingBaseDir, keepCount) {
+    let entries;
+    try {
+        entries = await fs.readdir(stagingBaseDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const candidates = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const fullPath = path.join(stagingBaseDir, entry.name);
+        try {
+            const stat = await fs.stat(fullPath);
+            candidates.push({ path: fullPath, mtimeMs: stat.mtimeMs });
+        }
+        catch {
+            // dir vanished concurrently — fine, skip it
+        }
+    }
+    if (candidates.length <= keepCount)
+        return;
+    candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    const toDelete = candidates.slice(keepCount);
+    let deleted = 0;
+    for (const victim of toDelete) {
+        try {
+            await fs.rm(victim.path, { recursive: true, force: true });
+            deleted += 1;
+        }
+        catch (error) {
+            logger.warn(`[eliza] Failed to prune stale plugin instance ${victim.path}: ${formatError(error)}`);
+        }
+    }
+    if (deleted > 0) {
+        logger.debug(`[eliza] Pruned ${deleted} stale plugin instance(s) under ${stagingBaseDir}, kept newest ${keepCount}`);
+    }
+}
+function createPluginPackageStageFilter(packageRoot) {
+    const distPath = path.join(packageRoot, "dist");
+    const stageBuiltPackageOnly = existsSync(distPath) && !stageFullPluginPackageEnabled();
+    return (src) => {
+        const relativePath = path.relative(packageRoot, src);
+        if (!relativePath)
+            return true;
+        const [topLevel] = relativePath.split(path.sep);
+        if (topLevel === "node_modules")
+            return false;
+        if (stageBuiltPackageOnly) {
+            return topLevel === "dist" || relativePath === "package.json";
+        }
+        return ![
+            ".turbo",
+            "coverage",
+            "docs",
+            "node_modules",
+            "public_src",
+            "test",
+            "__tests__",
+        ].includes(topLevel);
+    };
+}
+async function linkHoistedNodeModulesPackages(params) {
+    const stagedNodeModulesPath = path.join(params.stagedPackageRoot, "node_modules");
+    if (!existsSync(stagedNodeModulesPath)) {
+        return;
+    }
+    const stagedNodeModulesStat = await fs.lstat(stagedNodeModulesPath);
+    if (stagedNodeModulesStat.isSymbolicLink()) {
+        return;
+    }
+    const normalizedInstallRoot = path.resolve(params.installRoot);
+    const internalNodeModulesRoot = path.join(normalizedInstallRoot, "node_modules");
+    const ancestorNodeModulesDirs = await findAncestorNodeModulesDirs(path.dirname(params.packageRoot));
+    for (const ancestorNodeModules of ancestorNodeModulesDirs) {
+        const normalizedAncestorNodeModules = path.resolve(ancestorNodeModules);
+        if (normalizedAncestorNodeModules === internalNodeModulesRoot ||
+            normalizedAncestorNodeModules.startsWith(`${normalizedInstallRoot}${path.sep}`)) {
+            continue;
+        }
+        await linkMissingPackagesFromNodeModules({
+            sourceNodeModulesDir: ancestorNodeModules,
+            targetNodeModulesDir: stagedNodeModulesPath,
+        });
+    }
+}
+async function stagePluginImportRoot(params) {
+    const stagingBaseDir = path.join(resolveStateDir(), "plugins", ".runtime-imports", sanitizePluginCacheSegment(params.packageName));
+    await fs.mkdir(stagingBaseDir, { recursive: true });
+    // Prune BEFORE mkdtemp so concurrent stages of the same plugin can't have
+    // their just-minted (still-empty) sibling deleted by another process's pruner
+    // that ranks it as the oldest in the batch.
+    await pruneStalePluginInstances(stagingBaseDir, pluginInstanceKeepCount());
+    const stagingDir = await fs.mkdtemp(path.join(stagingBaseDir, `${Date.now()}-${crypto.randomUUID()}-`));
+    const stagedInstallRoot = path.join(stagingDir, "root");
+    const stagedPackageRoot = params.packageRelativePath.length > 0
+        ? path.join(stagedInstallRoot, ...params.packageRelativePath)
+        : stagedInstallRoot;
+    await fs.mkdir(path.dirname(stagedPackageRoot), { recursive: true });
+    await fs.cp(params.packageRoot, stagedPackageRoot, {
+        recursive: true,
+        force: true,
+        dereference: false,
+        filter: createPluginPackageStageFilter(params.packageRoot),
+    });
+    const installNodeModulesPath = path.join(params.installRoot, "node_modules");
+    try {
+        if ((await fs.stat(installNodeModulesPath)).isDirectory()) {
+            const stagedInstallNodeModulesPath = path.join(stagedInstallRoot, "node_modules");
+            await fs.mkdir(stagedInstallNodeModulesPath, { recursive: true });
+            await stageNodeModulesEntries({
+                sourceNodeModulesDir: installNodeModulesPath,
+                targetNodeModulesDir: stagedInstallNodeModulesPath,
+            });
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    if (params.packageRoot !== params.installRoot) {
+        const packageNodeModulesPath = path.join(params.packageRoot, "node_modules");
+        try {
+            if ((await fs.stat(packageNodeModulesPath)).isDirectory()) {
+                const stagedPackageNodeModulesPath = path.join(stagedPackageRoot, "node_modules");
+                await fs.mkdir(stagedPackageNodeModulesPath, { recursive: true });
+                await stageNodeModulesEntries({
+                    sourceNodeModulesDir: packageNodeModulesPath,
+                    targetNodeModulesDir: stagedPackageNodeModulesPath,
+                });
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    await ensureStagedPackageDependencies({
+        installRoot: params.installRoot,
+        packageName: params.packageName,
+        packageRoot: params.packageRoot,
+        stagedPackageRoot,
+    });
+    const shouldLinkHoistedWorkspaceDeps = stageAllHoistedNodeModulesEnabled() ||
+        params.packageName.startsWith("@elizaos/app-") ||
+        params.packageName.startsWith("@elizaos/plugin-");
+    if (shouldLinkHoistedWorkspaceDeps) {
+        await linkAncestorNodeModulesIfNeeded({
+            installRoot: params.installRoot,
+            packageRoot: params.packageRoot,
+            stagedPackageRoot,
+        });
+        await linkHoistedNodeModulesPackages({
+            installRoot: params.installRoot,
+            packageRoot: params.packageRoot,
+            stagedPackageRoot,
+        });
+    }
+    return stagedPackageRoot;
+}
+/**
+ * Resolve a statically-imported @elizaos plugin by name.
+ * Returns the module if found in STATIC_ELIZA_PLUGINS, otherwise null.
+ */
+function resolveStaticElizaPlugin(pluginName) {
+    return STATIC_ELIZA_PLUGINS[pluginName] ?? null;
+}
+/**
+ * In-process cache for {@link discoverPluginCandidates}. `resolvePlugins` runs
+ * twice per boot (blocking phase, then deferred phase), and on a dev box the
+ * scope walk touches ~180 `node_modules/@elizaos/*` dirs plus ~185 workspace
+ * `plugins/*` package.json reads each time. The candidate set only changes when
+ * a package is added or removed on disk, which bumps the parent directory's
+ * mtime, so we key the cache on the mtimes of every scanned root and reuse the
+ * result while the signature is unchanged.
+ */
+let pluginCandidateCache = null;
+/**
+ * In-process cache for {@link evaluatePluginManifests}. `discoverPluginCandidates`
+ * is memoized, but the manifest evaluator still re-reads every candidate's
+ * package.json and re-runs each plugin's `shouldEnable(ctx)` on every
+ * `resolvePlugins` call — duplicated work across the two-phase (blocking +
+ * deferred) boot. Verdicts are a pure function of (candidate set, env, config,
+ * platform); we key the cache on the candidate signature plus a fingerprint of
+ * those inputs so the deferred pass reuses the blocking pass's result while
+ * nothing has changed, and recomputes the moment any input that could flip a
+ * verdict changes (e.g. first-run config rewrite).
+ */
+let pluginVerdictCache = null;
+/**
+ * Fingerprint the inputs `shouldEnable(ctx)` predicates may read. `shouldEnable`
+ * can consult any env var or config field, so the fingerprint covers the whole
+ * env + serialized config + platform flag — invalidating the verdict cache on
+ * any change that could alter a verdict. Cheap relative to the ~180 disk reads
+ * and dynamic dispatches the evaluator performs.
+ */
+function computeVerdictFingerprint(config, isNativePlatform) {
+    const env = Object.entries(process.env)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([k, v]) => `${k}=${v ?? ""}`)
+        .join(" ");
+    return `${isNativePlatform ? "1" : "0"}
${env}
${JSON.stringify(config)}`;
+}
+/**
+ * Cheap signature over the directories {@link discoverPluginCandidates} scans:
+ * the mtimeMs of each `node_modules/@elizaos` and `plugins` root. Adding or
+ * removing a package mutates the containing directory's mtime, invalidating the
+ * cache. Missing directories contribute a sentinel so the signature still
+ * changes when one appears.
+ */
+async function computePluginCandidateSignature() {
+    const parts = [];
+    for (const root of resolveWorkspaceRoots()) {
+        for (const dir of [
+            path.join(root, "node_modules", "@elizaos"),
+            path.join(root, "plugins"),
+        ]) {
+            try {
+                const stat = await fs.stat(dir);
+                parts.push(`${dir}:${stat.mtimeMs}`);
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    parts.push(`${dir}:absent`);
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    return parts.join("|");
+}
+/**
+ * Walk the @elizaos scope in node_modules + workspace `plugins/` dirs and
+ * return every package that has a `package.json`. The manifest evaluator
+ * filters these down to the ones that actually declare an `elizaos.plugin`
+ * block — this discovery step is intentionally cheap (a single readdir + stat
+ * per candidate, no module imports). Result is memoized for the process while
+ * the scanned directories' mtimes are unchanged (see {@link pluginCandidateCache}).
+ */
+async function discoverPluginCandidates() {
+    const signature = await computePluginCandidateSignature();
+    if (pluginCandidateCache?.signature === signature) {
+        return pluginCandidateCache.candidates;
+    }
+    const candidates = await discoverPluginCandidatesUncached();
+    pluginCandidateCache = { signature, candidates };
+    return candidates;
+}
+async function discoverPluginCandidatesUncached() {
+    const seen = new Set();
+    const candidates = [];
+    const tryAdd = async (pkgRoot, pkgName) => {
+        if (seen.has(pkgName))
+            return;
+        if (!(await pathEntryExists(path.join(pkgRoot, "package.json"))))
+            return;
+        seen.add(pkgName);
+        candidates.push({ packageName: pkgName, packageRoot: pkgRoot });
+    };
+    // 1. node_modules/@elizaos/* — covers npm-installed plugins and dev symlinks
+    //    pointing at workspace packages.
+    for (const root of resolveWorkspaceRoots()) {
+        const elizaScope = path.join(root, "node_modules", "@elizaos");
+        let entries;
+        try {
+            entries = (await fs.readdir(elizaScope, {
+                withFileTypes: true,
+            }));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() && !entry.isSymbolicLink())
+                continue;
+            if (entry.name.startsWith("."))
+                continue;
+            // Only plugin/app packages — skip core, shared, agent, ui, etc. (those
+            // aren't auto-enable participants and reading their package.json is
+            // wasted work).
+            if (!entry.name.startsWith("plugin-") && !entry.name.startsWith("app-")) {
+                continue;
+            }
+            const pkgRoot = path.join(elizaScope, entry.name);
+            await tryAdd(pkgRoot, `@elizaos/${entry.name}`);
+        }
+    }
+    // 2. workspace `plugins/` dir — covers cases where the plugin is in the
+    //    repo source tree without a matching node_modules link. Cheap
+    //    fall-through.
+    for (const root of resolveWorkspaceRoots()) {
+        const pluginsDir = path.join(root, "plugins");
+        let entries;
+        try {
+            entries = (await fs.readdir(pluginsDir, {
+                withFileTypes: true,
+            }));
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (!entry.name.startsWith("plugin-") && !entry.name.startsWith("app-")) {
+                continue;
+            }
+            // Some workspace plugins keep their package at `<name>/typescript`; try
+            // the typescript subdir first, fall back to the dir itself.
+            const tsRoot = path.join(pluginsDir, entry.name, "typescript");
+            const tsManifest = path.join(tsRoot, "package.json");
+            if (await pathEntryExists(tsManifest)) {
+                try {
+                    const raw = await fs.readFile(tsManifest, "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed.name)
+                        await tryAdd(tsRoot, parsed.name);
+                }
+                catch {
+                    // ignore unreadable / malformed
+                }
+                continue;
+            }
+            const flatRoot = path.join(pluginsDir, entry.name);
+            const flatManifest = path.join(flatRoot, "package.json");
+            if (await pathEntryExists(flatManifest)) {
+                try {
+                    const raw = await fs.readFile(flatManifest, "utf8");
+                    const parsed = JSON.parse(raw);
+                    if (parsed.name)
+                        await tryAdd(flatRoot, parsed.name);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    return candidates;
+}
+export async function resolvePlugins(config, opts) {
+    const plugins = [];
+    const failedPlugins = [];
+    const repairedInstallRecords = new Set();
+    const phase = opts?.phase ?? "all";
+    // NOTE: Auto-enable runs before dependency validation intentionally.
+    // It returns a new config object (structuredClone under the hood) with
+    // `plugins.allow` populated based on env vars and connector configuration.
+    // We have to USE the returned config for collectPluginNames — the previous
+    // code discarded the return value and kept using the original `config`,
+    // which meant every env-gated plugin (plugin-wallet, etc.) was
+    // silently dropped. Capture the result and assign back so both the allow
+    // list and any downstream config reads see the mutation.
+    //
+    // Auto-enable is sourced exclusively from per-plugin manifests: walk every
+    // @elizaos/* package.json on disk and run each plugin's
+    // autoEnableModule.shouldEnable(ctx). Each plugin owns its own enable
+    // conditions in auto-enable.ts — no central map exists.
+    //
+    // App-level manifest (host app's package.json `elizaos.app` block) can:
+    //   - restrict the candidate list to a curated subset
+    //   - prepopulate config.plugins.entries with default { enabled } flags
+    //     (user config still wins; defaults only fill keys the user hasn't set)
+    const changes = [];
+    try {
+        const appManifest = await readAppManifest(process.cwd()).catch(() => null);
+        const defaultedEntries = applyAppManifestDefaults(config, appManifest);
+        if (defaultedEntries.length > 0) {
+            logger.info(`[eliza] App manifest defaults applied to entries: ${defaultedEntries.join(", ")}`);
+        }
+        const allCandidates = await discoverPluginCandidates();
+        const candidates = filterCandidatesByAppManifest(allCandidates, appManifest);
+        if (appManifest?.candidates && candidates.length < allCandidates.length) {
+            logger.info(`[eliza] App manifest restricted candidate set: ${candidates.length}/${allCandidates.length} plugins considered`);
+        }
+        const isNativePlatform = isMobilePlatform();
+        const candidateKey = candidates
+            .map((c) => c.packageName)
+            .sort()
+            .join(",");
+        const verdictKey = `${candidateKey}\n${computeVerdictFingerprint(config, isNativePlatform)}`;
+        let verdicts;
+        if (pluginVerdictCache?.key === verdictKey) {
+            verdicts = pluginVerdictCache.verdicts;
+        }
+        else {
+            verdicts = await evaluatePluginManifests(candidates, {
+                env: process.env,
+                config,
+                isNativePlatform,
+            });
+            pluginVerdictCache = { key: verdictKey, verdicts };
+        }
+        applyPluginManifestVerdicts(config, verdicts, changes);
+    }
+    catch (err) {
+        logger.warn(`[eliza] Plugin manifest auto-enable failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (changes.length > 0) {
+        logger.info(`[eliza] Plugin auto-enable: ${changes.join("; ")}`);
+    }
+    // Provenance for "why is this package in the load set?" — surfaced when an
+    // optional plugin fails to resolve so logs point at config/env, not "eliza broke".
+    const loadReasons = new Map();
+    const pluginsToLoad = collectPluginNames(config, loadReasons);
+    const corePluginSet = new Set(CORE_PLUGINS);
+    const blockingPluginSet = new Set(BLOCKING_CORE_PLUGINS);
+    const forceIncludePluginNames = new Set(opts?.forceIncludePluginNames ?? []);
+    // Build a mutable map of install records so we can merge drop-in discoveries
+    const installRecords = {
+        ...(config.plugins?.installs ?? {}),
+    };
+    const denyList = new Set((config.plugins?.deny || []));
+    const envSkipPlugins = (process.env.ELIZA_SKIP_PLUGINS ?? "")
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+    for (const pluginName of envSkipPlugins) {
+        denyList.add(pluginName);
+    }
+    if (envSkipPlugins.length > 0) {
+        logger.info(`[eliza] Skipping ${envSkipPlugins.length} plugin(s) via ELIZA_SKIP_PLUGINS: ${envSkipPlugins.join(", ")}`);
+    }
+    for (const pluginName of denyList) {
+        pluginsToLoad.delete(pluginName);
+        const canonical = resolvePluginPackageAlias(pluginName);
+        if (canonical !== pluginName) {
+            pluginsToLoad.delete(canonical);
+        }
+    }
+    // ── Auto-discover ejected plugins ───────────────────────────────────────
+    // Ejected plugins override npm/core versions, so they are tracked
+    // separately and consulted first at import time.
+    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);
+        if (!loadReasons.has(name))
+            loadReasons.set(name, "ejected plugins dir");
+        ejectedPluginNames.push(name);
+    }
+    if (ejectedPluginNames.length > 0) {
+        logger.info(`[eliza] Discovered ${ejectedPluginNames.length} ejected plugin(s): ${ejectedPluginNames.join(", ")}`);
+    }
+    // ── Auto-discover drop-in custom plugins ────────────────────────────────
+    // Scan well-known dir + any extra dirs from plugins.load.paths (first wins).
+    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;
+        }
+    }
+    // Merge into load set — deny list and core collisions are filtered out.
+    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(`[eliza] Discovered ${customPluginNames.length} custom plugin(s): ${customPluginNames.join(", ")}`);
+    }
+    if (phase !== "all") {
+        const beforePhaseFilter = pluginsToLoad.size;
+        for (const pluginName of Array.from(pluginsToLoad)) {
+            if (forceIncludePluginNames.has(pluginName)) {
+                continue;
+            }
+            const isBlocking = blockingPluginSet.has(pluginName);
+            if ((phase === "blocking" && !isBlocking) ||
+                (phase === "deferred" && isBlocking)) {
+                pluginsToLoad.delete(pluginName);
+            }
+        }
+        logger.info(`[eliza] Plugin resolution phase=${phase}: ${pluginsToLoad.size}/${beforePhaseFilter} plugin(s) selected`);
+    }
+    logger.info(`[eliza] Resolving ${pluginsToLoad.size} plugins...`);
+    const loadStartTime = Date.now();
+    // Built once so we don't rebuild on every optional plugin failure.
+    const optionalPluginNames = new Set([
+        ...Object.values(OPTIONAL_PLUGIN_MAP),
+        ...Object.values(CHANNEL_PLUGIN_MAP),
+        ...OPTIONAL_CORE_PLUGINS,
+    ]);
+    // Load a single plugin - returns result or null on skip/failure
+    async function loadSinglePlugin(pluginName) {
+        const isCore = corePluginSet.has(pluginName);
+        const isOfficialElizaPlugin = pluginName.startsWith("@elizaos/plugin-");
+        const ejectedRecord = ejectedRecords[pluginName];
+        const installRecord = installRecords[pluginName];
+        const workspaceOverridePath = getWorkspacePluginOverridePath(pluginName);
+        const staticElizaPlugin = await resolveStaticElizaPlugin(pluginName);
+        const exportSubpath = runtimePluginExportSubpath(pluginName);
+        const importOfficialPluginFromNodeModules = async () => (await import(__rewriteRelativeImportExtension(resolveRuntimePluginImportSpecifier(pluginName))));
+        // Pre-flight: opportunistically prepare special plugin dependencies.
+        // For plugin-browser, stagehand-server is only needed by the optional
+        // `stagehand` backend. The app workspace and Chrome/Safari bridge backends
+        // do not require it, and native mobile should prefer the app browser
+        // surface anyway.
+        if (pluginName === "@elizaos/plugin-browser") {
+            if (!ensureBrowserServerLink()) {
+                const platform = (process.env.ELIZA_MOBILE_PLATFORM ??
+                    process.env.ELIZA_PLATFORM ??
+                    process.env.CAPACITOR_PLATFORM ??
+                    "").toLowerCase();
+                const mobile = platform === "ios" || platform === "android" || platform === "mobile";
+                const message = "[eliza] plugin-browser: stagehand-server binary not found — loading app workspace and bridge browser backends anyway. " +
+                    "The optional `stagehand` fallback will stay disabled until plugins/plugin-browser/stagehand-server is built or a STAGEHAND_SERVER_URL is configured.";
+                if (mobile) {
+                    logger.debug(`${message} Native mobile prefers the app browser.`);
+                }
+                else {
+                    logger.info(message);
+                }
+            }
+        }
+        try {
+            let mod;
+            if (ejectedRecord?.installPath) {
+                // Ejected plugin — always prefer local source over npm/core.
+                logger.debug(`[eliza] Loading ejected plugin: ${pluginName} from ${ejectedRecord.installPath}`);
+                mod = await importPluginModuleFromPath(ejectedRecord.installPath, pluginName, exportSubpath);
+            }
+            else if (staticElizaPlugin) {
+                // Prefer statically imported official plugins over workspace staging.
+                // This keeps local node_modules links working while avoiding staging
+                // bugs in workspace packages with nested symlinked dependencies.
+                mod = staticElizaPlugin;
+            }
+            else if (pluginName === "@elizaos/plugin-sql") {
+                // Mobile bundles run without a node_modules tree. The static plugin
+                // registry is the normal fast path, but use a literal import fallback
+                // so Bun can still inline the required SQL plugin if module init order
+                // leaves the registry empty.
+                const sqlPluginModule = await import(
+                /* @vite-ignore */ "@elizaos/plugin-sql");
+                mod = Object.fromEntries(Object.entries(sqlPluginModule));
+            }
+            else if (workspaceOverridePath) {
+                const shouldPreferRepoNodeModules = isOfficialElizaPlugin &&
+                    (await hasNonSymlinkWorkspaceNodeModulesPackage(pluginName));
+                if (shouldPreferRepoNodeModules) {
+                    logger.debug(`[eliza] Loading repo node_modules plugin: ${pluginName}`);
+                    try {
+                        mod = await importOfficialPluginFromNodeModules();
+                    }
+                    catch (error) {
+                        logger.warn(`[eliza] Repo node_modules plugin import failed for ${pluginName}; falling back to workspace override: ${formatError(error)}`);
+                        mod = await importPluginModuleFromPath(workspaceOverridePath, pluginName, exportSubpath);
+                    }
+                }
+                else {
+                    logger.debug(`[eliza] Loading workspace plugin override: ${pluginName} from ${workspaceOverridePath}`);
+                    // Always stage workspace overrides instead of re-importing the bare
+                    // package specifier from node_modules. Bun can wedge a subsequent
+                    // restart when an earlier bare import of the same specifier failed
+                    // during module evaluation. Staging also guarantees local edits reload.
+                    mod = await importPluginModuleFromPath(workspaceOverridePath, pluginName, exportSubpath);
+                }
+            }
+            else if (installRecord?.installPath) {
+                // Prefer bundled/node_modules copies for official Eliza plugins.
+                if (isOfficialElizaPlugin) {
+                    try {
+                        mod = await importOfficialPluginFromNodeModules();
+                        if (repairBrokenInstallRecord(config, pluginName)) {
+                            repairedInstallRecords.add(pluginName);
+                        }
+                    }
+                    catch (npmErr) {
+                        logger.warn(`[eliza] Node_modules resolution failed for ${pluginName} (${formatError(npmErr)}). Trying installed path at ${redactUserSegments(installRecord.installPath)}.`);
+                        mod = await importPluginModuleFromPath(installRecord.installPath, pluginName, exportSubpath);
+                    }
+                }
+                else {
+                    // User-installed plugin — load from its install directory on disk.
+                    try {
+                        mod = await importPluginModuleFromPath(installRecord.installPath, pluginName, exportSubpath);
+                    }
+                    catch (installErr) {
+                        logger.warn(`[eliza] Installed plugin ${pluginName} failed at ${redactUserSegments(installRecord.installPath)} (${formatError(installErr)}). Falling back to node_modules resolution.`);
+                        const staticMod = await resolveStaticElizaPlugin(pluginName);
+                        mod = staticMod
+                            ? staticMod
+                            : (await import(__rewriteRelativeImportExtension(runtimePluginImportSpecifier(pluginName))));
+                        if (repairBrokenInstallRecord(config, pluginName)) {
+                            repairedInstallRecords.add(pluginName);
+                        }
+                    }
+                }
+            }
+            else if (isOfficialElizaPlugin) {
+                // Mobile bundles have no node_modules tree. If the plugin wasn't
+                // pre-registered in STATIC_ELIZA_PLUGINS it can't be loaded — skip it.
+                if (isMobilePlatform()) {
+                    return null;
+                }
+                // Eliza plugins can resolve either from bundled local wrappers
+                // under eliza-dist/plugins/* or from packaged node_modules.
+                mod = await importOfficialPluginFromNodeModules();
+            }
+            else {
+                // Built-in/npm plugin — prefer a bundled static import regardless of
+                // naming convention (short-name plugins like "agent-orchestrator" are
+                // registered in STATIC_ELIZA_PLUGINS and would otherwise fail a bare
+                // node_modules resolution).
+                mod = staticElizaPlugin
+                    ? staticElizaPlugin
+                    : (await import(__rewriteRelativeImportExtension(runtimePluginImportSpecifier(pluginName))));
+            }
+            const pluginInstance = findRuntimePluginExport(mod);
+            if (pluginInstance) {
+                // Wrap the plugin's init function with an error boundary.
+                // Core plugins re-throw on init failure; optional plugins degrade gracefully.
+                const wrappedPlugin = wrapPluginWithErrorBoundary(pluginName, pluginInstance, { isCore });
+                logger.debug(`[eliza] ✓ Loaded plugin: ${pluginName}`);
+                return { name: pluginName, plugin: wrappedPlugin };
+            }
+            else {
+                const msg = `[eliza] 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(`[eliza] Failed to load core plugin ${pluginName}: ${msg}`);
+            }
+            else {
+                if (optionalPluginNames.has(pluginName)) {
+                    if (!isBenignOptionalPluginFailure(msg)) {
+                        logger.warn(`[eliza] Optional plugin ${pluginName} failed to load: ${msg}`);
+                    }
+                }
+                else {
+                    logger.info(`[eliza] Could not load plugin ${pluginName}: ${msg}`);
+                }
+            }
+            return null;
+        }
+    }
+    // Load all plugins in parallel for faster startup.
+    // SECURITY NOTE: Plugins that modify process.env during import or init
+    // may race with each other. This is an accepted trade-off for startup
+    // performance. Critical env vars (database, AI provider keys) are set
+    // before this point in buildCharacterFromConfig / resolveDbEnv.
+    const serializePluginLoads = process.env.ELIZA_SERIALIZE_PLUGIN_LOADS === "1";
+    // The deferred phase runs in the background after the API server is already
+    // listening, so it must not starve it. Plugin imports are CPU-bound module
+    // evaluation (TS transpile + eval); a `Promise.all` burst hogs the single
+    // event loop for the whole batch, blocking /api/health (and the readiness
+    // flip) until it drains. For the deferred phase, load sequentially and yield
+    // to the event loop (setImmediate) between each import so the bound HTTP
+    // server can serve liveness/readiness mid-burst. Parallelism buys little here
+    // anyway — the work is CPU-bound on one thread. Blocking/all phases gate boot
+    // and keep the parallel path. Mirrors the deferred static-plugin scheduling.
+    const yieldBetweenLoads = phase === "deferred" && !serializePluginLoads;
+    logger.info(`[eliza] Loading ${pluginsToLoad.size} plugins${serializePluginLoads ? " sequentially" : yieldBetweenLoads ? " (deferred, yielding)" : ""}...`);
+    const pluginResults = serializePluginLoads || yieldBetweenLoads
+        ? await (async () => {
+            const results = [];
+            let index = 0;
+            for (const pluginName of pluginsToLoad) {
+                index += 1;
+                if (serializePluginLoads) {
+                    logger.info(`[eliza] Loading plugin ${index}/${pluginsToLoad.size}: ${pluginName}`);
+                }
+                results.push(await loadSinglePlugin(pluginName));
+                if (yieldBetweenLoads) {
+                    await new Promise((resolve) => {
+                        setImmediate(resolve);
+                    });
+                }
+            }
+            return results;
+        })()
+        : await Promise.all(Array.from(pluginsToLoad).map(loadSinglePlugin));
+    // Collect successful loads
+    for (const result of pluginResults) {
+        if (result) {
+            plugins.push(result);
+        }
+    }
+    const loadDuration = Date.now() - loadStartTime;
+    logger.info(`[eliza] Plugin loading took ${loadDuration}ms`);
+    // Summary logging — do not treat “optional + not installed” as top-level failures.
+    const optionalFailed = failedPlugins.filter((f) => optionalPluginNames.has(f.name));
+    const seriousFailed = failedPlugins.filter((f) => !optionalPluginNames.has(f.name));
+    const benignOptionalFailed = optionalFailed.filter((f) => isBenignOptionalPluginFailure(f.error));
+    const noisyOptionalFailed = optionalFailed.filter((f) => !isBenignOptionalPluginFailure(f.error));
+    const detailFailures = [...seriousFailed, ...noisyOptionalFailed];
+    let completeMsg = `[eliza] Plugin resolution complete: ${plugins.length}/${pluginsToLoad.size} loaded`;
+    if (detailFailures.length > 0) {
+        completeMsg += `, ${detailFailures.length} failed`;
+    }
+    if (benignOptionalFailed.length > 0) {
+        completeMsg += ` (${benignOptionalFailed.length} optional unavailable)`;
+    }
+    logger.info(completeMsg);
+    if (detailFailures.length > 0) {
+        logger.info(`[eliza] Failed plugins: ${detailFailures.map((f) => `${f.name} (${f.error})`).join(", ")}`);
+    }
+    if (benignOptionalFailed.length > 0) {
+        const withReasons = benignOptionalFailed.map((f) => {
+            const reason = loadReasons.get(f.name);
+            return reason ? `${f.name} (added by: ${reason})` : f.name;
+        });
+        logger.info(`[eliza] Optional plugins not installed: ${withReasons.join(", ")}`);
+    }
+    setLastFailedPlugins(failedPlugins);
+    // Diagnose version-skew issues when AI providers failed to load (#10)
+    const loadedNames = plugins.map((p) => p.name);
+    if (phase !== "blocking") {
+        const diagnostic = diagnoseNoAIProvider(loadedNames, failedPlugins);
+        if (diagnostic) {
+            if (opts?.quiet) {
+                // In headless/GUI mode before first-run setup, this is expected — the user
+                // will configure a provider through first-run setup and restart.
+                logger.info(`[eliza] ${diagnostic}`);
+            }
+            else {
+                logger.error(`[eliza] ${diagnostic}`);
+            }
+        }
+    }
+    // Persist repaired install records so subsequent startups stop importing
+    // from stale install directories.
+    if (repairedInstallRecords.size > 0) {
+        try {
+            saveElizaConfig(config);
+            logger.info(`[eliza] Repaired ${repairedInstallRecords.size} plugin install record(s): ${Array.from(repairedInstallRecords).join(", ")}`);
+        }
+        catch (err) {
+            logger.warn(`[eliza] Failed to persist plugin install repairs: ${formatError(err)}`);
+        }
+    }
+    return plugins;
+}