@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/runtime/eliza.js

@@ -1,3 +1,11 @@
+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;
+};
 /**
  * elizaOS runtime entry point for Eliza.
  *
@@ -8,7 +16,7 @@
  * @module eliza
  */
 import crypto from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, symlinkSync, unlinkSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
 import fs from "node:fs/promises";
 import { createRequire } from "node:module";
 import os from "node:os";
@@ -16,50 +24,270 @@ import path from "node:path";
 import process from "node:process";
 import * as readline from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
-let _clack = null;
-async function loadClack() {
-    if (!_clack)
-        _clack = await import("@clack/prompts");
-    return _clack;
-}
-import { AgentRuntime, AutonomyService, addLogListener, ChannelType, createBasicCapabilitiesPlugin, createMessageMemory, logger, 
-// loggerScope, // removed
-mergeCharacterDefaults, stringToUuid, } from "@elizaos/core";
-import * as pluginAgentOrchestrator from "@elizaos/plugin-agent-orchestrator";
-import * as pluginAgentSkills from "@elizaos/plugin-agent-skills";
-import * as pluginAnthropic from "@elizaos/plugin-anthropic";
-import * as pluginCron from "@elizaos/plugin-cron";
-import * as pluginElizacloud from "@elizaos/plugin-elizacloud";
-import * as pluginExperience from "@elizaos/plugin-experience";
-import * as pluginForm from "@elizaos/plugin-form";
-import * as pluginKnowledge from "@elizaos/plugin-knowledge";
-import * as pluginLocalEmbedding from "@elizaos/plugin-local-embedding";
-import * as pluginOllama from "@elizaos/plugin-ollama";
-import * as pluginOpenai from "@elizaos/plugin-openai";
-import * as pluginPdf from "@elizaos/plugin-pdf";
-import * as pluginPersonality from "@elizaos/plugin-personality";
-import * as pluginPluginManager from "@elizaos/plugin-plugin-manager";
-import * as pluginRolodex from "@elizaos/plugin-rolodex";
-import * as pluginSecretsManager from "@elizaos/plugin-secrets-manager";
-import * as pluginShell from "@elizaos/plugin-shell";
-import * as pluginSql from "@elizaos/plugin-sql";
-import * as pluginTodo from "@elizaos/plugin-todo";
-import * as pluginTrajectoryLogger from "@elizaos/plugin-trajectory-logger";
-import * as pluginTrust from "@elizaos/plugin-trust";
-import { debugLogResolvedContext, validateRuntimeContext, } from "../api/plugin-validation";
-import { configFileExists, loadElizaConfig, saveElizaConfig, } from "../config/config";
-import { collectConfigEnvVars } from "../config/env-vars";
-import { resolveStateDir, resolveUserPath } from "../config/paths";
-import { applyPluginAutoEnable, } from "../config/plugin-auto-enable";
-import { createHookEvent, loadHooks, triggerHook, } from "../hooks/index";
-import { ensureAgentWorkspace, resolveDefaultAgentWorkspaceDir, } from "../providers/workspace";
-import { SandboxAuditLog } from "../security/audit-log";
-import { SandboxManager } from "../services/sandbox-manager";
-import { diagnoseNoAIProvider } from "../services/version-compat";
-import { CORE_PLUGINS, OPTIONAL_CORE_PLUGINS } from "./core-plugins";
-import { createElizaPlugin } from "./eliza-plugin";
-import { detectEmbeddingPreset } from "./embedding-presets";
-import { shouldEnableTrajectoryLoggingByDefault } from "./trajectory-persistence";
+// ---------------------------------------------------------------------------
+// Extracted modules — re-exported for backward compatibility
+// ---------------------------------------------------------------------------
+import { runFirstTimeSetup } from "./first-time-setup.js";
+import { resolveConfigEnvForProcess } from "./operations/vault-bridge.js";
+import { resolvePlugins } from "./plugin-resolver.js";
+import { CUSTOM_PLUGINS_DIRNAME as CUSTOM_RUNTIME_PLUGINS_DIRNAME, STATIC_ELIZA_PLUGINS, } from "./plugin-types.js";
+export { CHANNEL_PLUGIN_MAP, collectPluginNames, OPTIONAL_PLUGIN_MAP, PROVIDER_PLUGIN_MAP, } from "./plugin-collector.js";
+export { CUSTOM_PLUGINS_DIRNAME, EJECTED_PLUGINS_DIRNAME, ensureBrowserServerLink, findPluginBrowserStagehandDir, findRuntimePluginExport, mergeDropInPlugins, repairBrokenInstallRecord, resolveElizaPluginImportSpecifier, resolvePackageEntry, STATIC_ELIZA_PLUGINS, scanDropInPlugins, } from "./plugin-types.js";
+// resolvePlugins is re-exported via index.ts from ./plugin-resolver
+// `@elizaos/app-lifeops` and `@elizaos/app-companion` are NOT eagerly imported
+// here. Both packages transitively import from `@elizaos/agent` (e.g.
+// `hasOwnerAccess` from this package's barrel) — a top-level static import
+// would form a module-init cycle that leaves named exports of the app-lifeops
+// actions array as `undefined`, crashing `runtime.registerPlugin` when it
+// iterates `plugin.actions`.
+//
+// Both apps still resolve at plugin-load time via headless dynamic-import
+// entrypoints in `plugin-resolver.ts`, after the static module graph has fully
+// evaluated, so the cycle never forms and browser-only UI exports stay out of
+// the agent process.
+// Keep this here as a single sentinel: if we ever need a static reference,
+// add `as const` data only — never an `import * as` of an app-* package.
+import { AgentRuntime, AutonomyService, addLogListener, ChannelType, createBasicCapabilitiesPlugin, createMessageMemory, logger, stringToUuid, } from "@elizaos/core";
+import { DEFAULT_ELIZA_CLOUD_TEXT_MODEL, formatError, isElizaSettingsDebugEnabled, isMobilePlatform, migrateLegacyRuntimeConfig, resolveDeploymentTargetInConfig, resolveElizaCloudTopology, resolveServerOnlyPort, resolveServiceRoutingInConfig, settingsDebugCloudSummary, } from "@elizaos/shared";
+async function importAppCoreRuntime() {
+    // Use a string-literal dynamic import (no indirection through a `const`)
+    // so Bun.build can statically follow it and inline `@elizaos/app-core`
+    // into the mobile bundle. The previous indirect form
+    // (`const moduleId = "@elizaos/app-core"; import(moduleId)`) defeated
+    // Bun's resolver and produced a runtime `Cannot find module` on AOSP
+    // where there is no node_modules tree.
+    return import(
+    /* webpackIgnore: true */ "@elizaos/app-core");
+}
+import { buildCharacterFromConfig } from "./build-character-config.js";
+import { resolvePreferredProviderId, resolvePreferredProviderPluginName, resolvePrimaryModel, } from "./model-resolution.js";
+const ELIZAMAKER_MODULE = "@elizaos/app-elizamaker";
+const STEWARD_EVM_BRIDGE_MODULE = "@elizaos/app-steward";
+async function loadElizaMakerModule() {
+    return (await import(__rewriteRelativeImportExtension(
+    /* @vite-ignore */ ELIZAMAKER_MODULE)));
+}
+async function loadStewardEvmBridgeModule() {
+    return (await import(__rewriteRelativeImportExtension(
+    /* @vite-ignore */ STEWARD_EVM_BRIDGE_MODULE)));
+}
+import { debugLogResolvedContext, validateRuntimeContext, } from "../api/plugin-validation.js";
+import { getWalletAddresses, syncSolanaPublicKeyEnv } from "../api/wallet.js";
+import { configFileExists, loadElizaConfig, } from "../config/config.js";
+import { CONNECTOR_ENV_MAP, collectConfigEnvVars, collectConnectorEnvVars, } from "../config/env-vars.js";
+import { resolveStateDir, resolveUserPath } from "../config/paths.js";
+import { createHookEvent, loadHooks, triggerHook, } from "../hooks/index.js";
+import { ensureAgentWorkspace } from "../providers/workspace.js";
+import { SandboxAuditLog } from "../security/audit-log.js";
+import { SandboxManager, } from "../services/sandbox-manager.js";
+import { resolveDefaultAgentWorkspaceDir, shouldBootstrapWorkspaceInitFiles, } from "../shared/workspace-resolution.js";
+import { CORE_PLUGINS, OPTIONAL_CORE_PLUGINS } from "./core-plugins.js";
+import { seedBundledDocuments } from "./default-documents.js";
+import { createElizaPlugin } from "./eliza-plugin.js";
+import { detectEmbeddingPreset } from "./embedding-presets.js";
+import { runtimeDocumentsEnabled, runtimeTrajectoriesEnabled, } from "./native-runtime-features.js";
+import { createPgliteInitError, getPgliteErrorCode, PGLITE_ERROR_CODES, } from "./pglite-error-compat.js";
+import { installRuntimePluginLifecycle } from "./plugin-lifecycle.js";
+import rolesPlugin from "./roles.js";
+import { shouldEnableTrajectoryLoggingByDefault } from "./trajectory-persistence.js";
+function isPluginSqlResolutionError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return (message.includes("Cannot find module '@elizaos/plugin-sql'") ||
+        message.includes('Cannot find module "@elizaos/plugin-sql"') ||
+        (message.includes("@elizaos/plugin-sql") &&
+            (message.includes("ResolveMessage") ||
+                message.includes("Module not found") ||
+                message.includes("could not resolve") ||
+                message.includes("Could not resolve"))));
+}
+async function loadRequiredPluginSql() {
+    try {
+        return await import("@elizaos/plugin-sql");
+    }
+    catch (err) {
+        const sourceEntry = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../../plugins/plugin-sql/src/index.node.ts");
+        if (!isPluginSqlResolutionError(err) || !existsSync(sourceEntry)) {
+            throw err;
+        }
+        logger.debug(`[eliza] Loading @elizaos/plugin-sql from workspace source at ${sourceEntry}`);
+        return (await import(__rewriteRelativeImportExtension(pathToFileURL(sourceEntry).href)));
+    }
+}
+// Agent orchestrator ships as the standalone @elizaos/plugin-agent-orchestrator package.
+const loadOptionalPlugin = async (packageName) => {
+    try {
+        return await import(__rewriteRelativeImportExtension(packageName));
+    }
+    catch {
+        return null;
+    }
+};
+// IMPORTANT: Do NOT pull plugin modules in via top-level `await` at module scope.
+//
+// Bun.build (and any cross-module top-level-await scheduling that follows the
+// ESM spec naively) can emit an `init_eliza()` call that is NOT awaited inside
+// a downstream `init_runtime*` function. When that happens, the
+// `Object.assign(STATIC_ELIZA_PLUGINS, ...)` below has not run yet by the time
+// `loadSinglePlugin("@elizaos/plugin-sql")` is dispatched, and the resolver
+// falls through to a dynamic import that throws
+// "Cannot find module '@elizaos/plugin-sql'" from the bundle path.
+//
+// Solution: lazy-load and memoize each module, and register the static map
+// inside `ensureCoreStaticPluginsRegistered()` which is awaited from every
+// runtime entry point (`startEliza`, `startInCloudMode`).
+let _pluginSqlPromise = null;
+async function getPluginSql() {
+    if (!_pluginSqlPromise) {
+        _pluginSqlPromise = loadRequiredPluginSql();
+    }
+    return _pluginSqlPromise;
+}
+let _pluginLocalEmbeddingPromise = null;
+async function getPluginLocalEmbedding() {
+    if (!_pluginLocalEmbeddingPromise) {
+        _pluginLocalEmbeddingPromise = (async () => {
+            try {
+                return await import("@elizaos/plugin-local-embedding");
+            }
+            catch {
+                return null;
+            }
+        })();
+    }
+    return _pluginLocalEmbeddingPromise;
+}
+const _optionalPluginCache = new Map();
+function getOptionalPlugin(packageName) {
+    const cached = _optionalPluginCache.get(packageName);
+    if (cached)
+        return cached;
+    const promise = loadOptionalPlugin(packageName);
+    _optionalPluginCache.set(packageName, promise);
+    return promise;
+}
+// Personality is bundled in @elizaos/core advanced capabilities (advancedCapabilities).
+let _coreStaticPluginsRegistered = false;
+let _coreStaticPluginsRegistrationPromise = null;
+/**
+ * Resolve and register the baseline `@elizaos/plugin-*` modules into the
+ * shared `STATIC_ELIZA_PLUGINS` map. Called from every runtime entry point
+ * (`startEliza`, `startInCloudMode`, `bootElizaRuntime`) before any caller
+ * touches `loadSinglePlugin`. Memoized so repeated calls are free.
+ *
+ * Why this isn't done at module init:
+ * - Top-level `await` for these modules at module scope creates a
+ *   cross-module TLA dependency that `Bun.build` does not always honor in
+ *   the bundled output (it emits the init call without awaiting it).
+ * - Deferring to an explicit awaited call inside an entry function makes the
+ *   ordering explicit and bundler-independent.
+ */
+export async function ensureCoreStaticPluginsRegistered() {
+    if (_coreStaticPluginsRegistered)
+        return;
+    if (_coreStaticPluginsRegistrationPromise) {
+        await _coreStaticPluginsRegistrationPromise;
+        return;
+    }
+    _coreStaticPluginsRegistrationPromise = (async () => {
+        const [pluginSql, pluginLocalEmbedding, pluginAgentOrchestrator, pluginShell, pluginCommands, pluginVideo, pluginElizacloud, pluginOllama, pluginAnthropic, pluginOpenai,] = await Promise.all([
+            getPluginSql(),
+            getPluginLocalEmbedding(),
+            getOptionalPlugin("@elizaos/plugin-agent-orchestrator"),
+            getOptionalPlugin("@elizaos/plugin-shell"),
+            getOptionalPlugin("@elizaos/plugin-commands"),
+            getOptionalPlugin("@elizaos/plugin-video"),
+            getOptionalPlugin("@elizaos/plugin-elizacloud"),
+            getOptionalPlugin("@elizaos/plugin-ollama"),
+            getOptionalPlugin("@elizaos/plugin-anthropic"),
+            getOptionalPlugin("@elizaos/plugin-openai"),
+        ]);
+        Object.assign(STATIC_ELIZA_PLUGINS, {
+            "@elizaos/plugin-sql": pluginSql,
+            ...(pluginLocalEmbedding
+                ? { "@elizaos/plugin-local-embedding": pluginLocalEmbedding }
+                : {}),
+            // secrets (SECRETS service): now built-in core capability (ENABLE_SECRETS_MANAGER)
+            ...(pluginAgentOrchestrator
+                ? { "agent-orchestrator": pluginAgentOrchestrator }
+                : {}),
+            ...(pluginShell ? { "@elizaos/plugin-shell": pluginShell } : {}),
+            // plugin-manager: now built-in core capability (ENABLE_PLUGIN_MANAGER)
+            ...(pluginCommands ? { "@elizaos/plugin-commands": pluginCommands } : {}),
+            ...(pluginVideo ? { "@elizaos/plugin-video": pluginVideo } : {}),
+            ...(pluginOpenai ? { "@elizaos/plugin-openai": pluginOpenai } : {}),
+            ...(pluginAnthropic
+                ? { "@elizaos/plugin-anthropic": pluginAnthropic }
+                : {}),
+            ...(pluginOllama ? { "@elizaos/plugin-ollama": pluginOllama } : {}),
+            ...(pluginElizacloud
+                ? { "@elizaos/plugin-elizacloud": pluginElizacloud }
+                : {}),
+            // trust: now built-in core capability (ENABLE_TRUST)
+            // `@elizaos/app-lifeops` and `@elizaos/app-companion` are intentionally
+            // omitted from the static map — see the comment near the top of this file.
+            // They resolve via headless dynamic-import entrypoints in plugin-resolver.ts.
+            // personality: now built-in advanced capability (advancedCapabilities: true)
+        });
+        _coreStaticPluginsRegistered = true;
+    })();
+    await _coreStaticPluginsRegistrationPromise;
+}
+let activeSignalShutdownContext = null;
+let signalHandlersRegistered = false;
+let signalShutdownPromise = null;
+function registerSignalShutdownHandlers(context) {
+    activeSignalShutdownContext = context;
+    if (signalHandlersRegistered) {
+        return;
+    }
+    const shutdown = async () => {
+        if (signalShutdownPromise) {
+            await signalShutdownPromise;
+            return;
+        }
+        signalShutdownPromise = (async () => {
+            const current = activeSignalShutdownContext;
+            if (!current) {
+                process.exit(0);
+            }
+            try {
+                await current?.beforeShutdown?.();
+            }
+            catch (err) {
+                logger.warn(`[eliza] Pre-shutdown cleanup error: ${formatError(err)}`);
+            }
+            try {
+                const sandboxManager = current?.getSandboxManager();
+                if (sandboxManager) {
+                    try {
+                        await sandboxManager.stop();
+                        logger.info("[eliza] Sandbox manager stopped");
+                    }
+                    catch (err) {
+                        logger.warn(`[eliza] Sandbox stop error: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn(`[eliza] Sandbox shutdown error: ${formatError(err)}`);
+            }
+            try {
+                const runtime = current?.getRuntime();
+                if (runtime) {
+                    await shutdownRuntime(runtime, "signal shutdown");
+                }
+            }
+            catch (err) {
+                logger.warn(`[eliza] Error during shutdown: ${formatError(err)}`);
+            }
+            process.exit(0);
+        })();
+        await signalShutdownPromise;
+    };
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+    signalHandlersRegistered = true;
+}
 /**
  * Map of baseline bundled @elizaos plugin names to their statically imported
  * modules.
@@ -67,31 +295,14 @@ import { shouldEnableTrajectoryLoggingByDefault } from "./trajectory-persistence
  * Post-release plugins are intentionally excluded so the packaged runtime can
  * ship a smaller baseline bundle. Those plugins fall through to dynamic
  * import() and can be installed later via the plugin installer.
+ *
+ * The actual `Object.assign(STATIC_ELIZA_PLUGINS, ...)` registration runs
+ * inside `ensureCoreStaticPluginsRegistered()` (defined above), which is
+ * called at the top of every runtime entry point. Doing it there instead of
+ * at module init avoids a `Bun.build` cross-module top-level-await scheduling
+ * bug that strands `@elizaos/plugin-sql` undefined in the bundled runtime.
  */
-const STATIC_ELIZA_PLUGINS = {
-    "@elizaos/plugin-sql": pluginSql,
-    "@elizaos/plugin-local-embedding": pluginLocalEmbedding,
-    "@elizaos/plugin-secrets-manager": pluginSecretsManager,
-    "@elizaos/plugin-form": pluginForm,
-    "@elizaos/plugin-knowledge": pluginKnowledge,
-    "@elizaos/plugin-rolodex": pluginRolodex,
-    "@elizaos/plugin-trajectory-logger": pluginTrajectoryLogger,
-    "@elizaos/plugin-agent-orchestrator": pluginAgentOrchestrator,
-    "@elizaos/plugin-cron": pluginCron,
-    "@elizaos/plugin-shell": pluginShell,
-    "@elizaos/plugin-plugin-manager": pluginPluginManager,
-    "@elizaos/plugin-agent-skills": pluginAgentSkills,
-    "@elizaos/plugin-pdf": pluginPdf,
-    "@elizaos/plugin-openai": pluginOpenai,
-    "@elizaos/plugin-anthropic": pluginAnthropic,
-    "@elizaos/plugin-ollama": pluginOllama,
-    "@elizaos/plugin-elizacloud": pluginElizacloud,
-    "@elizaos/plugin-trust": pluginTrust,
-    "@elizaos/plugin-todo": pluginTodo,
-    "@elizaos/plugin-personality": pluginPersonality,
-    "@elizaos/plugin-experience": pluginExperience,
-};
-// NODE_PATH so dynamic plugin imports (e.g. @elizaos/plugin-agent-orchestrator) resolve.
+// NODE_PATH so dynamic plugin imports (e.g. @elizaos/plugin-*) resolve.
 // WHY: When eliza is loaded from dist/ or by a test runner, Node's resolution does not
 // search repo root node_modules; import("@elizaos/plugin-*") then fails. We prepend
 // repo root node_modules only if not already in NODE_PATH (run-node.mjs may have set it)
@@ -123,14 +334,28 @@ if (_rootModules) {
 }
 export function configureLocalEmbeddingPlugin(_plugin, config) {
     const detectedPreset = detectEmbeddingPreset();
+    const SQL_COMPATIBLE_EMBEDDING_DIMENSIONS = new Set([
+        384, 512, 768, 1024, 1536, 3072,
+    ]);
+    const normalizeEmbeddingDimensions = (rawValue) => {
+        if (!rawValue)
+            return undefined;
+        const parsed = Number.parseInt(rawValue, 10);
+        if (!Number.isInteger(parsed) || parsed <= 0)
+            return undefined;
+        return SQL_COMPATIBLE_EMBEDDING_DIMENSIONS.has(parsed)
+            ? String(parsed)
+            : "384";
+    };
     const embeddingConfig = config?.embedding;
     const configuredModel = embeddingConfig?.model?.trim();
     const configuredRepo = embeddingConfig?.modelRepo?.trim();
-    const configuredDimensions = typeof embeddingConfig?.dimensions === "number" &&
+    const configuredDimensions = normalizeEmbeddingDimensions(typeof embeddingConfig?.dimensions === "number" &&
         Number.isInteger(embeddingConfig.dimensions) &&
         embeddingConfig.dimensions > 0
         ? String(embeddingConfig.dimensions)
-        : undefined;
+        : undefined);
+    const detectedDimensions = normalizeEmbeddingDimensions(String(detectedPreset.dimensions));
     const configuredContextSize = typeof embeddingConfig?.contextSize === "number" &&
         Number.isInteger(embeddingConfig.contextSize) &&
         embeddingConfig.contextSize > 0
@@ -171,7 +396,7 @@ export function configureLocalEmbeddingPlugin(_plugin, config) {
         setEnvFromConfig("LOCAL_EMBEDDING_DIMENSIONS", configuredDimensions);
     }
     else if (!configuredModel) {
-        setEnvIfMissing("LOCAL_EMBEDDING_DIMENSIONS", String(detectedPreset.dimensions));
+        setEnvIfMissing("LOCAL_EMBEDDING_DIMENSIONS", detectedDimensions);
     }
     if (configuredContextSize) {
         setEnvFromConfig("LOCAL_EMBEDDING_CONTEXT_SIZE", configuredContextSize);
@@ -201,14 +426,184 @@ export function configureLocalEmbeddingPlugin(_plugin, config) {
     // defaults so the plugin always has valid model names.
     setEnvIfMissing("GOOGLE_SMALL_MODEL", "gemini-3-flash-preview");
     setEnvIfMissing("GOOGLE_LARGE_MODEL", "gemini-3.1-pro-preview");
+    // Default Groq model names — plugin-groq still ships a deprecated large-model
+    // fallback. Seed runtime defaults before plugin init so direct Groq provider
+    // sessions use the approved GPT-OSS default.
+    const currentSharedSmallModel = process.env.OPENAI_SMALL_MODEL ?? process.env.SMALL_MODEL;
+    const currentSharedLargeModel = process.env.OPENAI_LARGE_MODEL ?? process.env.LARGE_MODEL;
+    setEnvIfMissing("GROQ_SMALL_MODEL", currentSharedSmallModel && !isLikelyOpenAiTextModel(currentSharedSmallModel)
+        ? currentSharedSmallModel
+        : "openai/gpt-oss-120b");
+    setEnvIfMissing("GROQ_LARGE_MODEL", currentSharedLargeModel && !isLikelyOpenAiTextModel(currentSharedLargeModel)
+        ? currentSharedLargeModel
+        : "openai/gpt-oss-120b");
     logger.info(`[eliza] 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})`);
 }
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-/** Extract a human-readable error message from an unknown thrown value. */
-function formatError(err) {
-    return err instanceof Error ? err.message : String(err);
+function trimEnvString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function getMutableConfigEnv(config) {
+    if (!config.env ||
+        typeof config.env !== "object" ||
+        Array.isArray(config.env)) {
+        return null;
+    }
+    return config.env;
+}
+function getMutableConfigEnvVars(configEnv) {
+    if (!configEnv.vars ||
+        typeof configEnv.vars !== "object" ||
+        Array.isArray(configEnv.vars)) {
+        return null;
+    }
+    return configEnv.vars;
+}
+function readConfigEnvValue(config, key) {
+    const configEnv = getMutableConfigEnv(config);
+    if (!configEnv)
+        return undefined;
+    const vars = getMutableConfigEnvVars(configEnv);
+    return trimEnvString(vars?.[key]) ?? trimEnvString(configEnv[key]);
+}
+function readEffectiveEnvValue(config, key, env = process.env) {
+    return trimEnvString(env[key]) ?? readConfigEnvValue(config, key);
+}
+function setConfigEnvValue(config, key, value) {
+    if (!config.env ||
+        typeof config.env !== "object" ||
+        Array.isArray(config.env)) {
+        config.env = {};
+    }
+    const configEnv = config.env;
+    const vars = getMutableConfigEnvVars(configEnv);
+    if (vars) {
+        vars[key] = value;
+        delete configEnv[key];
+        return;
+    }
+    configEnv[key] = value;
+}
+function deleteConfigEnvValue(config, key) {
+    const configEnv = getMutableConfigEnv(config);
+    if (!configEnv)
+        return;
+    const vars = getMutableConfigEnvVars(configEnv);
+    if (vars) {
+        delete vars[key];
+        if (Object.keys(vars).length === 0) {
+            delete configEnv.vars;
+        }
+    }
+    delete configEnv[key];
+}
+function detectOpenAiBaseUrlProvider(baseUrl) {
+    try {
+        const hostname = new URL(baseUrl).hostname.trim().toLowerCase();
+        if (hostname === "api.groq.com" || hostname.endsWith(".groq.com")) {
+            return "groq";
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function looksLikeGroqApiKey(value) {
+    return Boolean(value && /^gsk[-_]/i.test(value));
+}
+function isLikelyOpenAiTextModel(value) {
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized.startsWith("gpt-") || normalized.startsWith("openai/");
+}
+/**
+ * Normalize known-bad provider compatibility shims before plugin resolution.
+ *
+ * A common failure mode is routing the OpenAI plugin through Groq's
+ * OpenAI-compatible base URL while leaving OpenAI defaults (`gpt-5.5`,
+ * `gpt-5-mini`) in place. Structured output generation then fails during
+ * message handling because Groq does not serve those model IDs.
+ *
+ * When we can confidently detect that state, rewrite the effective runtime
+ * config to use the Groq plugin directly.
+ */
+/** @internal Exported for testing. */
+export function normalizeOpenAiCompatibleProviderConfig(config, env = process.env) {
+    const cloudInferenceEnabled = resolveElizaCloudTopology(config).services.inference;
+    if (cloudInferenceEnabled) {
+        return false;
+    }
+    const openaiBaseUrl = readEffectiveEnvValue(config, "OPENAI_BASE_URL", env);
+    if (!openaiBaseUrl) {
+        return false;
+    }
+    if (detectOpenAiBaseUrlProvider(openaiBaseUrl) !== "groq") {
+        return false;
+    }
+    const openaiApiKey = readEffectiveEnvValue(config, "OPENAI_API_KEY", env);
+    const groqApiKey = readEffectiveEnvValue(config, "GROQ_API_KEY", env);
+    const inheritedGroqApiKey = groqApiKey ??
+        (looksLikeGroqApiKey(openaiApiKey) ? openaiApiKey : undefined);
+    if (!inheritedGroqApiKey) {
+        return false;
+    }
+    const currentGroqSmallModel = readEffectiveEnvValue(config, "GROQ_SMALL_MODEL", env);
+    const currentGroqLargeModel = readEffectiveEnvValue(config, "GROQ_LARGE_MODEL", env);
+    const currentSharedSmallModel = readEffectiveEnvValue(config, "OPENAI_SMALL_MODEL", env) ??
+        readEffectiveEnvValue(config, "SMALL_MODEL", env);
+    const currentSharedLargeModel = readEffectiveEnvValue(config, "OPENAI_LARGE_MODEL", env) ??
+        readEffectiveEnvValue(config, "LARGE_MODEL", env);
+    const normalizedGroqSmallModel = currentGroqSmallModel ??
+        (currentSharedSmallModel &&
+            !isLikelyOpenAiTextModel(currentSharedSmallModel)
+            ? currentSharedSmallModel
+            : "openai/gpt-oss-120b");
+    const normalizedGroqLargeModel = currentGroqLargeModel ??
+        (currentSharedLargeModel &&
+            !isLikelyOpenAiTextModel(currentSharedLargeModel)
+            ? currentSharedLargeModel
+            : "openai/gpt-oss-120b");
+    env.GROQ_API_KEY = inheritedGroqApiKey;
+    env.GROQ_SMALL_MODEL = normalizedGroqSmallModel;
+    env.GROQ_LARGE_MODEL = normalizedGroqLargeModel;
+    setConfigEnvValue(config, "GROQ_API_KEY", inheritedGroqApiKey);
+    setConfigEnvValue(config, "GROQ_SMALL_MODEL", normalizedGroqSmallModel);
+    setConfigEnvValue(config, "GROQ_LARGE_MODEL", normalizedGroqLargeModel);
+    delete env.OPENAI_BASE_URL;
+    deleteConfigEnvValue(config, "OPENAI_BASE_URL");
+    const shouldDisableOpenAiKey = !openaiApiKey ||
+        openaiApiKey === groqApiKey ||
+        looksLikeGroqApiKey(openaiApiKey);
+    if (shouldDisableOpenAiKey) {
+        delete env.OPENAI_API_KEY;
+        deleteConfigEnvValue(config, "OPENAI_API_KEY");
+    }
+    const primaryModel = trimEnvString(config.agents?.defaults?.model?.primary);
+    if (shouldDisableOpenAiKey &&
+        primaryModel &&
+        (primaryModel.toLowerCase() === "openai" ||
+            isLikelyOpenAiTextModel(primaryModel))) {
+        config.agents ??= {};
+        config.agents.defaults ??= {};
+        config.agents.defaults.model = {
+            ...config.agents.defaults.model,
+            primary: "groq",
+        };
+    }
+    logger.warn("[eliza] Detected Groq routed through OPENAI_BASE_URL; normalizing runtime settings to use @elizaos/plugin-groq");
+    return true;
+}
+/** Redact username segments from filesystem paths to avoid leaking user info in logs. */
+function _redactUserSegments(filepath) {
+    // Replace /Users/<name>/ or /home/<name>/ with /Users/<redacted>/ etc.
+    return filepath.replace(/\/(Users|home)\/[^/]+\//g, "/$1/<redacted>/");
 }
 /**
  * Best-effort runtime shutdown that also closes the database adapter.
@@ -266,16 +661,37 @@ export function deduplicatePluginActions(plugins) {
         }
     }
 }
-async function waitForTrajectoryLoggerService(runtime, context, timeoutMs = 3000) {
+/**
+ * Retrieve the AutonomyService from the runtime, returning null if unavailable.
+ * Uses a runtime property check to safely narrow the opaque Service return.
+ */
+function getAutonomyService(runtime) {
+    const svc = runtime.getService("AUTONOMY") ?? runtime.getService("autonomy");
+    if (svc &&
+        "enableAutonomy" in svc &&
+        typeof svc.enableAutonomy === "function") {
+        return svc;
+    }
+    return null;
+}
+async function startAndRegisterAutonomyService(runtime) {
+    const service = await AutonomyService.start(runtime);
+    runtime.services.set("AUTONOMY", [service]);
+    return service;
+}
+async function waitForTrajectoriesService(runtime, context, timeoutMs = 3000) {
+    if (!runtimeTrajectoriesEnabled(runtime)) {
+        return;
+    }
     const runtimeLike = runtime;
     // Check if already available
     if (typeof runtimeLike.getService === "function") {
-        const existing = runtimeLike.getService("trajectory_logger");
+        const existing = runtimeLike.getService("trajectories");
         if (existing)
             return;
     }
     const registrationStatus = typeof runtimeLike.getServiceRegistrationStatus === "function"
-        ? runtimeLike.getServiceRegistrationStatus("trajectory_logger")
+        ? runtimeLike.getServiceRegistrationStatus("trajectories")
         : "unknown";
     if (registrationStatus !== "pending" &&
         registrationStatus !== "registering") {
@@ -293,15 +709,15 @@ async function waitForTrajectoryLoggerService(runtime, context, timeoutMs = 3000
     });
     try {
         await Promise.race([
-            runtimeLike.getServiceLoadPromise("trajectory_logger").then(() => { }),
+            runtimeLike.getServiceLoadPromise("trajectories").then(() => { }),
             timeoutPromise,
         ]);
         if (timedOut) {
-            logger.debug(`[eliza] trajectory_logger still ${registrationStatus} after ${timeoutMs}ms (${context})`);
+            logger.debug(`[eliza] trajectories still ${registrationStatus} after ${timeoutMs}ms (${context})`);
         }
     }
     catch (err) {
-        logger.debug(`[eliza] trajectory_logger registration failed while waiting (${context}): ${formatError(err)}`);
+        logger.debug(`[eliza] trajectories registration failed while waiting (${context}): ${formatError(err)}`);
     }
     finally {
         if (timeoutHandle)
@@ -309,9 +725,13 @@ async function waitForTrajectoryLoggerService(runtime, context, timeoutMs = 3000
     }
 }
 function ensureTrajectoryLoggerEnabled(runtime, context) {
-    const trajectoryLogger = runtime.getService("trajectory_logger");
+    if (!runtimeTrajectoriesEnabled(runtime)) {
+        logger.info(`[eliza] Native trajectories disabled (${context})`);
+        return;
+    }
+    const trajectoryLogger = runtime.getService("trajectories");
     if (!trajectoryLogger) {
-        logger.warn(`[eliza] trajectory_logger service unavailable (${context}); trajectory capture disabled`);
+        logger.warn(`[eliza] trajectories service unavailable (${context}); trajectory capture disabled`);
         return;
     }
     const isEnabled = typeof trajectoryLogger.isEnabled === "function"
@@ -321,17 +741,22 @@ function ensureTrajectoryLoggerEnabled(runtime, context) {
     if (isEnabled !== shouldEnable &&
         typeof trajectoryLogger.setEnabled === "function") {
         trajectoryLogger.setEnabled(shouldEnable);
-        logger.info(`[eliza] trajectory_logger defaulted ${shouldEnable ? "on" : "off"} (${context})`);
+        logger.info(`[eliza] trajectories defaulted ${shouldEnable ? "on" : "off"} (${context})`);
     }
 }
-/**
- * Cancel the onboarding flow and exit cleanly.
- * Extracted to avoid duplicating the cancel+exit pattern 7 times.
- */
-function cancelOnboarding() {
-    // _clack is guaranteed to be loaded by the time onboarding calls this.
-    _clack?.cancel("Maybe next time!");
-    process.exit(0);
+async function installPromptOptimizationLayer(runtime, context, config) {
+    try {
+        const { installPromptOptimizations } = await import("./prompt-optimization.js");
+        installPromptOptimizations(runtime, config);
+    }
+    catch (err) {
+        logger.warn(`[eliza] Failed to install prompt optimizations (${context}): ${err instanceof Error ? err.message : err}`);
+    }
+}
+async function prepareRuntimeForTrajectoryCapture(runtime, context, config) {
+    await waitForTrajectoriesService(runtime, context);
+    ensureTrajectoryLoggerEnabled(runtime, context);
+    await installPromptOptimizationLayer(runtime, context, config);
 }
 // ---------------------------------------------------------------------------
 // Channel secret mapping
@@ -343,50 +768,7 @@ function cancelOnboarding() {
  * Eliza stores channel credentials under `config.channels.<name>.<field>`,
  * while elizaOS plugins read them from process.env.
  */
-const RETAKE_CHANNEL_ACCESS_TOKEN_ENV = "RETAKE_AGENT_TOKEN";
-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: {
-        authDir: "SIGNAL_AUTH_DIR",
-        account: "SIGNAL_ACCOUNT_NUMBER",
-        httpUrl: "SIGNAL_HTTP_URL",
-        cliPath: "SIGNAL_CLI_PATH",
-    },
-    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",
-    },
-    blooio: {
-        apiKey: "BLOOIO_API_KEY",
-        fromNumber: "BLOOIO_PHONE_NUMBER",
-        webhookSecret: "BLOOIO_WEBHOOK_SECRET",
-        webhookUrl: "BLOOIO_WEBHOOK_URL",
-        webhookPort: "BLOOIO_WEBHOOK_PORT",
-    },
-    retake: {
-        accessToken: RETAKE_CHANNEL_ACCESS_TOKEN_ENV,
-        apiUrl: "RETAKE_API_URL",
-    },
-};
+const CHANNEL_ENV_MAP = CONNECTOR_ENV_MAP;
 // ---------------------------------------------------------------------------
 // Plugin resolution
 // ---------------------------------------------------------------------------
@@ -401,521 +783,17 @@ const _OPTIONAL_NATIVE_PLUGINS = [
     "@elizaos/plugin-vision", // requires @tensorflow/tfjs-node native addon
     "@elizaos/plugin-computeruse", // requires platform-specific binaries
 ];
-/** Maps Eliza channel names to plugin package names. */
-export const CHANNEL_PLUGIN_MAP = {
-    discord: "@elizaos/plugin-discord",
-    telegram: "@elizaos/plugin-telegram",
-    slack: "@elizaos/plugin-slack",
-    twitter: "@elizaos/plugin-twitter",
-    // Internal connector built from src/plugins/whatsapp (not an npm package).
-    whatsapp: "@elizaos/plugin-whatsapp",
-    // Internal connector built from src/plugins/signal (not an npm package).
-    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: "@elizaos/plugin-retake",
-    blooio: "@elizaos/plugin-blooio",
-    twitch: "@elizaos/plugin-twitch",
-};
-const PI_AI_PLUGIN_PACKAGE = "@elizaos/plugin-pi-ai";
-function isPiAiEnabledFromEnv(env = process.env) {
-    const raw = env.ELIZA_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",
-    ELIZA_USE_PI_AI: PI_AI_PLUGIN_PACKAGE,
-    // ElizaCloud — loaded when API key is present OR cloud is explicitly enabled
-    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": "@elizaos/plugin-agent-orchestrator",
-    "streaming-base": "@elizaos/plugin-streaming-base",
-    "twitch-streaming": "@elizaos/plugin-twitch-streaming",
-    "youtube-streaming": "@elizaos/plugin-youtube-streaming",
-    "custom-rtmp": "@elizaos/plugin-custom-rtmp",
-    "pumpfun-streaming": "@elizaos/plugin-pumpfun-streaming",
-    "x-streaming": "@elizaos/plugin-x-streaming",
-};
-function looksLikePlugin(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const obj = value;
-    if (typeof obj.name !== "string" || typeof obj.description !== "string") {
-        return false;
-    }
-    // Providers also expose { name, description } so we require at least one
-    // plugin-like capability field before accepting named exports as plugins.
-    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";
-}
-export function findRuntimePluginExport(mod) {
-    // 1. Prefer explicit default export
-    if (looksLikePlugin(mod.default))
-        return mod.default;
-    // 2. Check for a named `plugin` export
-    if (looksLikePlugin(mod.plugin))
-        return mod.plugin;
-    // 3. Check if the module itself looks like a Plugin (CJS default pattern).
-    if (looksLikePlugin(mod))
-        return mod;
-    // 4. Scan named exports in a deterministic order.
-    // Prefer keys ending with "Plugin" before generic exports like providers.
-    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;
-    }
-    // 5. Final compatibility fallback: accept minimal plugin-like exports only
-    // when the export name itself indicates it's a plugin.
-    for (const key of preferredKeys) {
-        const value = mod[key];
-        if (looksLikePluginBasic(value))
-            return value;
-    }
-    // 6. Legacy CJS compatibility for modules that export only { name, description }.
-    if (looksLikePluginBasic(mod))
-        return mod;
-    const modDefault = mod.default;
-    const modPlugin = mod.plugin;
-    if (looksLikePluginBasic(modDefault))
-        return modDefault;
-    if (looksLikePluginBasic(modPlugin))
-        return modPlugin;
-    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. */
-export function collectPluginNames(config) {
-    const shellPluginDisabled = config.features?.shellEnabled === false;
-    const localEmbeddingsExplicitlyDisabled = (() => {
-        const raw = process.env.ELIZA_DISABLE_LOCAL_EMBEDDINGS;
-        if (!raw)
-            return false;
-        const normalized = raw.trim().toLowerCase();
-        return normalized === "1" || normalized === "true" || normalized === "yes";
-    })();
-    const cloudMode = config.cloud?.enabled;
-    const cloudHasApiKey = Boolean(config.cloud?.apiKey);
-    const cloudExplicitlyDisabled = cloudMode === false;
-    // Note: this is intentionally broader than the inference-path check in
-    // applyCloudConfigToEnv (which requires explicit `enabled: true`).  Here
-    // hasApiKey acts as an implicit enable signal so the cloud *plugin* gets
-    // loaded for RPC/services (auth, credits, billing) even when inference
-    // itself is handled by the user's own keys (BYOK).  The inference and
-    // persistence paths gate on `cloud.enabled === true` separately.
-    const cloudEffectivelyEnabled = cloudMode === true || (!cloudExplicitlyDisabled && cloudHasApiKey);
-    // When inferenceMode is "byok" or "local", OR services.inference is false,
-    // the user wants their own AI provider keys — cloud stays enabled for
-    // RPC/services but does NOT hijack model inference.
-    //
-    // If the user chose a subscription provider (e.g. anthropic-subscription)
-    // during onboarding and never explicitly set inferenceMode, treat that as
-    // "byok" — the subscription IS the user's inference choice.
-    const hasSubscriptionProvider = Boolean(config.agents?.defaults?.subscriptionProvider);
-    const explicitInferenceMode = config.cloud?.inferenceMode;
-    const cloudInferenceMode = explicitInferenceMode ?? (hasSubscriptionProvider ? "byok" : "cloud");
-    const cloudInferenceToggle = config.cloud?.services?.inference ?? true;
-    const cloudHandlesInference = cloudEffectivelyEnabled &&
-        cloudInferenceMode === "cloud" &&
-        cloudInferenceToggle !== false;
-    const configEnv = config.env;
-    const configPiAiFlag = (configEnv?.vars &&
-        typeof configEnv.vars === "object" &&
-        !Array.isArray(configEnv.vars)
-        ? configEnv.vars.ELIZA_USE_PI_AI
-        : undefined) ?? configEnv?.ELIZA_USE_PI_AI;
-    const piAiEnabled = isPiAiEnabledFromEnv(process.env) ||
-        (typeof configPiAiFlag === "string" &&
-            isPiAiEnabledFromEnv({
-                ELIZA_USE_PI_AI: configPiAiFlag,
-            }));
-    const pluginEntries = config.plugins
-        ?.entries;
-    const isPluginExplicitlyDisabled = (pluginPackageName) => {
-        const marker = "/plugin-";
-        const markerIndex = pluginPackageName.lastIndexOf(marker);
-        const pluginId = markerIndex >= 0
-            ? pluginPackageName.slice(markerIndex + marker.length)
-            : pluginPackageName;
-        return pluginEntries?.[pluginId]?.enabled === false;
-    };
-    const providerPluginIdSet = new Set(Object.values(PROVIDER_PLUGIN_MAP).map((pluginPackageName) => {
-        const marker = "/plugin-";
-        const markerIndex = pluginPackageName.lastIndexOf(marker);
-        return markerIndex >= 0
-            ? pluginPackageName.slice(markerIndex + marker.length)
-            : pluginPackageName;
-    }));
-    const explicitProviderEntries = Object.entries(pluginEntries ?? {}).filter(([pluginId]) => providerPluginIdSet.has(pluginId));
-    const hasExplicitEnabledProvider = explicitProviderEntries.some(([, entry]) => entry?.enabled === true);
-    // Allow-list entries are additive (extra plugins), not exclusive.
-    const allowList = config.plugins?.allow;
-    const pluginsToLoad = new Set(CORE_PLUGINS);
-    if (localEmbeddingsExplicitlyDisabled) {
-        pluginsToLoad.delete("@elizaos/plugin-local-embedding");
-    }
-    // Allow list is additive — extra plugins on top of auto-detection,
-    // not an exclusive whitelist that blocks everything else.
-    if (allowList && allowList.length > 0) {
-        for (const item of allowList) {
-            const pluginName = CHANNEL_PLUGIN_MAP[item] ?? OPTIONAL_PLUGIN_MAP[item] ?? item;
-            pluginsToLoad.add(pluginName);
-        }
-    }
-    // Connector plugins — load when connector has config entries
-    // Prefer config.connectors, fall back to config.channels for backward compatibility
-    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);
-            }
-        }
-    }
-    // Model-provider plugins — load when env key is present
-    for (const [envKey, pluginName] of Object.entries(PROVIDER_PLUGIN_MAP)) {
-        if (envKey === "ELIZA_USE_PI_AI") {
-            // pi-ai enablement uses dedicated boolean parsing + precedence logic below.
-            continue;
-        }
-        if (cloudExplicitlyDisabled &&
-            (envKey === "ELIZAOS_CLOUD_API_KEY" || envKey === "ELIZAOS_CLOUD_ENABLED")) {
-            continue;
-        }
-        if (isPluginExplicitlyDisabled(pluginName)) {
-            continue;
-        }
-        if (hasExplicitEnabledProvider) {
-            const marker = "/plugin-";
-            const markerIndex = pluginName.lastIndexOf(marker);
-            const pluginId = markerIndex >= 0
-                ? pluginName.slice(markerIndex + marker.length)
-                : 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 = () => {
-        // Provider precedence:
-        // 1) ElizaCloud for inference (when enabled AND inferenceMode is "cloud")
-        // 2) pi-ai (when enabled and cloud inference is not active)
-        // 3) direct provider plugins (api-key/env based)
-        //
-        // When inferenceMode is "byok" or "local", cloud stays loaded for
-        // RPC/services but direct AI provider plugins are preserved so the
-        // user's own API keys (e.g. Anthropic) handle model inference.
-        if (cloudEffectivelyEnabled) {
-            pluginsToLoad.add("@elizaos/plugin-elizacloud");
-            if (cloudHandlesInference) {
-                // Cloud handles ALL model calls — remove direct AI provider plugins.
-                const directProviders = new Set(Object.values(PROVIDER_PLUGIN_MAP));
-                directProviders.delete("@elizaos/plugin-elizacloud");
-                for (const p of directProviders) {
-                    pluginsToLoad.delete(p);
-                }
-                return;
-            }
-            // inferenceMode is "byok" or "local" — keep direct provider plugins.
-            // Cloud plugin stays loaded for non-inference cloud services (RPC, media, etc.)
-            // Pi-ai takes priority over direct providers when cloud inference is disabled.
-            if (shouldEnablePiAi) {
-                pluginsToLoad.add(PI_AI_PLUGIN_PACKAGE);
-                // Remove direct provider plugins — pi-ai handles inference selection.
-                const directProviders = new Set(Object.values(PROVIDER_PLUGIN_MAP));
-                directProviders.delete(PI_AI_PLUGIN_PACKAGE);
-                directProviders.delete("@elizaos/plugin-elizacloud");
-                for (const p of directProviders) {
-                    pluginsToLoad.delete(p);
-                }
-            }
-            return;
-        }
-        if (shouldEnablePiAi) {
-            pluginsToLoad.add(PI_AI_PLUGIN_PACKAGE);
-            // When pi-ai is active, remove direct provider plugins + cloud plugin.
-            // pi-ai performs the upstream provider selection itself.
-            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) {
-            // Cloud was explicitly disabled — remove elizacloud even though it's
-            // in CORE_PLUGINS, so it cannot intercept model calls.
-            pluginsToLoad.delete("@elizaos/plugin-elizacloud");
-        }
-    };
-    // Apply once before additive plugin-entry/feature paths.
-    applyProviderPrecedence();
-    // Optional feature plugins from config.plugins.entries
-    const pluginsConfig = config.plugins;
-    if (pluginsConfig?.entries) {
-        for (const [key, entry] of Object.entries(pluginsConfig.entries)) {
-            if (entry &&
-                typeof entry === "object" &&
-                entry.enabled !== false) {
-                // Connector keys (telegram, discord, etc.) must use CHANNEL_PLUGIN_MAP
-                // so the correct variant loads.
-                const pluginName = CHANNEL_PLUGIN_MAP[key] ??
-                    OPTIONAL_PLUGIN_MAP[key] ??
-                    (key.includes("/") ? key : `@elizaos/plugin-${key}`);
-                pluginsToLoad.add(pluginName);
-            }
-        }
-    }
-    // Feature flags (config.features)
-    const features = config.features;
-    if (features && typeof features === "object") {
-        for (const [featureName, featureValue] of Object.entries(features)) {
-            const isEnabled = featureValue === true ||
-                (typeof featureValue === "object" &&
-                    featureValue !== null &&
-                    featureValue.enabled !== false);
-            if (isEnabled) {
-                const pluginName = OPTIONAL_PLUGIN_MAP[featureName];
-                if (pluginName) {
-                    pluginsToLoad.add(pluginName);
-                }
-            }
-        }
-    }
-    // x402 plugin — auto-load when config section enabled
-    if (config.x402?.enabled) {
-        pluginsToLoad.add("@elizaos/plugin-x402");
-    }
-    // Opinion plugin — auto-load when API key is present.
-    // NOT in PROVIDER_PLUGIN_MAP because it is a feature plugin, not a model
-    // provider, and would be incorrectly removed during provider precedence.
-    if (process.env.OPINION_API_KEY?.trim()) {
-        pluginsToLoad.add("@elizaos/plugin-opinion");
-    }
-    // User-installed plugins from config.plugins.installs
-    // These are plugins that were installed via the plugin-manager at runtime
-    // and tracked in eliza.json so they persist across restarts.
-    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);
-            }
-        }
-    }
-    // Re-apply provider precedence so later additive paths (entries, features,
-    // installs) cannot accidentally re-introduce suppressed providers.
-    applyProviderPrecedence();
-    // Enforce feature gating last so allow-list entries cannot bypass it.
-    if (shellPluginDisabled) {
-        pluginsToLoad.delete("@elizaos/plugin-shell");
-    }
-    if (isPluginExplicitlyDisabled("@elizaos/plugin-agent-orchestrator")) {
-        pluginsToLoad.delete("@elizaos/plugin-agent-orchestrator");
-    }
-    return pluginsToLoad;
-}
+// CHANNEL_PLUGIN_MAP, PROVIDER_PLUGIN_MAP, and OPTIONAL_PLUGIN_MAP live in
+// ./plugin-collector.ts and are re-exported from this module for backward compatibility.
 // ---------------------------------------------------------------------------
-// Custom / drop-in plugin discovery
+// Custom / drop-in plugin discovery (moved to plugin-types.ts)
 // ---------------------------------------------------------------------------
-/** Subdirectory under the Eliza state dir for drop-in custom plugins. */
-export const CUSTOM_PLUGINS_DIRNAME = "plugins/custom";
-/** Subdirectory under the Eliza state dir for ejected plugins. */
-export 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.
- */
-export async function scanDropInPlugins(dir) {
-    const records = {};
-    let entries;
-    try {
-        entries = await fs.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.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`.
- */
-export 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(`[eliza] 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 = new Set([
-    // "@elizaos/plugin-trajectory-logger",
-    // "@elizaos/plugin-plugin-manager",
-    // "@elizaos/plugin-media-generation",
-    "@elizaos/plugin-twitch-streaming",
-    "@elizaos/plugin-youtube-streaming",
-    "@elizaos/plugin-retake",
-]);
-function getWorkspacePluginOverridePath(pluginName) {
-    if (process.env.ELIZA_DISABLE_WORKSPACE_PLUGIN_OVERRIDES === "1") {
-        return null;
-    }
-    if (!WORKSPACE_PLUGIN_OVERRIDES.has(pluginName)) {
-        return null;
-    }
-    const pluginSegmentMatch = pluginName.match(/^@[^/]+\/(plugin-[^/]+)$/);
-    const pluginSegment = pluginSegmentMatch?.[1];
-    if (!pluginSegment)
-        return null;
-    const thisDir = path.dirname(fileURLToPath(import.meta.url));
-    const elizaRoot = path.resolve(thisDir, "..", "..");
-    const workspaceRoot = path.resolve(elizaRoot, "..");
-    const candidates = [
-        path.join(elizaRoot, "plugins", pluginSegment, "typescript"),
-        path.join(workspaceRoot, "plugins", pluginSegment, "typescript"),
-        path.join(elizaRoot, "plugins", pluginSegment),
-        path.join(workspaceRoot, "plugins", pluginSegment),
-        path.join(elizaRoot, "packages", pluginSegment),
-        path.join(workspaceRoot, "packages", pluginSegment),
-    ];
-    for (const candidate of candidates) {
-        if (existsSync(path.join(candidate, "package.json"))) {
-            return candidate;
-        }
-    }
-    return null;
-}
-export function resolveElizaPluginImportSpecifier(pluginName, runtimeModuleUrl = import.meta.url) {
-    if (!pluginName.startsWith("@elizaos/plugin-")) {
-        return pluginName;
-    }
-    const shortName = pluginName.replace("@elizaos/plugin-", "");
-    const thisDir = path.dirname(fileURLToPath(runtimeModuleUrl));
-    const distRoot = thisDir.endsWith("runtime")
-        ? path.resolve(thisDir, "..")
-        : thisDir;
-    const indexPath = path.resolve(distRoot, "plugins", shortName, "index.js");
-    return existsSync(indexPath) ? pathToFileURL(indexPath).href : pluginName;
-}
-export function shouldIgnoreMissingPluginExport(pluginName) {
-    return pluginName === "@elizaos/plugin-streaming-base";
-}
 // ---------------------------------------------------------------------------
 // Plugin resolution
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Browser server pre-flight
 // ---------------------------------------------------------------------------
-/**
- * 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,
@@ -923,6 +801,8 @@ export function shouldIgnoreMissingPluginExport(pluginName) {
  */
 export function isEnvKeyAllowedForForwarding(key) {
     const upper = key.toUpperCase();
+    if (upper === "ALLOW_NO_DATABASE")
+        return false;
     // Block blockchain private keys
     if (upper.includes("PRIVATE_KEY"))
         return false;
@@ -933,461 +813,54 @@ export function isEnvKeyAllowedForForwarding(key) {
         return false;
     if (/(ACCESS_TOKEN|REFRESH_TOKEN|SESSION_TOKEN|AUTH_TOKEN)$/i.test(key))
         return false;
-    return true;
-}
-export function ensureBrowserServerLink() {
-    try {
-        // Resolve the plugin-browser package root via its package.json.
-        const req = createRequire(import.meta.url);
-        const pkgJsonPath = req.resolve("@elizaos/plugin-browser/package.json");
-        const pluginRoot = path.dirname(pkgJsonPath);
-        const serverDir = path.join(pluginRoot, "dist", "server");
-        const serverIndex = path.join(serverDir, "dist", "index.js");
-        // Already linked / available — nothing to do.
-        if (existsSync(serverIndex))
-            return true;
-        // Walk upward from this file to find the eliza-workspace root.
-        // Layout: <workspace>/eliza/packages/agent/src/runtime/eliza.ts
-        const thisDir = path.dirname(fileURLToPath(import.meta.url));
-        const workspaceRoot = path.resolve(thisDir, "..", "..", "..", "..", "..");
-        const stagehandDir = path.join(workspaceRoot, "plugins", "plugin-browser", "stagehand-server");
-        const stagehandIndex = path.join(stagehandDir, "dist", "index.js");
-        // Auto-build if source exists but dist doesn't
-        if (!existsSync(stagehandIndex) &&
-            existsSync(path.join(stagehandDir, "src", "index.ts"))) {
-            logger.info(`[eliza] Stagehand server not built — attempting auto-build...`);
-            try {
-                const cp = createRequire(import.meta.url)("node:child_process");
-                if (!existsSync(path.join(stagehandDir, "node_modules"))) {
-                    cp.execSync("pnpm install --ignore-scripts", {
-                        cwd: stagehandDir,
-                        stdio: "ignore",
-                        timeout: 60_000,
-                    });
-                }
-                // Prefer local tsc binary, fall back to pnpm exec
-                const localTsc = path.join(stagehandDir, "node_modules", ".bin", "tsc");
-                const tscCmd = existsSync(localTsc) ? localTsc : "pnpm exec tsc";
-                cp.execSync(tscCmd, {
-                    cwd: stagehandDir,
-                    stdio: "ignore",
-                    timeout: 60_000,
-                });
-                logger.info(`[eliza] Stagehand server built successfully`);
-            }
-            catch (buildErr) {
-                logger.debug(`[eliza] Auto-build failed: ${formatError(buildErr)}`);
-            }
-        }
-        if (!existsSync(stagehandIndex)) {
-            logger.info(`[eliza] Browser server not found at ${stagehandDir} — ` +
-                `@elizaos/plugin-browser will not be loaded`);
-            return false;
-        }
-        // Create symlink: dist/server -> stagehand-server
-        symlinkSync(stagehandDir, serverDir, "dir");
-        logger.info(`[eliza] Linked browser server: ${serverDir} -> ${stagehandDir}`);
-        return true;
-    }
-    catch (err) {
-        logger.debug(`[eliza] Could not link browser server: ${formatError(err)}`);
-        return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Plugin resolution
-// ---------------------------------------------------------------------------
-/**
- * Resolve Eliza 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 ~/.eliza/plugins/installed/
- * 3. Custom/drop-in plugins — from ~/.eliza/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.
- */
-/**
- * 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;
-}
-async function resolvePlugins(config, opts) {
-    const plugins = [];
-    const failedPlugins = [];
-    const repairedInstallRecords = new Set();
-    applyPluginAutoEnable({
-        config,
-        env: process.env,
-    });
-    const pluginsToLoad = collectPluginNames(config);
-    const corePluginSet = new Set(CORE_PLUGINS);
-    // 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 || []));
-    // ── 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);
-        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(", ")}`);
-    }
-    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 ejectedRecord = ejectedRecords[pluginName];
-        const installRecord = installRecords[pluginName];
-        const workspaceOverridePath = getWorkspacePluginOverridePath(pluginName);
-        // Pre-flight: ensure native dependencies are available for special plugins.
-        if (pluginName === "@elizaos/plugin-browser") {
-            if (!ensureBrowserServerLink()) {
-                failedPlugins.push({
-                    name: pluginName,
-                    error: "browser server binary not found",
-                });
-                logger.warn(`[eliza] 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) {
-                // Ejected plugin — always prefer local source over npm/core.
-                logger.debug(`[eliza] Loading ejected plugin: ${pluginName} from ${ejectedRecord.installPath}`);
-                mod = await importFromPath(ejectedRecord.installPath, pluginName);
-            }
-            else if (workspaceOverridePath) {
-                logger.debug(`[eliza] Loading workspace plugin override: ${pluginName} from ${workspaceOverridePath}`);
-                mod = await importFromPath(workspaceOverridePath, pluginName);
-            }
-            else if (installRecord?.installPath) {
-                // Prefer bundled/node_modules copies for official Eliza plugins.
-                const isOfficialElizaPlugin = pluginName.startsWith("@elizaos/plugin-");
-                if (isOfficialElizaPlugin) {
-                    try {
-                        const staticMod = await resolveStaticElizaPlugin(pluginName);
-                        mod = staticMod
-                            ? staticMod
-                            : (await import(pluginName));
-                        if (repairBrokenInstallRecord(config, pluginName)) {
-                            repairedInstallRecords.add(pluginName);
-                        }
-                    }
-                    catch (npmErr) {
-                        logger.warn(`[eliza] Node_modules resolution failed for ${pluginName} (${formatError(npmErr)}). Trying installed path at ${installRecord.installPath}.`);
-                        mod = await importFromPath(installRecord.installPath, pluginName);
-                    }
-                }
-                else {
-                    // User-installed plugin — load from its install directory on disk.
-                    try {
-                        mod = await importFromPath(installRecord.installPath, pluginName);
-                    }
-                    catch (installErr) {
-                        logger.warn(`[eliza] Installed plugin ${pluginName} failed at ${installRecord.installPath} (${formatError(installErr)}). Falling back to node_modules resolution.`);
-                        const staticMod = await resolveStaticElizaPlugin(pluginName);
-                        mod = staticMod
-                            ? staticMod
-                            : (await import(pluginName));
-                        if (repairBrokenInstallRecord(config, pluginName)) {
-                            repairedInstallRecords.add(pluginName);
-                        }
-                    }
-                }
-            }
-            else if (pluginName.startsWith("@elizaos/plugin-")) {
-                // Eliza plugins can resolve either from bundled local wrappers
-                // under eliza-dist/plugins/* or from packaged node_modules.
-                mod = (await import(resolveElizaPluginImportSpecifier(pluginName)));
-            }
-            else {
-                // Built-in/npm plugin — try bundled static import first, then
-                // fall back to bare node_modules resolution.
-                const staticMod = pluginName.startsWith("@elizaos/plugin-")
-                    ? await resolveStaticElizaPlugin(pluginName)
-                    : null;
-                mod = staticMod
-                    ? staticMod
-                    : (await import(pluginName));
-            }
-            const pluginInstance = findRuntimePluginExport(mod);
-            if (pluginInstance) {
-                // Wrap the plugin's init function with an error boundary
-                const wrappedPlugin = wrapPluginWithErrorBoundary(pluginName, pluginInstance);
-                logger.debug(`[eliza] ✓ Loaded plugin: ${pluginName}`);
-                return { name: pluginName, plugin: wrappedPlugin };
-            }
-            else {
-                if (shouldIgnoreMissingPluginExport(pluginName)) {
-                    logger.info(`[eliza] Skipping helper package ${pluginName}: no Plugin export is expected`);
-                    return null;
-                }
-                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)) {
-                    logger.debug(`[eliza] Optional plugin ${pluginName} not available: ${msg}`);
-                }
-                else {
-                    logger.info(`[eliza] Could not load plugin ${pluginName}: ${msg}`);
-                }
-            }
-            return null;
-        }
-    }
-    // Load all plugins in parallel for faster startup
-    const pluginResults = 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
-    logger.info(`[eliza] Plugin resolution complete: ${plugins.length}/${pluginsToLoad.size} loaded` +
-        (failedPlugins.length > 0 ? `, ${failedPlugins.length} failed` : ""));
-    if (failedPlugins.length > 0) {
-        logger.info(`[eliza] Failed plugins: ${failedPlugins.map((f) => `${f.name} (${f.error})`).join(", ")}`);
-    }
-    // Diagnose version-skew issues when AI providers failed to load (#10)
-    const loadedNames = plugins.map((p) => p.name);
-    const diagnostic = diagnoseNoAIProvider(loadedNames, failedPlugins);
-    if (diagnostic) {
-        if (opts?.quiet) {
-            // In headless/GUI mode before onboarding, this is expected — the user
-            // will configure a provider through the onboarding wizard and restart.
-            logger.info(`[eliza] ${diagnostic}`);
-        }
-        else {
-            logger.error(`[eliza] ${diagnostic}`);
-        }
-    }
-    // Persist repaired install records so future startups do not keep trying
-    // to import 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;
-}
-/** @internal Exported for testing. */
-export function repairBrokenInstallRecord(config, pluginName) {
-    const record = config.plugins?.installs?.[pluginName];
-    if (!record || typeof record.installPath !== "string")
-        return false;
-    if (!record.installPath.trim())
+    // Block elizaCloud connection keys — these must only come from config.cloud
+    // via applyCloudConfigToEnv(). Forwarding them from config.env.vars into
+    // runtime.settings would let a stale env-var shadow the live cloud key that
+    // the app sets when the user connects through the UI.
+    if (upper === "ELIZAOS_CLOUD_API_KEY" ||
+        upper === "ELIZAOS_CLOUD_ENABLED" ||
+        upper === "ELIZAOS_CLOUD_BASE_URL" ||
+        upper === "ELIZAOS_CLOUD_NANO_MODEL" ||
+        upper === "ELIZAOS_CLOUD_MEDIUM_MODEL" ||
+        upper === "ELIZAOS_CLOUD_SMALL_MODEL" ||
+        upper === "ELIZAOS_CLOUD_LARGE_MODEL" ||
+        upper === "ELIZAOS_CLOUD_MEGA_MODEL" ||
+        upper === "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL" ||
+        upper === "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL" ||
+        upper === "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL" ||
+        upper === "ELIZAOS_CLOUD_PLANNER_MODEL")
         return false;
-    // Keep the plugin listed as installed but force node_modules resolution.
-    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 };
-    // 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)}`);
-                // Surface the error but don't rethrow — the agent continues
-                // without this plugin's init having completed.
-                logger.warn(`[eliza] Plugin "${pluginName}" will run in degraded mode (init failed)`);
-            }
-        };
+function assertPersistentDatabaseRequired(runtime) {
+    const raw = runtime.getSetting("ALLOW_NO_DATABASE") ?? process.env.ALLOW_NO_DATABASE;
+    const normalized = String(raw ?? "")
+        .trim()
+        .toLowerCase();
+    if (normalized === "true" ||
+        normalized === "1" ||
+        normalized === "yes" ||
+        normalized === "on") {
+        throw new Error(`Eliza requires persistent database storage and does not permit ALLOW_NO_DATABASE (agent ${runtime.agentId}). Remove ALLOW_NO_DATABASE from config/env and use @elizaos/plugin-sql.`);
     }
-    // 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}`);
-                    // Return an error marker so downstream consumers can detect
-                    // the failure rather than silently using empty data.
-                    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. ~/.eliza/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);
-    // 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 */
-    }
-    // Resolve entry point from package.json
-    const entryPoint = await resolvePackageEntry(pkgRoot);
-    return (await import(pathToFileURL(entryPoint).href));
-}
-/** Read package.json exports/main to find the importable entry file. */
-/** @internal Exported for testing. */
-export 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 = 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 first candidate even when missing so callers still get a useful path in errors.
-        return path.resolve(paths[0] ?? fallback);
-    };
-    try {
-        const raw = await fs.readFile(path.join(pkgRoot, "package.json"), "utf-8");
-        const pkg = JSON.parse(raw);
-        if (typeof pkg.exports === "object" && pkg.exports["."] !== undefined) {
-            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;
-    }
+function isElizaCloudManagedProcessEnvKey(key) {
+    const upper = key.toUpperCase();
+    return (upper === "ELIZAOS_CLOUD_API_KEY" ||
+        upper === "ELIZAOS_CLOUD_ENABLED" ||
+        upper === "ELIZAOS_CLOUD_BASE_URL" ||
+        upper === "ELIZAOS_CLOUD_NANO_MODEL" ||
+        upper === "ELIZAOS_CLOUD_MEDIUM_MODEL" ||
+        upper === "ELIZAOS_CLOUD_SMALL_MODEL" ||
+        upper === "ELIZAOS_CLOUD_LARGE_MODEL" ||
+        upper === "ELIZAOS_CLOUD_MEGA_MODEL" ||
+        upper === "ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL" ||
+        upper === "ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL" ||
+        upper === "ELIZAOS_CLOUD_ACTION_PLANNER_MODEL" ||
+        upper === "ELIZAOS_CLOUD_PLANNER_MODEL");
 }
+// findPluginBrowserStagehandDir, ensureBrowserServerLink,
+// repairBrokenInstallRecord, resolvePackageEntry — moved to plugin-types.ts
 // ---------------------------------------------------------------------------
 // Config → Character mapping
 // ---------------------------------------------------------------------------
@@ -1410,12 +883,8 @@ export function applyConnectorSecretsToEnv(config) {
                 (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;
-                }
+                process.env.DISCORD_API_TOKEN = tokenValue;
+                process.env.DISCORD_BOT_TOKEN = tokenValue;
             }
         }
         const envMap = CHANNEL_ENV_MAP[channelName];
@@ -1423,143 +892,289 @@ export function applyConnectorSecretsToEnv(config) {
             continue;
         for (const [configField, envKey] of Object.entries(envMap)) {
             const value = configObj[configField];
-            if (typeof value === "string" && value.trim()) {
-                // Set if unset, or overwrite stale [REDACTED] placeholders
-                const existing = process.env[envKey];
-                if (!existing || existing.startsWith("[REDACT")) {
-                    process.env[envKey] = value;
+            if (typeof value === "boolean" || typeof value === "number") {
+                process.env[envKey] = String(value);
+            }
+            else if (typeof value === "string" && value.trim()) {
+                process.env[envKey] = value;
+            }
+        }
+        if (channelName === "whatsapp") {
+            const allowFrom = configObj.allowFrom;
+            if (Array.isArray(allowFrom) && allowFrom.length > 0) {
+                const normalized = allowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    process.env.WHATSAPP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const groupAllowFrom = configObj.groupAllowFrom;
+            if (Array.isArray(groupAllowFrom) && groupAllowFrom.length > 0) {
+                const normalized = groupAllowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    process.env.WHATSAPP_GROUP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const accounts = configObj.accounts;
+            if (accounts &&
+                typeof accounts === "object" &&
+                !Array.isArray(accounts)) {
+                const firstEnabledAccount = Object.values(accounts).find((account) => {
+                    if (!account ||
+                        typeof account !== "object" ||
+                        Array.isArray(account)) {
+                        return false;
+                    }
+                    const candidate = account;
+                    return (candidate.enabled !== false && typeof candidate.authDir === "string");
+                });
+                if (firstEnabledAccount &&
+                    typeof firstEnabledAccount.authDir === "string" &&
+                    firstEnabledAccount.authDir.trim()) {
+                    process.env.WHATSAPP_AUTH_DIR = firstEnabledAccount.authDir.trim();
                 }
             }
         }
     }
 }
 /**
- * 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.
+ * 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. */
+export 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(`[eliza] 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(`[eliza] Auto-resolved Discord Application ID: ${app.id}`);
+    }
+    catch (err) {
+        logger.warn(`[eliza] Could not auto-resolve Discord Application ID: ${err}`);
+    }
+}
+/**
+ * Fetch GitHub OAuth token from cloud if available and no local token is set.
+ * Called during async runtime init after cloud config is applied.
+ *
+ * Flow: If the agent has a managed GitHub connection in the cloud, and no
+ * local GITHUB_TOKEN is set, fetch the OAuth token from the cloud API and
+ * inject it into process.env so plugins (plugin-github, git-workspace-service)
+ * can use it for API calls and git credential helpers.
  */
 /** @internal Exported for testing. */
-export async function autoResolveDiscordAppId() {
-    if (process.env.DISCORD_APPLICATION_ID)
+export async function autoFetchCloudGithubToken(agentId) {
+    // Skip if a local token is already configured
+    if (process.env.GITHUB_TOKEN || process.env.GITHUB_PAT)
         return;
-    const discordToken = process.env.DISCORD_API_TOKEN || process.env.DISCORD_BOT_TOKEN;
-    if (!discordToken)
+    // Need cloud credentials and an agent ID
+    const cloudApiKey = process.env.ELIZAOS_CLOUD_API_KEY?.trim();
+    const cloudBaseUrl = process.env.ELIZAOS_CLOUD_BASE_URL?.trim() || "https://api.elizacloud.ai";
+    if (!cloudApiKey || !agentId)
+        return;
+    const managedNs = process.env.ELIZA_CLOUD_MANAGED_AGENTS_API_SEGMENT?.trim();
+    if (!managedNs)
         return;
     try {
-        const res = await fetch("https://discord.com/api/v10/oauth2/applications/@me", { headers: { Authorization: `Bot ${discordToken}` } });
+        const url = `${cloudBaseUrl}/api/v1/${managedNs}/agents/${encodeURIComponent(agentId)}/github/token`;
+        const res = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${cloudApiKey}`,
+                Accept: "application/json",
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
         if (!res.ok) {
-            logger.warn(`[eliza] Failed to auto-resolve Discord Application ID: ${res.status}`);
+            // 404 = no GitHub connection for this agent, which is fine
+            if (res.status !== 404) {
+                logger.warn(`[eliza] Failed to fetch cloud GitHub token: ${res.status}`);
+            }
             return;
         }
-        const app = (await res.json());
-        if (!app.id)
+        const body = (await res.json());
+        if (!body.success || !body.data?.accessToken)
             return;
-        process.env.DISCORD_APPLICATION_ID = app.id;
-        logger.info(`[eliza] Auto-resolved Discord Application ID: ${app.id}`);
+        process.env.GITHUB_TOKEN = body.data.accessToken;
+        logger.info(`[eliza] Fetched GitHub token from cloud for @${body.data.githubUsername || "unknown"}`);
     }
     catch (err) {
-        logger.warn(`[eliza] Could not auto-resolve Discord Application ID: ${err}`);
+        logger.warn(`[eliza] Could not fetch cloud GitHub token: ${err}`);
     }
 }
 /**
  * Propagate cloud config from Eliza config into process.env so the
  * ElizaCloud plugin can discover settings at startup.
  */
-/** @internal Exported for testing. */
 export function applyCloudConfigToEnv(config) {
+    migrateLegacyRuntimeConfig(config);
     const cloud = config.cloud;
-    if (!cloud)
+    const isCloudContainer = process.env.ELIZA_CLOUD_PROVISIONED === "1";
+    if (!cloud && !isCloudContainer)
         return;
-    const cloudMode = cloud.enabled;
-    // Require explicit cloud.enabled = true. Previously, undefined + apiKey
-    // would count as enabled, causing the model to revert to cloud on restart.
-    const effectivelyEnabled = cloudMode === true;
+    const topology = resolveElizaCloudTopology(config);
+    // Cloud inference is selected from the canonical onboarding connection, not
+    // just from raw cloud flags. This keeps linked cloud auth from re-enabling
+    // Eliza Cloud after the user has switched to a local or remote provider.
+    const effectivelyEnabled = topology.services.inference || isCloudContainer;
+    const shouldLoadCloudPlugin = topology.shouldLoadPlugin || isCloudContainer;
+    const setCloudUsageEnv = (key, enabled) => {
+        if (enabled) {
+            process.env[key] = "true";
+        }
+        else {
+            delete process.env[key];
+        }
+    };
+    if (isElizaSettingsDebugEnabled()) {
+        const c = (cloud ?? {});
+        logger.debug(`[eliza][settings][runtime] applyCloudConfigToEnv inference=${effectivelyEnabled} shouldLoadPlugin=${shouldLoadCloudPlugin} isCloudContainer=${isCloudContainer} cloud=${JSON.stringify(settingsDebugCloudSummary(c))}`);
+    }
+    setCloudUsageEnv("ELIZAOS_CLOUD_USE_INFERENCE", effectivelyEnabled);
+    setCloudUsageEnv("ELIZAOS_CLOUD_USE_TTS", topology.services.tts || isCloudContainer);
+    setCloudUsageEnv("ELIZAOS_CLOUD_USE_MEDIA", topology.services.media);
+    setCloudUsageEnv("ELIZAOS_CLOUD_USE_EMBEDDINGS", topology.services.embeddings);
+    setCloudUsageEnv("ELIZAOS_CLOUD_USE_RPC", topology.services.rpc);
     if (effectivelyEnabled) {
         process.env.ELIZAOS_CLOUD_ENABLED = "true";
-        logger.info(`[eliza] 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;
     }
-    // Only propagate the API key when it is a real credential — never set
-    // the literal "[REDACTED]" placeholder (which can leak into the config via
-    // UI round-trips through the redacted GET → PUT cycle).
-    const isRealApiKey = cloud.apiKey && cloud.apiKey.trim().toUpperCase() !== "[REDACTED]";
-    if (isRealApiKey) {
-        process.env.ELIZAOS_CLOUD_API_KEY = cloud.apiKey;
+    if (shouldLoadCloudPlugin) {
+        logger.info(`[eliza] Cloud config: inference=${topology.services.inference}, runtime=${topology.runtime}, hasApiKey=${Boolean(cloud?.apiKey || process.env.ELIZAOS_CLOUD_API_KEY)}, baseUrl=${cloud?.baseUrl ?? "(default)"}, isCloudContainer=${isCloudContainer}`);
+        // Only propagate the API key when cloud is enabled AND it is a real
+        // credential — never set the literal "[REDACTED]" placeholder (which can
+        // leak into the config via UI round-trips through the redacted GET → PUT
+        // cycle). WHY: when enabled is false (BYOK / disconnected), leaving the key
+        // in process.env still auto-loads @elizaos/plugin-elizacloud and steals
+        // TEXT_LARGE even if the JSON says cloud is off.
+        const isRealApiKey = cloud?.apiKey && cloud.apiKey.trim().toUpperCase() !== "[REDACTED]";
+        if (isRealApiKey) {
+            process.env.ELIZAOS_CLOUD_API_KEY = cloud.apiKey;
+        }
+        else if (!isCloudContainer) {
+            delete process.env.ELIZAOS_CLOUD_API_KEY;
+        }
+        if (cloud?.baseUrl) {
+            process.env.ELIZAOS_CLOUD_BASE_URL = cloud.baseUrl;
+        }
+        else if (!isCloudContainer) {
+            delete process.env.ELIZAOS_CLOUD_BASE_URL;
+        }
     }
     else {
+        delete process.env.ELIZAOS_CLOUD_NANO_MODEL;
+        delete process.env.ELIZAOS_CLOUD_MEDIUM_MODEL;
+        delete process.env.ELIZAOS_CLOUD_SMALL_MODEL;
+        delete process.env.ELIZAOS_CLOUD_LARGE_MODEL;
+        delete process.env.ELIZAOS_CLOUD_MEGA_MODEL;
+        delete process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL;
+        delete process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL;
+        delete process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL;
+        delete process.env.ELIZAOS_CLOUD_PLANNER_MODEL;
         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;
     }
-    // Propagate model names so the cloud plugin picks them up.  Falls back to
+    // Propagate model names so the cloud plugin picks them up. Falls back to
     // sensible defaults when cloud is enabled but no explicit selection exists.
     // Skip when inferenceMode is "byok"/"local" or services.inference is off —
     // user's own keys handle models.
     // If the user chose a subscription provider, treat that as "byok" unless
     // they explicitly set inferenceMode to "cloud".
-    const hasSubProvider = Boolean(config.agents?.defaults?.subscriptionProvider);
-    const explicitMode = cloud.inferenceMode;
-    const inferenceMode = explicitMode ?? (hasSubProvider ? "byok" : "cloud");
-    const inferenceToggle = cloud.services?.inference ?? true;
-    const cloudDoesInference = inferenceMode === "cloud" && inferenceToggle !== false;
+    const llmText = resolveServiceRoutingInConfig(config)?.llmText;
     const models = config.models;
-    if (effectivelyEnabled && cloudDoesInference) {
-        const small = models?.small || "openai/gpt-5-mini";
-        const large = models?.large || "anthropic/claude-sonnet-4.5";
+    if (effectivelyEnabled) {
+        const nano = llmText?.nanoModel || models?.nano || DEFAULT_ELIZA_CLOUD_TEXT_MODEL;
+        const small = llmText?.smallModel || models?.small || DEFAULT_ELIZA_CLOUD_TEXT_MODEL;
+        const medium = llmText?.mediumModel || models?.medium || small;
+        const large = llmText?.largeModel || models?.large || DEFAULT_ELIZA_CLOUD_TEXT_MODEL;
+        const mega = llmText?.megaModel || models?.mega || large;
+        const responseHandlerModel = llmText?.responseHandlerModel || llmText?.shouldRespondModel;
+        const actionPlannerModel = llmText?.actionPlannerModel || llmText?.plannerModel;
         process.env.SMALL_MODEL = small;
+        process.env.NANO_MODEL = nano;
+        process.env.MEDIUM_MODEL = medium;
         process.env.LARGE_MODEL = large;
+        process.env.MEGA_MODEL = mega;
+        if (responseHandlerModel) {
+            process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL = responseHandlerModel;
+            process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL = responseHandlerModel;
+        }
+        else {
+            delete process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL;
+            delete process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL;
+        }
+        if (actionPlannerModel) {
+            process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL = actionPlannerModel;
+            process.env.ELIZAOS_CLOUD_PLANNER_MODEL = actionPlannerModel;
+        }
+        else {
+            delete process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL;
+            delete process.env.ELIZAOS_CLOUD_PLANNER_MODEL;
+        }
+        process.env.ELIZAOS_CLOUD_NANO_MODEL = nano;
+        process.env.ELIZAOS_CLOUD_MEDIUM_MODEL = medium;
         process.env.ELIZAOS_CLOUD_SMALL_MODEL = small;
         process.env.ELIZAOS_CLOUD_LARGE_MODEL = large;
+        process.env.ELIZAOS_CLOUD_MEGA_MODEL = mega;
     }
-    else if (effectivelyEnabled) {
-        // Cloud enabled but inference handled by user's own keys — clean cloud
-        // model env vars so the cloud plugin doesn't intercept model calls.
+    else if (shouldLoadCloudPlugin) {
+        // Cloud plugin may still be active for non-inference services; keep model
+        // routing local by clearing the cloud model aliases.
+        delete process.env.ELIZAOS_CLOUD_NANO_MODEL;
+        delete process.env.ELIZAOS_CLOUD_MEDIUM_MODEL;
         delete process.env.ELIZAOS_CLOUD_SMALL_MODEL;
         delete process.env.ELIZAOS_CLOUD_LARGE_MODEL;
+        delete process.env.ELIZAOS_CLOUD_MEGA_MODEL;
+        delete process.env.ELIZAOS_CLOUD_RESPONSE_HANDLER_MODEL;
+        delete process.env.ELIZAOS_CLOUD_SHOULD_RESPOND_MODEL;
+        delete process.env.ELIZAOS_CLOUD_ACTION_PLANNER_MODEL;
+        delete process.env.ELIZAOS_CLOUD_PLANNER_MODEL;
+        delete process.env.NANO_MODEL;
+        delete process.env.MEDIUM_MODEL;
+        delete process.env.SMALL_MODEL;
+        delete process.env.LARGE_MODEL;
+        delete process.env.MEGA_MODEL;
     }
     // Propagate per-service disable flags so downstream code can check them
     // without needing direct access to the ElizaConfig object.
-    const services = cloud.services;
-    if (services) {
-        if (services.tts === false) {
-            process.env.ELIZA_CLOUD_TTS_DISABLED = "true";
-            process.env.ELIZA_CLOUD_TTS_DISABLED = "true";
-        }
-        else {
-            delete process.env.ELIZA_CLOUD_TTS_DISABLED;
-            delete process.env.ELIZA_CLOUD_TTS_DISABLED;
-        }
-        if (services.media === false) {
-            process.env.ELIZA_CLOUD_MEDIA_DISABLED = "true";
-            process.env.ELIZA_CLOUD_MEDIA_DISABLED = "true";
-        }
-        else {
-            delete process.env.ELIZA_CLOUD_MEDIA_DISABLED;
-            delete process.env.ELIZA_CLOUD_MEDIA_DISABLED;
-        }
-        if (services.embeddings === false) {
-            process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED = "true";
-            process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED = "true";
-        }
-        else {
-            delete process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED;
-            delete process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED;
-        }
-        if (services.rpc === false) {
-            process.env.ELIZA_CLOUD_RPC_DISABLED = "true";
-            process.env.ELIZA_CLOUD_RPC_DISABLED = "true";
-        }
-        else {
-            delete process.env.ELIZA_CLOUD_RPC_DISABLED;
-            delete process.env.ELIZA_CLOUD_RPC_DISABLED;
-        }
+    if (!topology.services.tts) {
+        process.env.ELIZA_CLOUD_TTS_DISABLED = "true";
+    }
+    else {
+        delete process.env.ELIZA_CLOUD_TTS_DISABLED;
+    }
+    if (!topology.services.media) {
+        process.env.ELIZA_CLOUD_MEDIA_DISABLED = "true";
+    }
+    else {
+        delete process.env.ELIZA_CLOUD_MEDIA_DISABLED;
+    }
+    if (!topology.services.embeddings) {
+        process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED = "true";
+    }
+    else {
+        delete process.env.ELIZA_CLOUD_EMBEDDINGS_DISABLED;
+    }
+    if (!topology.services.rpc) {
+        process.env.ELIZA_CLOUD_RPC_DISABLED = "true";
+    }
+    else {
+        delete process.env.ELIZA_CLOUD_RPC_DISABLED;
     }
 }
 /**
@@ -1569,8 +1184,8 @@ export function applyCloudConfigToEnv(config) {
  * 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 (`~/.eliza/workspace/.eliza/.elizadb`) and remove any stale
+ * `PGLITE_DATA_DIR` to either the configured value or the resolved default
+ * workspace (`<workspace>/.eliza/.elizadb`) and remove any stale
  * `POSTGRES_URL`.
  */
 /** @internal Exported for testing. */
@@ -1631,8 +1246,8 @@ export function applyDatabaseConfigToEnv(config) {
             mkdirSync(dataDir, { recursive: true });
             logger.info(`[eliza] PGlite data dir: ${dataDir} (${alreadyExisted ? "existed" : "created"})`);
             // Remove stale postmaster.pid left by a crashed process. Without this,
-            // PGlite sees the lock and either fails or triggers the destructive
-            // resetPgliteDataDir path, wiping all conversation history.
+            // PGlite sees the lock and either fails or, with explicit destructive
+            // recovery enabled, triggers the resetPgliteDataDir path.
             cleanStalePglitePid(dataDir);
         }
     }
@@ -1648,7 +1263,7 @@ function reconcilePglitePidFile(dataDir) {
         if (Number.isNaN(pid) || pid <= 0) {
             // Malformed pid file — remove it
             unlinkSync(pidPath);
-            logger.warn(`[eliza] Removed malformed PGlite postmaster.pid`);
+            logger.info(`[eliza] Removed malformed PGlite postmaster.pid`);
             return "cleared-malformed";
         }
         // Check if the process is still alive
@@ -1663,7 +1278,7 @@ function reconcilePglitePidFile(dataDir) {
             if (code === "ESRCH") {
                 // Process doesn't exist — stale pid file, safe to remove
                 unlinkSync(pidPath);
-                logger.warn(`[eliza] Removed stale PGlite postmaster.pid (process ${pid} not running)`);
+                logger.info(`[eliza] Removed stale PGlite postmaster.pid (process ${pid} not running)`);
                 return "cleared-stale";
             }
             else {
@@ -1684,7 +1299,12 @@ function reconcilePglitePidFile(dataDir) {
  * The pid file is stale if the recorded process is no longer running.
  */
 export function cleanStalePglitePid(dataDir) {
-    void reconcilePglitePidFile(dataDir);
+    try {
+        reconcilePglitePidFile(dataDir);
+    }
+    catch (err) {
+        logger.warn(`[eliza] PGlite PID reconciliation failed: ${err}`);
+    }
 }
 function collectErrorMessages(err) {
     const messages = [];
@@ -1730,12 +1350,18 @@ function isPgliteLockError(err) {
 }
 /** @internal Exported for testing. */
 export function isRecoverablePgliteInitError(err) {
+    const code = getPgliteErrorCode(err);
+    if (code === PGLITE_ERROR_CODES.ACTIVE_LOCK ||
+        code === PGLITE_ERROR_CODES.CORRUPT_DATA ||
+        code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED) {
+        return true;
+    }
     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 _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 = [
@@ -1748,34 +1374,69 @@ export function isRecoverablePgliteInitError(err) {
         "checkpoint failed",
         "checksum mismatch",
         "corrupt",
+        "could not read blocks",
+        "read only ",
+        "unreachable code should not be executed",
+        "_pgl_backend",
     ].some((needle) => haystack.includes(needle));
     if (hasMigrationsSchema)
         return true;
     if (hasAbort && hasPglite)
         return true;
-    if (hasRecoverableStorageSignal && (hasPglite || hasSqlite))
+    if (hasRecoverableStorageSignal)
         return true;
     return false;
 }
 /** @internal Exported for testing. */
 export function getPgliteRecoveryAction(err, dataDir) {
+    const code = getPgliteErrorCode(err);
+    if (code === PGLITE_ERROR_CODES.ACTIVE_LOCK) {
+        return "fail-active-lock";
+    }
+    if (code === PGLITE_ERROR_CODES.CORRUPT_DATA ||
+        code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED) {
+        return "fail-manual-reset";
+    }
     if (!isRecoverablePgliteInitError(err))
         return "none";
-    if (!isPgliteLockError(err))
-        return "reset-data-dir";
     const pidStatus = reconcilePglitePidFile(dataDir);
-    if (pidStatus === "active" ||
-        pidStatus === "active-unconfirmed" ||
-        pidStatus === "check-failed") {
+    const treatPidAsActiveLock = code === PGLITE_ERROR_CODES.ACTIVE_LOCK || isPgliteLockError(err);
+    if ((treatPidAsActiveLock && pidStatus === "active") ||
+        (treatPidAsActiveLock && pidStatus === "active-unconfirmed") ||
+        (treatPidAsActiveLock && pidStatus === "check-failed")) {
         return "fail-active-lock";
     }
     if (pidStatus === "cleared-stale" || pidStatus === "cleared-malformed") {
         return "retry-without-reset";
     }
-    return "reset-data-dir";
+    return "fail-manual-reset";
 }
 function createActivePgliteLockError(dataDir, err) {
-    return new Error(`PGLite data dir is already in use at ${dataDir}. Close the other Eliza process or set a different PGLITE_DATA_DIR before retrying.`, { cause: err });
+    if (getPgliteErrorCode(err) === PGLITE_ERROR_CODES.ACTIVE_LOCK &&
+        err instanceof Error) {
+        return err;
+    }
+    return createPgliteInitError(PGLITE_ERROR_CODES.ACTIVE_LOCK, `PGLite data dir is already in use at ${dataDir}. Close the other Eliza or Eliza process, or set a different PGLITE_DATA_DIR before retrying.`, { cause: err, dataDir });
+}
+function formatPgliteFailure(err) {
+    return collectErrorMessages(err)[0] ?? formatError(err);
+}
+function createManualResetRequiredPgliteError(dataDir, err) {
+    if (getPgliteErrorCode(err) === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED &&
+        err instanceof Error) {
+        return err;
+    }
+    const errorText = formatPgliteFailure(err);
+    const cause = getPgliteErrorCode(err) === PGLITE_ERROR_CODES.CORRUPT_DATA
+        ? err
+        : createPgliteInitError(PGLITE_ERROR_CODES.CORRUPT_DATA, `PGlite data dir at ${dataDir} appears corrupt or unreadable: ${errorText}`, { cause: err, dataDir });
+    return createPgliteInitError(PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED, `PGlite initialization failed for ${dataDir}: ${errorText}. Stop Eliza, then rename or delete only this directory before retrying: ${dataDir}`, { cause, dataDir });
+}
+export function isFatalPgliteStartupError(err) {
+    const code = getPgliteErrorCode(err);
+    return (code === PGLITE_ERROR_CODES.ACTIVE_LOCK ||
+        code === PGLITE_ERROR_CODES.CORRUPT_DATA ||
+        code === PGLITE_ERROR_CODES.MANUAL_RESET_REQUIRED);
 }
 function resolveActivePgliteDataDir(config) {
     const provider = config.database?.provider ?? "pglite";
@@ -1785,38 +1446,20 @@ function resolveActivePgliteDataDir(config) {
     const dataDir = configured || resolveDefaultPgliteDataDir(config);
     return resolveUserPath(dataDir);
 }
-async function resetPgliteDataDir(dataDir) {
-    const normalized = path.resolve(dataDir);
-    const root = path.parse(normalized).root;
-    if (normalized === root) {
-        throw new Error(`Refusing to reset unsafe PGLite path: ${normalized}`);
-    }
-    const stamp = new Date()
-        .toISOString()
-        .replace(/[-:]/g, "")
-        .replace(/\..*$/, "")
-        .replace("T", "-");
-    const backupDir = `${normalized}.corrupt-${stamp}`;
-    if (existsSync(normalized)) {
-        try {
-            await fs.rename(normalized, backupDir);
-            logger.warn(`[eliza] Backed up existing PGLite data dir to ${backupDir}`);
-        }
-        catch (err) {
-            logger.warn(`[eliza] Failed to back up PGLite data dir (${formatError(err)}); deleting ${normalized} instead`);
-            await fs.rm(normalized, { recursive: true, force: true });
-        }
-    }
-    await fs.mkdir(normalized, { recursive: true });
+/** Call whichever init method the adapter exposes (.init or .initialize). */
+async function callAdapterInit(adapter) {
+    const fn = "init" in adapter &&
+        typeof adapter.init === "function"
+        ? adapter.init
+        : adapter.initialize;
+    if (typeof fn === "function")
+        await fn.call(adapter);
 }
 async function initializeDatabaseAdapter(runtime, config) {
     if (!runtime.adapter || (await runtime.adapter.isReady()))
         return;
     try {
-        const adapterInit = runtime.adapter.init ??
-            runtime.adapter.initialize;
-        if (typeof adapterInit === "function")
-            await adapterInit.call(runtime.adapter);
+        await callAdapterInit(runtime.adapter);
         logger.info("[eliza] Database adapter initialized early (before plugin inits)");
     }
     catch (err) {
@@ -1831,21 +1474,12 @@ async function initializeDatabaseAdapter(runtime, config) {
         if (recoveryAction === "fail-active-lock") {
             throw createActivePgliteLockError(pgliteDataDir, err);
         }
-        if (recoveryAction === "retry-without-reset") {
-            logger.warn(`[eliza] PGLite init failed (${formatError(err)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying without resetting data.`);
+        if (recoveryAction === "fail-manual-reset") {
+            throw createManualResetRequiredPgliteError(pgliteDataDir, err);
         }
-        else {
-            logger.warn(`[eliza] PGLite init failed (${formatError(err)}). Resetting local DB at ${pgliteDataDir} and retrying once.`);
-            await resetPgliteDataDir(pgliteDataDir);
-            process.env.PGLITE_DATA_DIR = pgliteDataDir;
-        }
-        const adapterInit2 = runtime.adapter.init ??
-            runtime.adapter.initialize;
-        if (typeof adapterInit2 === "function")
-            await adapterInit2.call(runtime.adapter);
-        logger.info(recoveryAction === "retry-without-reset"
-            ? "[eliza] Database adapter recovered after clearing a stale PGLite lock"
-            : "[eliza] Database adapter recovered after resetting PGLite data");
+        logger.warn(`[eliza] PGLite init failed (${formatError(err)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying without resetting data.`);
+        await callAdapterInit(runtime.adapter);
+        logger.info("[eliza] Database adapter recovered after clearing a stale PGLite lock");
     }
     // Health check: verify PGlite data directory has files after init.
     // Runs on BOTH the happy path and the recovery path.
@@ -1956,6 +1590,7 @@ export function installRuntimeMethodBindings(runtime) {
     if (runtimeWithBindings.__elizaMethodBindingsInstalled) {
         return;
     }
+    installRuntimePluginLifecycle(runtime);
     // Some plugin builds store this method and invoke it later without the
     // runtime receiver, which breaks private-field access in AgentRuntime.
     runtime.getConversationLength = runtime.getConversationLength.bind(runtime);
@@ -1974,6 +1609,11 @@ export function installRuntimeMethodBindings(runtime) {
         "GROQ_API_KEY",
         "XAI_API_KEY",
         "DEEPSEEK_API_KEY",
+        "ZAI_API_KEY",
+        "Z_AI_API_KEY",
+        "MOONSHOT_API_KEY",
+        "KIMI_API_KEY",
+        "OPENAI_BASE_URL",
         "OPENROUTER_API_KEY",
         // Google model defaults
         "GOOGLE_SMALL_MODEL",
@@ -2007,7 +1647,7 @@ export function installRuntimeMethodBindings(runtime) {
         }
         return result;
     };
-    // Add targeted diagnostics around component writes. Rolodex reflection and
+    // Add targeted diagnostics around component writes. Relationships reflection and
     // relationship extraction rely heavily on components; when inserts fail,
     // upstream logs often hide the concrete DB cause/constraint.
     if (!runtimeWithBindings.__elizaComponentWriteDiagnosticsInstalled) {
@@ -2125,729 +1765,119 @@ export function installRuntimeMethodBindings(runtime) {
     }
     runtimeWithBindings.__elizaMethodBindingsInstalled = true;
 }
-function installActionAliases(runtime) {
-    const runtimeWithAliases = runtime;
-    if (runtimeWithAliases.__elizaActionAliasesInstalled) {
-        return;
-    }
-    const actions = Array.isArray(runtimeWithAliases.actions)
-        ? runtimeWithAliases.actions
-        : [];
-    // Keep compaction automatic-only; do not allow manual COMPACT_SESSION invokes.
-    const compactSessionIndex = actions.findIndex((action) => action?.name?.toUpperCase() === "COMPACT_SESSION");
-    if (compactSessionIndex !== -1) {
-        actions.splice(compactSessionIndex, 1);
-        logger.info("[eliza] Disabled manual COMPACT_SESSION action; auto-compaction remains enabled");
-    }
-    // Compatibility alias: older prompts/docs still reference CODE_TASK,
-    // while plugin-agent-orchestrator exposes CREATE_TASK.
-    const createTaskAction = actions.find((action) => action?.name?.toUpperCase() === "CREATE_TASK");
-    if (createTaskAction) {
-        const similes = Array.isArray(createTaskAction.similes)
-            ? createTaskAction.similes
-            : [];
-        const hasCodeTaskAlias = similes.some((simile) => simile.toUpperCase() === "CODE_TASK");
-        if (!hasCodeTaskAlias) {
-            createTaskAction.similes = [...similes, "CODE_TASK"];
-            logger.info("[eliza] Added action alias CODE_TASK -> CREATE_TASK for agent-orchestrator");
-        }
-    }
-    runtimeWithAliases.__elizaActionAliasesInstalled = 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) {
-            throw registerError;
-        }
-        const recoveryAction = getPgliteRecoveryAction(registerError, pgliteDataDir);
-        if (recoveryAction === "none") {
-            throw registerError;
-        }
-        if (recoveryAction === "fail-active-lock") {
-            throw createActivePgliteLockError(pgliteDataDir, registerError);
-        }
-        if (recoveryAction === "retry-without-reset") {
-            logger.warn(`[eliza] SQL plugin registration failed (${formatError(registerError)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying without resetting data.`);
-        }
-        else {
-            logger.warn(`[eliza] 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 Eliza config.
- *
- * Resolves the agent name from `config.agents.list` (first entry) or
- * `config.ui.assistant.name`, falling back to "Eliza".  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 setup.
- */
-/** @internal Exported for testing. */
-export function buildCharacterFromConfig(config) {
-    // Resolve name: agents list → ui assistant → "Eliza"
-    const agentEntry = config.agents?.list?.[0];
-    const name = agentEntry?.name ?? config.ui?.assistant?.name ?? "Eliza";
-    const bundledPreset = (() => {
-        const defaultPresetByName = {
-            Reimu: "uwu~",
-            Marisa: "hell yeah",
-            Yukari: "lol k",
-            Sakuya: "Noted.",
-            Koishi: "hehe~",
-            Remilia: "...",
-            Reisen: "locked in",
-        };
-        const presetByName = getPresetNameMap() ?? defaultPresetByName;
-        const presetCatchphrase = presetByName[name.trim()];
-        if (!presetCatchphrase)
-            return undefined;
-        return getStylePresets().find((preset) => preset.catchphrase === presetCatchphrase);
-    })();
-    // Read personality fields from the agent config entry (set during
-    // onboarding from the chosen style preset).  Fall back to generic
-    // defaults when the preset data is not present (e.g. pre-onboarding
-    // setup or configs created before this change). For built-in default
-    // characters, fall back to the bundled preset so legacy name-only configs
-    // still retain their default posts/messages.
-    const bio = agentEntry?.bio ??
-        bundledPreset?.bio ?? [
-        "{{name}} is an AI assistant powered by Eliza and elizaOS.",
-    ];
-    const systemPrompt = agentEntry?.system ??
-        bundledPreset?.system ??
-        "You are {{name}}, an autonomous AI agent powered by elizaOS.";
-    const style = agentEntry?.style ?? bundledPreset?.style;
-    const adjectives = agentEntry?.adjectives ?? bundledPreset?.adjectives;
-    const postExamples = agentEntry?.postExamples ?? bundledPreset?.postExamples;
-    const messageExamples = agentEntry?.messageExamples ?? bundledPreset?.messageExamples;
-    // Collect secrets from process.env (API keys the plugins need)
-    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_NUMBER",
-        "MSTEAMS_APP_ID",
-        "MSTEAMS_APP_PASSWORD",
-        "MATTERMOST_BOT_TOKEN",
-        "MATTERMOST_BASE_URL",
-        // ElizaCloud secrets
-        "ELIZAOS_CLOUD_API_KEY",
-        "ELIZAOS_CLOUD_BASE_URL",
-        "ELIZAOS_CLOUD_ENABLED",
-        // Wallet / blockchain secrets
-        "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 access for coding agent plugin
-        "GITHUB_TOKEN",
-        "GITHUB_OAUTH_CLIENT_ID",
-    ];
-    const secrets = {};
-    for (const key of secretKeys) {
-        const value = process.env[key];
-        if (value?.trim()) {
-            secrets[key] = value;
-        }
-    }
-    // Normalise messageExamples to the {examples: [{name,content}]} shape
-    // that @elizaos/core expects.  Config may contain EITHER format:
-    //   OLD (preset/onboarding): [[{user, content}, ...], ...]
-    //   NEW (@elizaos/core):     [{examples: [{name, content}, ...]}, ...]
-    const mappedExamples = messageExamples?.map((item) => {
-        // Already in new format — pass through
-        if (item &&
-            typeof item === "object" &&
-            "examples" in item) {
-            return item;
-        }
-        // Old format — array of {user, content} entries
-        const arr = item;
-        return {
-            examples: arr.map((msg) => ({
-                name: msg.name ?? msg.user ?? "",
-                content: msg.content,
-            })),
-        };
-    });
-    return mergeCharacterDefaults({
-        name,
-        ...(agentEntry?.username ? { username: agentEntry.username } : {}),
-        bio,
-        system: systemPrompt,
-        ...(agentEntry?.topics ? { topics: agentEntry.topics } : {}),
-        ...(style ? { style } : {}),
-        ...(adjectives ? { adjectives } : {}),
-        ...(postExamples ? { postExamples } : {}),
-        ...(mappedExamples ? { messageExamples: mappedExamples } : {}),
-        secrets,
-    });
-}
-/**
- * Resolve the primary model identifier from Eliza config.
- *
- * Eliza 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. */
-export function resolvePrimaryModel(config) {
-    const modelConfig = config.agents?.defaults?.model;
-    if (!modelConfig)
-        return undefined;
-    // AgentDefaultsConfig.model is AgentModelListConfig: { primary?, fallbacks? }
-    return modelConfig.primary;
-}
-/**
- * Vision is a heavy optional plugin. When Eliza enables it, keep the service
- * loaded but idle until the user explicitly selects CAMERA, SCREEN, or BOTH.
- * This avoids background capture loops during normal app startup.
- */
-export function resolveVisionModeSetting(config, env = process.env) {
-    const explicitMode = env.VISION_MODE?.trim();
-    if (explicitMode)
-        return explicitMode;
-    if (config.features?.vision === true)
-        return "OFF";
-    return undefined;
-}
-// ---------------------------------------------------------------------------
-// First-run onboarding
-// ---------------------------------------------------------------------------
-// Name pool + random picker shared with the web UI API server.
-// See src/runtime/onboarding-names.ts for the canonical list.
-import { pickRandomNames } from "./onboarding-names";
-// ---------------------------------------------------------------------------
-// Style presets — shared between CLI and GUI onboarding
-// ---------------------------------------------------------------------------
-import { getPresetNameMap, getStylePresets } from "../onboarding-presets";
-/**
- * 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];
-    const hasName = Boolean(agentEntry?.name || config.ui?.assistant?.name);
-    if (hasName)
-        return config;
-    // Only prompt when stdin is a TTY (interactive terminal)
-    if (!process.stdin.isTTY)
-        return config;
-    // Load @clack/prompts lazily — only needed for interactive CLI onboarding.
-    const clack = await loadClack();
-    // ── Step 1: Welcome ────────────────────────────────────────────────────
-    clack.intro("WELCOME TO MILADY!");
-    // ── Step 2: Name ───────────────────────────────────────────────────────
-    const randomNames = pickRandomNames(4);
-    const nameChoice = await clack.select({
-        message: "♡♡eliza♡♡: 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: "Eliza",
-        });
-        if (clack.isCancel(customName))
-            cancelOnboarding();
-        name = customName.trim() || "Eliza";
-    }
-    else {
-        name = nameChoice;
-    }
-    clack.log.message(`♡♡${name}♡♡: Oh that's right, I'm ${name}!`);
-    // ── Step 3: Catchphrase / writing style ────────────────────────────────
-    const styleChoice = await clack.select({
-        message: `${name}: Now... how do I like to talk again?`,
-        options: getStylePresets().map((preset) => ({
-            value: preset.catchphrase,
-            label: preset.catchphrase,
-            hint: preset.hint,
-        })),
-    });
-    if (clack.isCancel(styleChoice))
-        cancelOnboarding();
-    const chosenTemplate = getStylePresets().find((p) => p.catchphrase === styleChoice);
-    // ── Step 3.5: Runtime selection (Cloud vs Local) ───────────────────────
-    // Present the user with a choice of where to run their agent. Cloud mode
-    // skips the local AI provider, wallet, and GitHub steps.
-    let cloudOnboardingResult = null;
-    let isCloudMode = false;
-    const runtimeChoice = await clack.select({
-        message: `${name}: Where should I live?`,
-        options: [
-            {
-                value: "cloud",
-                label: "☁️  Eliza Cloud (recommended)",
-                hint: "zero setup — hosted, always online",
-            },
-            {
-                value: "local",
-                label: "💻  Run locally",
-                hint: "full control — runs on this machine",
-            },
-            {
-                value: "later",
-                label: "⏭️  Decide later",
-                hint: "start local, switch to cloud anytime",
-            },
-        ],
-    });
-    if (clack.isCancel(runtimeChoice))
-        cancelOnboarding();
-    if (runtimeChoice === "later") {
-        // User deferred the decision — continue with local setup (steps 4–7).
-        clack.log.info("No problem! Starting with local setup. You can switch to cloud anytime with `eliza cloud connect`.");
-    }
-    else if (runtimeChoice === "cloud") {
-        const { runCloudOnboarding } = await import("./cloud-onboarding");
-        cloudOnboardingResult = await runCloudOnboarding(clack, name, chosenTemplate);
-        if (cloudOnboardingResult?.agentId) {
-            isCloudMode = true;
-            clack.log.success(`${name} is now running in the cloud! ☁️`);
-        }
-        else if (cloudOnboardingResult) {
-            // Auth succeeded but no agent provisioned — save auth for later
-            clack.log.info("Cloud auth saved. You can provision later with `eliza cloud connect`.");
-        }
-        else {
-            // Cloud flow cancelled / failed — fall back to local
-            clack.log.info("No worries! Setting up locally instead.");
-        }
-    }
-    // ── Steps 4–7: Local-only setup ─────────────────────────────────────────
-    // These steps are skipped when the user chose Eliza Cloud, since the cloud
-    // handles inference, wallets can be configured via the dashboard, and
-    // GitHub access is not needed for the initial cloud agent.
-    let providerEnvKey;
-    let providerApiKey;
-    // Snapshot whether wallet keys already exist BEFORE onboarding touches
-    // process.env, so the persistence block later can guard against
-    // overwriting pre-existing values.
-    const hasEvmKey = Boolean(process.env.EVM_PRIVATE_KEY?.trim());
-    const hasSolKey = Boolean(process.env.SOLANA_PRIVATE_KEY?.trim());
-    if (!isCloudMode) {
-        // ── Step 4: Model provider ───────────────────────────────────────────────
-        // Skip provider selection in cloud mode — Eliza Cloud handles inference.
-        // Check whether an API key is already set in the environment (from .env or
-        // shell).  If none is found, ask the user to pick a provider and enter a key.
-        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",
-            },
-        ];
-        // Detect if any provider key is already configured
-        const detectedProvider = PROVIDER_OPTIONS.find((p) => p.detectKeys.some((key) => process.env[key]?.trim()));
-        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" : undefined,
-                    })),
-                    {
-                        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") {
-                        // Ollama just needs a base URL, default to localhost
-                        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();
-                    }
-                }
-            }
-        }
-        // ── Step 4b: Embedding model preset ────────────────────────────────────
-        // (Simplified: always use the standard/reliable model preset. No user choice.)
-        // ── Step 5: Wallet setup ───────────────────────────────────────────────
-        // Offer to generate or import wallets for EVM and Solana. Keys are
-        // stored in config.env and process.env, making them available to
-        // plugins at runtime.
-        const { generateWalletKeys, importWallet } = await import("../api/wallet");
-        // hasEvmKey and hasSolKey are hoisted above the if (!isCloudMode) block
-        // so they're also available in the persistence section.
-        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") {
-                // EVM 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}`);
-                        }
-                    }
-                }
-                // Solana import
-                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}`);
-                        }
-                    }
-                }
-            }
-            // "skip" — do nothing
-        }
-        // ── Step 6: Skills Registry (ClawHub default) ──────────────────────────
-        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";
-        }
-        // ── Step 7: GitHub access (for coding agents, issue management) ─────────
-        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.");
-            }
-        }
-    } // end if (!isCloudMode)
-    // ── Step 8: Persist agent + style + provider + embedding config ─────────
-    // Save the agent name and chosen personality template into config so that
-    // the same character data is used regardless of whether the user onboarded
-    // via CLI or GUI.  This ensures full parity between onboarding surfaces.
-    const existingList = config.agents?.list ?? [];
-    const mainEntry = existingList[0] ?? {
-        id: "main",
-        default: true,
-    };
-    const agentConfigEntry = { ...mainEntry, name };
-    // Apply the chosen style template to the agent config entry so the
-    // personality is persisted — not just the name.
-    if (chosenTemplate) {
-        agentConfigEntry.bio = chosenTemplate.bio;
-        agentConfigEntry.system = chosenTemplate.system;
-        agentConfigEntry.style = chosenTemplate.style;
-        agentConfigEntry.adjectives = chosenTemplate.adjectives;
-        agentConfigEntry.postExamples = chosenTemplate.postExamples;
-        agentConfigEntry.messageExamples = chosenTemplate.messageExamples;
-    }
-    const updatedList = [
-        agentConfigEntry,
-        ...existingList.slice(1),
-    ];
-    const updated = {
-        ...config,
-        agents: {
-            ...config.agents,
-            list: updatedList,
-        },
-    };
-    // Persist the provider API key and wallet keys in config.env so they
-    // survive restarts.  Initialise the env bucket once to avoid the
-    // repeated `if (!updated.env)` pattern.
-    if (!updated.env)
-        updated.env = {};
-    const envBucket = updated.env;
-    // Only persist local-mode env vars when not in cloud mode (those vars
-    // were never prompted for / set during cloud onboarding).
-    if (!isCloudMode) {
-        if (providerEnvKey && providerApiKey) {
-            envBucket[providerEnvKey] = providerApiKey;
-            // Also set immediately in process.env for the current run
-            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) {
-            envBucket.SKILLS_REGISTRY = process.env.SKILLS_REGISTRY;
-        }
-        if (process.env.SKILLSMP_API_KEY) {
-            envBucket.SKILLSMP_API_KEY = process.env.SKILLSMP_API_KEY;
-        }
-        if (process.env.GITHUB_TOKEN) {
-            envBucket.GITHUB_TOKEN = process.env.GITHUB_TOKEN;
-        }
-        if (process.env.GITHUB_OAUTH_CLIENT_ID) {
-            envBucket.GITHUB_OAUTH_CLIENT_ID = process.env.GITHUB_OAUTH_CLIENT_ID;
-        }
-    }
-    // ── Cloud config persistence ───────────────────────────────────────────
-    // If the user completed cloud onboarding, persist the cloud credentials
-    // and agent ID so subsequent `eliza start` connects directly.
-    if (cloudOnboardingResult) {
-        updated.cloud = {
-            ...updated.cloud,
-            enabled: isCloudMode,
-            provider: "elizacloud",
-            apiKey: cloudOnboardingResult.apiKey,
-            baseUrl: cloudOnboardingResult.baseUrl,
-            inferenceMode: isCloudMode ? "cloud" : updated.cloud?.inferenceMode,
-            runtime: isCloudMode ? "cloud" : "local",
-        };
-        if (cloudOnboardingResult.agentId) {
-            updated.cloud.agentId = cloudOnboardingResult.agentId;
+function installActionAliases(runtime) {
+    const runtimeWithAliases = runtime;
+    if (runtimeWithAliases.__elizaActionAliasesInstalled) {
+        return;
+    }
+    const actions = Array.isArray(runtimeWithAliases.actions)
+        ? runtimeWithAliases.actions
+        : [];
+    // Keep compaction automatic-only; do not allow manual COMPACT_SESSION invokes.
+    const compactSessionIndex = actions.findIndex((action) => action?.name?.toUpperCase() === "COMPACT_SESSION");
+    if (compactSessionIndex !== -1) {
+        actions.splice(compactSessionIndex, 1);
+        logger.info("[eliza] Disabled manual COMPACT_SESSION action; auto-compaction remains enabled");
+    }
+    // Compatibility alias: older prompts/docs still reference CODE_TASK,
+    // while agent-orchestrator exposes START_CODING_TASK.
+    const codingTaskAction = actions.find((action) => action?.name?.toUpperCase() === "START_CODING_TASK") ??
+        actions.find((action) => action?.name?.toUpperCase() === "CREATE_TASK");
+    if (codingTaskAction) {
+        const similes = Array.isArray(codingTaskAction.similes)
+            ? codingTaskAction.similes
+            : [];
+        const hasCodeTaskAlias = similes.some((simile) => simile.toUpperCase() === "CODE_TASK");
+        if (!hasCodeTaskAlias) {
+            codingTaskAction.similes = [...similes, "CODE_TASK"];
+            logger.info("[eliza] Added action alias CODE_TASK -> START_CODING_TASK for agent-orchestrator");
         }
     }
+    runtimeWithAliases.__elizaActionAliasesInstalled = true;
+}
+async function registerSqlPluginWithRecovery(runtime, sqlPlugin, config) {
+    let registerError = null;
     try {
-        saveElizaConfig(updated);
+        await runtime.registerPlugin(sqlPlugin.plugin);
     }
     catch (err) {
-        // Non-fatal: the agent can still start, but choices won't persist.
-        clack.log.warn(`Could not save config: ${formatError(err)}`);
+        registerError = err;
+    }
+    if (registerError) {
+        const pgliteDataDir = resolveActivePgliteDataDir(config);
+        if (!pgliteDataDir) {
+            throw registerError;
+        }
+        const recoveryAction = getPgliteRecoveryAction(registerError, pgliteDataDir);
+        if (recoveryAction === "none") {
+            throw registerError;
+        }
+        if (recoveryAction === "fail-active-lock") {
+            throw createActivePgliteLockError(pgliteDataDir, registerError);
+        }
+        if (recoveryAction === "fail-manual-reset") {
+            throw createManualResetRequiredPgliteError(pgliteDataDir, registerError);
+        }
+        logger.warn(`[eliza] SQL plugin registration failed (${formatError(registerError)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying without resetting data.`);
+        try {
+            await runtime.registerPlugin(sqlPlugin.plugin);
+        }
+        catch (retryErr) {
+            if (!isPluginAlreadyRegisteredError(retryErr)) {
+                throw retryErr;
+            }
+        }
     }
-    clack.log.message(`${name}: ${styleChoice} Alright, that's me.`);
-    clack.outro(isCloudMode ? "Your agent is live in the cloud! ☁️" : "Let's get started!");
-    return updated;
+    await initializeDatabaseAdapter(runtime, config);
+}
+export { buildCharacterFromConfig, resolvePreferredProviderId, resolvePreferredProviderPluginName, resolvePrimaryModel, };
+/**
+ * Vision is a heavy optional plugin. When Eliza enables it, keep the service
+ * loaded but idle until the user explicitly selects CAMERA, SCREEN, or BOTH.
+ * This avoids background capture loops during normal app startup.
+ */
+export function resolveVisionModeSetting(config, env = process.env) {
+    const explicitMode = env.VISION_MODE?.trim();
+    if (explicitMode)
+        return explicitMode;
+    if (config.features?.vision === true)
+        return "OFF";
+    return undefined;
+}
+/** @internal Exported for testing. */
+export function resolveWalletRuntimeSettings(config, env = process.env) {
+    const directRpcUrl = trimEnvString(env.SOLANA_RPC_URL);
+    const solanaNoActions = trimEnvString(env.SOLANA_NO_ACTIONS);
+    const configEnv = config?.env;
+    const configVars = configEnv?.vars &&
+        typeof configEnv.vars === "object" &&
+        !Array.isArray(configEnv.vars)
+        ? configEnv.vars
+        : undefined;
+    const getConfigEnvString = (key) => {
+        const value = configVars?.[key] ?? configEnv?.[key];
+        return typeof value === "string" && value.trim() ? value.trim() : undefined;
+    };
+    const explicitSolanaPublicKey = trimEnvString(env.SOLANA_PUBLIC_KEY) ??
+        trimEnvString(env.WALLET_PUBLIC_KEY) ??
+        getConfigEnvString("SOLANA_PUBLIC_KEY") ??
+        getConfigEnvString("WALLET_PUBLIC_KEY");
+    const derivedSolanaPublicKey = trimEnvString(getWalletAddresses().solanaAddress) ??
+        trimEnvString(syncSolanaPublicKeyEnv(getConfigEnvString("SOLANA_PRIVATE_KEY")));
+    const solanaPublicKey = explicitSolanaPublicKey ?? derivedSolanaPublicKey;
+    const settings = {};
+    if (directRpcUrl) {
+        settings.SOLANA_RPC_URL = directRpcUrl;
+    }
+    if (solanaNoActions) {
+        settings.SOLANA_NO_ACTIONS = solanaNoActions;
+    }
+    if (!solanaPublicKey) {
+        return settings;
+    }
+    settings.SOLANA_PUBLIC_KEY = solanaPublicKey;
+    settings.WALLET_PUBLIC_KEY = solanaPublicKey;
+    return settings;
 }
 /**
  * Boot the elizaOS runtime without starting the readline chat loop.
@@ -2877,11 +1907,12 @@ const LEVEL_TO_NAME = {
     60: "fatal",
 };
 export const logToChatListener = (entry) => {
-    if (entry.roomId && entry.runtime) {
-        const runtime = entry.runtime;
+    const chatEntry = entry;
+    if (chatEntry.roomId && chatEntry.runtime) {
+        const runtime = chatEntry.runtime;
         // access dynamic property
         const overrides = runtime.logLevelOverrides;
-        const overrideLevel = overrides?.get(String(entry.roomId));
+        const overrideLevel = overrides?.get(String(chatEntry.roomId));
         if (overrideLevel) {
             const levelKey = entry.level;
             const levelName = (levelKey && LEVEL_TO_NAME[levelKey] ? LEVEL_TO_NAME[levelKey] : "log").toUpperCase();
@@ -2894,7 +1925,9 @@ export const logToChatListener = (entry) => {
                 source: "system",
                 isLog: "true",
             })
-                .catch(() => { });
+                .catch((err) => {
+                logger.debug(`[runtime] failed to send log message to target: ${err}`);
+            });
         }
     }
 };
@@ -2905,8 +1938,13 @@ export const logToChatListener = (entry) => {
  * interactive readline loop.
  */
 export async function startEliza(opts) {
+    // Resolve and register baseline `@elizaos/plugin-*` modules into the
+    // STATIC_ELIZA_PLUGINS map BEFORE any plugin resolution happens. See the
+    // comment on `ensureCoreStaticPluginsRegistered()` for why this isn't a
+    // module-init top-level await.
+    await ensureCoreStaticPluginsRegistered();
     // Start buffering logs early so startup messages appear in the UI log viewer
-    const { captureEarlyLogs } = await import("../api/early-logs");
+    const { captureEarlyLogs } = await import("../api/early-logs.js");
     captureEarlyLogs();
     // Register log listener for chat mirroring
     addLogListener(logToChatListener);
@@ -2950,18 +1988,75 @@ export async function startEliza(opts) {
     applyX402ConfigToEnv(config);
     // 2d. Propagate database config into process.env for plugin-sql
     applyDatabaseConfigToEnv(config);
-    // 2e. Propagate arbitrary env vars from config.env into process.env.
+    // 2e. Boot-time vault hydration. Migrate plaintext sensitive values from
+    // eliza.json + config.env + sensitive process.env keys into the OS-keychain
+    // vault, then resolve any vault://KEY sentinels in `config.env` so the
+    // legacy hydration loop below sees real values.
+    {
+        try {
+            const { hydrateWalletKeysFromNodePlatformSecureStore } = await importAppCoreRuntime();
+            await hydrateWalletKeysFromNodePlatformSecureStore();
+        }
+        catch (err) {
+            logger.warn(`[wallet][os-store] boot hydrate skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const { runVaultBootstrap } = await importAppCoreRuntime();
+        const { sharedVault } = await importAppCoreRuntime();
+        const bootResult = await runVaultBootstrap();
+        logger.info(`[vault-bootstrap] migrated=${bootResult.migrated} failed=${bootResult.failed.length}`);
+        const { resolved, missing } = await resolveConfigEnvForProcess(config.env, sharedVault());
+        if (missing.length > 0) {
+            logger.warn(`[vault-bootstrap] sentinel(s) without vault entry: ${missing.join(", ")}`);
+        }
+        if (config.env &&
+            typeof config.env === "object" &&
+            !Array.isArray(config.env)) {
+            for (const [key, value] of Object.entries(resolved)) {
+                config.env[key] = value;
+            }
+        }
+        const varsBag = config.env?.vars;
+        if (varsBag && typeof varsBag === "object" && !Array.isArray(varsBag)) {
+            const varsResult = await resolveConfigEnvForProcess(varsBag, sharedVault());
+            for (const [key, value] of Object.entries(varsResult.resolved)) {
+                varsBag[key] = value;
+            }
+        }
+    }
+    // 2f. Propagate arbitrary env vars from config.env into process.env.
     // Eliza stores user-defined env vars (plugin settings, API URLs, etc.)
     // in config.env; elizaOS plugins read them via process.env / getSetting.
+    // Skip ELIZAOS_CLOUD_* — applyCloudConfigToEnv() owns those; otherwise a
+    // stale key in config.env refills process.env after disconnect cleared it.
     if (config.env &&
         typeof config.env === "object" &&
         !Array.isArray(config.env)) {
         for (const [key, value] of Object.entries(config.env)) {
+            if (isElizaCloudManagedProcessEnvKey(key))
+                continue;
             if (typeof value === "string" && !process.env[key]) {
                 process.env[key] = value;
             }
         }
+        // Also hydrate from config.env.vars — setEnvValue writes API keys to
+        // both config.env["KEY"] and config.env.vars["KEY"]. If the top-level
+        // key was lost (e.g. pruneEnv, config migration), the nested form is
+        // the authoritative source.
+        const vars = config.env.vars;
+        if (vars && typeof vars === "object" && !Array.isArray(vars)) {
+            for (const [key, value] of Object.entries(vars)) {
+                if (isElizaCloudManagedProcessEnvKey(key))
+                    continue;
+                if (typeof value === "string" && !process.env[key]) {
+                    process.env[key] = value;
+                }
+            }
+        }
     }
+    // Keep the canonical public key env in sync for Solana plugins that still
+    // read process.env directly instead of runtime settings.
+    syncSolanaPublicKeyEnv();
+    normalizeOpenAiCompatibleProviderConfig(config);
     // Log active database configuration for debugging persistence issues
     {
         const dbProvider = config.database?.provider ?? "pglite";
@@ -2972,16 +2067,18 @@ export async function startEliza(opts) {
                 ? ` | data dir: ${pgliteDir}`
                 : "") +
             (dbProvider === "postgres" && postgresUrl
-                ? ` | connection: ${postgresUrl.replace(/:\/\/([^:]+):([^@]+)@/, "://$1:***@")}`
+                ? ` | connection: ${(postgresUrl.length > 4096 ? postgresUrl.slice(0, 4096) : postgresUrl).replace(/:\/\/([^:@]{1,1024}):([^@]{1,1024})@/, "://$1:***@")}`
                 : ""));
     }
     // 2d-iii. OG tracking code initialization
-    try {
-        const { initializeOGCode } = await import("../api/og-tracker");
-        initializeOGCode();
-    }
-    catch {
-        // Silent — OG tracking is non-critical
+    if (!isMobilePlatform()) {
+        try {
+            const { initializeOGCode } = await loadElizaMakerModule();
+            initializeOGCode?.();
+        }
+        catch {
+            // Silent — OG tracking is non-critical
+        }
     }
     // 2d-ii. Allow destructive migrations (e.g. dropping tables removed between
     //        plugin versions) so the runtime doesn't silently stall.  Without this
@@ -2990,11 +2087,38 @@ export async function startEliza(opts) {
     if (!process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS) {
         process.env.ELIZA_ALLOW_DESTRUCTIVE_MIGRATIONS = "true";
     }
-    // 2e-ii. Ensure SECRET_SALT is set to suppress the @elizaos/core default
-    //        warning and avoid using a predictable value in production.
+    // 2e-ii. SECRET_SALT must be stable across boots — multiple consumers key
+    //        durable encryption off it (core/settings.ts encryptStringValue,
+    //        encryptedCharacter for character.secrets, runtime.ts decryptSecret,
+    //        advanced-capabilities settings). Previously we generated a random
+    //        value per process, which silently invalidated every persisted
+    //        ciphertext on restart (decryptStringValue returns the encrypted
+    //        string on failure, so connector logins just stopped working
+    //        without an error). Persist to <stateDir>/secret-salt instead.
     if (!process.env.SECRET_SALT) {
-        process.env.SECRET_SALT = crypto.randomBytes(32).toString("hex");
-        logger.info("[eliza] Generated random SECRET_SALT for this session");
+        const secretSaltPath = path.join(resolveStateDir(), "secret-salt");
+        let salt = null;
+        try {
+            const cached = readFileSync(secretSaltPath, "utf8").trim();
+            if (/^[0-9a-f]{64}$/.test(cached)) {
+                salt = cached;
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        if (!salt) {
+            salt = crypto.randomBytes(32).toString("hex");
+            mkdirSync(path.dirname(secretSaltPath), { recursive: true });
+            // 0o600: only the user account that wrote it can read it. The salt
+            // is a key-derivation input — anyone who reads it plus the
+            // ciphertext can decrypt persisted secrets.
+            writeFileSync(secretSaltPath, salt, { encoding: "utf8", mode: 0o600 });
+            logger.info(`[eliza] Generated SECRET_SALT and persisted to ${secretSaltPath}`);
+        }
+        process.env.SECRET_SALT = salt;
     }
     // 2e-iii. Pre-flight validation for Google AI API keys.  If the key looks
     //         obviously invalid (too short, placeholder, wrong prefix), clear it
@@ -3011,35 +2135,114 @@ export async function startEliza(opts) {
             delete process.env[gkey];
         }
     }
-    // 2f. Apply subscription-based credentials (Claude Max, Codex Max)
+    // 2f. Install the multi-account pool shims and apply selected direct API
+    //     accounts before plugin resolution snapshots process.env.
+    try {
+        const accountPool = await importAppCoreRuntime();
+        accountPool.getDefaultAccountPool();
+        await accountPool.applyAccountPoolApiCredentials({
+            activeBackend: resolveServiceRoutingInConfig(config)?.llmText?.backend,
+            accountStrategies: config.accountStrategies,
+            serviceRouting: resolveServiceRoutingInConfig(config),
+        });
+        accountPool.startAccountPoolKeepAlive();
+    }
+    catch (err) {
+        logger.debug(`[eliza] Account pool bootstrap skipped: ${formatError(err)}`);
+    }
+    // 2g. Apply subscription-based credentials (Claude Max, Codex Max).
+    //     Failure is non-fatal — the agent can still start with other providers.
+    //     Config is NOT rolled back on failure; partial mutations may persist in
+    //     the in-memory config but are not saved to disk until explicit save.
     try {
-        const { applySubscriptionCredentials } = await import("../auth/index");
+        const { applySubscriptionCredentials } = await import("../auth/index.js");
         await applySubscriptionCredentials(config);
     }
     catch (err) {
-        logger.warn(`[eliza] Failed to apply subscription credentials: ${err}`);
+        logger.warn(`[eliza] Failed to apply subscription credentials (agent will continue without them): ${formatError(err)}`);
     }
-    // 2g. Cloud mode — if the user chose cloud during onboarding (or on a
+    // 2h. Cloud mode — if the user chose cloud during onboarding (or on a
     //     subsequent start with cloud config), skip local runtime setup and
     //     connect via the thin client instead.
-    if (config.cloud?.enabled &&
+    const deploymentTarget = resolveDeploymentTargetInConfig(config);
+    // 2h-pre. Store-variant build: macOS App Sandbox / MAS / MS Store / Flathub
+    // policy is incompatible with running an embedded local AgentRuntime, so
+    // store builds must route to Eliza Cloud. If the cloud config is missing,
+    // fail loudly and route the user to onboarding.
+    const { isStoreBuild } = await importAppCoreRuntime();
+    if (isStoreBuild()) {
+        if (deploymentTarget.runtime === "local") {
+            throw new Error("[eliza] Store-variant builds cannot run a local agent. " +
+                "Pair an Eliza Cloud account in onboarding, or switch to the direct download build.");
+        }
+        if (!config.cloud?.apiKey?.trim() || !config.cloud?.agentId?.trim()) {
+            throw new Error("[eliza] Store-variant build requires a paired Eliza Cloud account. " +
+                "Run onboarding to link Eliza Cloud, or switch to the direct download build.");
+        }
+        return startInCloudMode(config, config.cloud.agentId, opts);
+    }
+    if (deploymentTarget.runtime === "cloud" &&
+        deploymentTarget.provider === "elizacloud" &&
         config.cloud?.apiKey &&
-        config.cloud?.agentId &&
-        config.cloud?.runtime === "cloud") {
+        config.cloud?.agentId?.trim()) {
         return startInCloudMode(config, config.cloud.agentId, opts);
     }
     // 3. Build elizaOS Character from Eliza config
     const character = buildCharacterFromConfig(config);
     const primaryModel = resolvePrimaryModel(config);
+    const preferredProviderId = resolvePreferredProviderId(config);
+    const preferredProviderPluginName = resolvePreferredProviderPluginName(config);
     // 4. Ensure workspace exists with required files
     const workspaceDir = config.agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
-    await ensureAgentWorkspace({ dir: workspaceDir, ensureInitFiles: true });
+    await ensureAgentWorkspace({
+        dir: workspaceDir,
+        ensureInitFiles: shouldBootstrapWorkspaceInitFiles(workspaceDir),
+    });
     // 4b. Ensure custom plugins directory exists for drop-in plugins
-    await fs.mkdir(path.join(resolveStateDir(), CUSTOM_PLUGINS_DIRNAME), {
+    await fs.mkdir(path.join(resolveStateDir(), CUSTOM_RUNTIME_PLUGINS_DIRNAME), {
         recursive: true,
     });
     // 5. Create the Eliza bridge plugin (workspace context + session keys + compaction)
     const agentId = character.name?.toLowerCase().replace(/\s+/g, "-") ?? "main";
+    // 5-pre0. Apply per-agent vault profile overrides to process.env.
+    //
+    // Vault keys with multiple named profiles (work / personal / throwaway)
+    // resolve the active profile for THIS agent through the vault's
+    // routing layer, then write the resolved value into process.env so
+    // the synchronous runtime.getSetting fast path picks it up. Idempotent;
+    // safe to run multiple times. Opt-out via
+    // ELIZA_DISABLE_VAULT_PROFILE_RESOLVER=1.
+    if (process.env.ELIZA_DISABLE_VAULT_PROFILE_RESOLVER !== "1") {
+        try {
+            const { sharedVault } = await importAppCoreRuntime();
+            const { applyVaultProfilesForAgent } = await import("./vault-profile-resolver.js");
+            await applyVaultProfilesForAgent(sharedVault(), agentId);
+        }
+        catch (err) {
+            logger.warn(`[vault-profile-resolver] boot-time apply failed agent="${agentId}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // 5-pre. Ensure each agent has its own EVM + Solana keypair in the vault.
+    // The runtime-wide EVM_PRIVATE_KEY / SOLANA_PRIVATE_KEY (process.env) is
+    // the *user* wallet; per-agent wallets live inside the encrypted vault and
+    // are surfaced separately in the in-app browser. Idempotent — existing
+    // wallets are preserved. Opt-out via ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP=1.
+    if (process.env.ELIZA_DISABLE_AGENT_WALLET_BOOTSTRAP !== "1") {
+        try {
+            const { sharedVault } = await importAppCoreRuntime();
+            const { ensureAgentWallets } = await import("./agent-wallets.js");
+            const descriptors = await ensureAgentWallets(sharedVault(), agentId, "agent-bootstrap");
+            const summary = descriptors
+                .map((d) => `${d.chain}:${d.address}`)
+                .join(" ");
+            logger.info(`[agent-wallets] agent="${agentId}" wallets ready (${summary})`);
+        }
+        catch (err) {
+            logger.warn(`[agent-wallets] failed to ensure wallets for agent="${agentId}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // 5a. If cloud is configured and no local GitHub token, try fetching from cloud
+    await autoFetchCloudGithubToken(config.cloud?.agentId?.trim() || agentId);
     const elizaPlugin = createElizaPlugin({
         workspaceDir,
         agentId,
@@ -3074,6 +2277,7 @@ export async function startEliza(opts) {
             pluginCount: resolvedPlugins.length,
             providerCount: providerNames.length,
             primaryModel: primaryModel ?? "(auto-detect)",
+            preferredProvider: preferredProviderId ?? "(auto-detect)",
             workspaceDir,
         };
         debugLogResolvedContext(pluginNames, providerNames, contextSummary, (msg) => logger.debug(msg));
@@ -3108,7 +2312,7 @@ export async function startEliza(opts) {
     const runtimeLogLevel = (() => {
         // process.env.LOG_LEVEL is already resolved (set explicitly or from
         // config.logging.level above), so prefer it to honour the dev-mode
-        // LOG_LEVEL=error override set by scripts/dev-ui.mjs.
+        // LOG_LEVEL=error override set by eliza/packages/app-core/scripts/dev-ui.mjs.
         const lvl = process.env.LOG_LEVEL ?? config.logging?.level ?? "error";
         if (lvl === "silent")
             return "fatal";
@@ -3185,24 +2389,51 @@ export async function startEliza(opts) {
         });
     }
     // ── End sandbox setup ───────────────────────────────────────────────────
-    // ── Boost preferred model plugin priority ─────────────────────────────
+    // ── Boost preferred provider plugin priority ──────────────────────────
     // elizaOS selects the model handler with the highest `priority` for each
     // ModelType.  All provider plugins default to priority 0, so whichever
     // registers first wins — essentially random when using Promise.all.
-    // When the user has explicitly chosen a primary model provider (via
-    // `model.primary` in config), we bump that plugin's priority so its
-    // handlers are always selected over other providers.
+    // When the user has explicitly selected a provider or model, prefer that
+    // provider's plugin so its handlers are selected over registration order.
     const pluginsForRuntime = otherPlugins.map((p) => p.plugin);
     const visionModeSetting = resolveVisionModeSetting(config);
-    if (primaryModel) {
+    if (preferredProviderPluginName) {
         for (const plugin of pluginsForRuntime) {
-            if (plugin.name === primaryModel) {
+            if (plugin.name === preferredProviderPluginName) {
                 plugin.priority = (plugin.priority ?? 0) + 10;
-                logger.info(`[eliza] Boosted plugin "${plugin.name}" priority to ${plugin.priority} (model.primary)`);
+                logger.info(`[eliza] Boosted plugin "${plugin.name}" priority to ${plugin.priority} (preferred provider: ${preferredProviderId ?? "unknown"})`);
                 break;
             }
         }
     }
+    // ── Strip upstream skill providers ──────────────────────────────────────
+    // The upstream @elizaos/plugin-agent-skills registers providers that dump
+    // ALL loaded skills into every prompt (~2000-4000 tokens).  Eliza replaces
+    // them with a BM25-lite dynamic provider (see providers/skill-provider.ts)
+    // that injects only the most relevant skills per turn.
+    //
+    // We keep:
+    //   - agent_skills_overview  (lightweight stats, ~50 tokens)
+    //   - all actions (USE_SKILL, SEARCH_SKILLS, INSTALL_SKILL, …)
+    //   - the AGENT_SKILLS_SERVICE itself
+    {
+        const UPSTREAM_SKILL_PROVIDERS_TO_STRIP = new Set([
+            "agent_skills",
+            "agent_skill_instructions",
+            "agent_skills_catalog",
+        ]);
+        for (const plugin of pluginsForRuntime) {
+            if (plugin.name === "@elizaos/plugin-agent-skills" &&
+                Array.isArray(plugin.providers)) {
+                const before = plugin.providers.length;
+                plugin.providers = plugin.providers.filter((p) => !UPSTREAM_SKILL_PROVIDERS_TO_STRIP.has(p.name ?? ""));
+                const removed = before - plugin.providers.length;
+                if (removed > 0) {
+                    logger.info(`[eliza] Stripped ${removed} upstream skill provider(s) — using dynamic BM25-lite provider instead`);
+                }
+            }
+        }
+    }
     // Deduplicate actions across all plugins to avoid "Action already registered"
     // warnings from elizaOS core. basic-capabilities is registered first by the
     // runtime, so include it in deduplication so its actions take precedence.
@@ -3226,7 +2457,7 @@ export async function startEliza(opts) {
         character,
         // advancedCapabilities: true,
         actionPlanning: true,
-        // advancedMemory: true, // Not supported in this version of AgentRuntime
+        // advancedMemory is enabled via character.advancedMemory
         plugins: [elizaPlugin, ...pluginsForRuntime],
         ...(runtimeLogLevel ? { logLevel: runtimeLogLevel } : {}),
         // Sandbox options — only active when mode != "off"
@@ -3252,9 +2483,30 @@ export async function startEliza(opts) {
             // allowed since plugins need them via runtime.getSetting(). Private keys
             // should only be accessed via process.env by signing services.
             ...Object.fromEntries(Object.entries(collectConfigEnvVars(config)).filter(([key]) => isEnvKeyAllowedForForwarding(key))),
+            // Forward connector config vars as-is. The connector env map is curated
+            // and plugins need access to secrets like passwords and tokens via
+            // runtime.getSetting() for real transports to boot.
+            ...collectConnectorEnvVars(config),
             // Forward Eliza config env vars as runtime settings
-            ...(primaryModel ? { MODEL_PROVIDER: primaryModel } : {}),
+            ...(preferredProviderId ? { MODEL_PROVIDER: preferredProviderId } : {}),
             ...(visionModeSetting ? { VISION_MODE: visionModeSetting } : {}),
+            ...resolveWalletRuntimeSettings(config),
+            ...(typeof config.agents?.defaults?.adminEntityId === "string" &&
+                config.agents.defaults.adminEntityId.trim().length > 0
+                ? {
+                    ELIZA_ADMIN_ENTITY_ID: config.agents.defaults.adminEntityId.trim(),
+                }
+                : {}),
+            ...(config.agents?.defaults?.ownerContacts
+                ? {
+                    ELIZA_OWNER_CONTACTS_JSON: JSON.stringify(config.agents.defaults.ownerContacts),
+                }
+                : {}),
+            ...(config.roles?.connectorAdmins
+                ? {
+                    ELIZA_ROLES_CONNECTOR_ADMINS_JSON: JSON.stringify(config.roles.connectorAdmins),
+                }
+                : {}),
             // Forward skills config so plugin-agent-skills can apply allow/deny filtering
             ...(config.skills?.allowBundled
                 ? { SKILLS_ALLOWLIST: config.skills.allowBundled.join(",") }
@@ -3282,6 +2534,28 @@ export async function startEliza(opts) {
         },
     });
     installRuntimeMethodBindings(runtime);
+    // 7a. Mobile local inference must be registered before runtime.initialize().
+    // Runtime services probe TEXT_EMBEDDING during init; registering the local
+    // handler only after startEliza() returns leaves mobile local mode booting
+    // with "no provider" diagnostics and disabled embedding services.
+    if (process.env.ELIZA_LOCAL_LLAMA?.trim() === "1") {
+        try {
+            const { ensureAospLocalInferenceHandlers } = await import("@elizaos/plugin-aosp-local-inference");
+            await ensureAospLocalInferenceHandlers(runtime);
+        }
+        catch (err) {
+            logger.warn(`[eliza] AOSP local inference pre-registration skipped: ${formatError(err)}`);
+        }
+    }
+    else if (process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1") {
+        try {
+            const { ensureMobileDeviceBridgeInferenceHandlers } = await import("@elizaos/plugin-capacitor-bridge");
+            await ensureMobileDeviceBridgeInferenceHandlers(runtime);
+        }
+        catch (err) {
+            logger.warn(`[eliza] Mobile device bridge pre-registration skipped: ${formatError(err)}`);
+        }
+    }
     // 7b. Pre-register plugin-sql so the adapter is ready before other plugins init.
     //     This is OPTIONAL — without it, some features (memory, todos) won't work.
     //     runtime.db is a getter that returns this.adapter.db and throws when
@@ -3319,6 +2593,14 @@ export async function startEliza(opts) {
     //     Each registerPlugin() call runs the plugin's init() before proceeding
     //     to the next, guaranteeing that cross-plugin getService() calls resolve.
     {
+        try {
+            logger.info("[eliza] Pre-registering roles capability...");
+            await runtime.registerPlugin(rolesPlugin);
+            logger.info("[eliza] ✓ roles capability pre-registered");
+        }
+        catch (err) {
+            logger.warn(`[eliza] Roles capability pre-registration failed: ${formatError(err)}`);
+        }
         const alreadyPreRegistered = new Set([
             "@elizaos/plugin-sql",
             "@elizaos/plugin-local-embedding",
@@ -3394,23 +2676,114 @@ export async function startEliza(opts) {
         }
     };
     const initializeRuntimeServices = async () => {
+        if (process.env.ELIZA_LEGACY_STEWARD_EVM_BRIDGE !== "0") {
+            try {
+                const { stewardEvmPreBoot } = await loadStewardEvmBridgeModule();
+                await stewardEvmPreBoot?.(runtime);
+            }
+            catch (err) {
+                logger.debug(`[eliza] Steward EVM pre-boot skipped: ${formatError(err)}`);
+            }
+        }
+        // 7f. Pre-register ConnectorSetupService so connector plugins can access
+        //     shared config/escalation/owner-contact helpers via runtime.getService().
+        try {
+            const { ConnectorSetupService } = await import("../services/connector-setup-service.js");
+            await runtime.registerService(ConnectorSetupService);
+        }
+        catch (err) {
+            logger.debug(`[eliza] ConnectorSetupService registration skipped: ${formatError(err)}`);
+        }
         // 8. Initialize the runtime (registers remaining plugins, starts services)
+        assertPersistentDatabaseRequired(runtime);
         await runtime.initialize();
-        await waitForTrajectoryLoggerService(runtime, "runtime.initialize()");
-        ensureTrajectoryLoggerEnabled(runtime, "runtime.initialize()");
+        await prepareRuntimeForTrajectoryCapture(runtime, "runtime.initialize()", config);
+        // 8a. Apply legacy role redaction to protected plugin providers.
+        try {
+            const { applyPluginRoleGating } = await import("./plugin-role-gating.js");
+            applyPluginRoleGating(runtime.plugins ?? []);
+        }
+        catch (err) {
+            logger.debug(`[eliza] Plugin provider role gating skipped: ${formatError(err)}`);
+        }
+        // 8b. Register conversation-proximity provider for post-turn evaluators.
+        // This is read-only context; relationship writes are handled by the
+        // evaluator service from model-extracted relationship updates.
+        try {
+            const { conversationProximityProvider } = await import("../providers/conversation-proximity.js");
+            await runtime.registerPlugin({
+                name: "eliza-conversation-proximity",
+                description: "Read-only co-participant context for post-turn evaluators",
+                providers: [conversationProximityProvider],
+            });
+            logger.info("[eliza] ✓ conversation-proximity provider registered");
+        }
+        catch (err) {
+            logger.debug(`[eliza] Conversation-proximity provider skipped: ${formatError(err)}`);
+        }
+        try {
+            if (runtimeDocumentsEnabled(runtime)) {
+                await seedBundledDocuments(runtime);
+            }
+            else {
+                logger.info("[eliza] Native documents disabled; skipping bundled document seeding");
+            }
+        }
+        catch (err) {
+            logger.warn(`[eliza] Failed to seed bundled documents: ${formatError(err)}`);
+        }
+        if (process.env.ELIZA_LEGACY_STEWARD_EVM_BRIDGE !== "0") {
+            try {
+                const { stewardEvmPostBoot } = await loadStewardEvmBridgeModule();
+                await stewardEvmPostBoot?.(runtime);
+            }
+            catch (err) {
+                logger.debug(`[eliza] Steward EVM post-boot skipped: ${formatError(err)}`);
+            }
+        }
+        try {
+            const { installAnthropicWebSearch } = await import("./web-search-tools.js");
+            installAnthropicWebSearch(runtime);
+        }
+        catch (err) {
+            logger.debug(`[eliza] Anthropic web search setup skipped: ${formatError(err)}`);
+        }
         // 8b. Ensure AutonomyService is available for trigger dispatch.
         // registers this service) from loading, so we start it explicitly.
-        if (!runtime.getService("AUTONOMY")) {
+        // Respect ENABLE_AUTONOMY env var — cloud-provisioned containers may
+        // disable this to prevent runaway autonomous actions.
+        const autonomyEnabled = (process.env.ENABLE_AUTONOMY ?? "true").toLowerCase() !== "false";
+        if (autonomyEnabled && !runtime.getService("AUTONOMY")) {
             try {
-                await AutonomyService.start(runtime);
+                await startAndRegisterAutonomyService(runtime);
                 logger.info("[eliza] AutonomyService started for trigger dispatch");
             }
             catch (err) {
                 logger.warn(`[eliza] AutonomyService failed to start: ${formatError(err)}`);
             }
         }
+        else if (!autonomyEnabled) {
+            logger.info("[eliza] AutonomyService skipped — ENABLE_AUTONOMY=false");
+        }
+        // Enable the autonomy loop so memories injected into the autonomy
+        // room (e.g. by workflow nodes that post into autonomy) are actually
+        // processed by the agent's autonomous reasoning.
+        if (autonomyEnabled) {
+            const autonomySvc = getAutonomyService(runtime);
+            if (autonomySvc) {
+                try {
+                    await autonomySvc.enableAutonomy();
+                    logger.info("[eliza] AutonomyService enabled — trigger instructions will be processed");
+                }
+                catch (err) {
+                    logger.warn(`[eliza] Failed to enable autonomy loop: ${formatError(err)}`);
+                }
+            }
+        }
         // Do not block runtime startup on skills warm-up.
-        void warmAgentSkillsService();
+        void warmAgentSkillsService().catch((err) => {
+            logger.warn(`[eliza] Skills warm-up failed: ${formatError(err)}`);
+        });
     };
     try {
         await initializeRuntimeServices();
@@ -3426,19 +2799,16 @@ export async function startEliza(opts) {
         if (recoveryAction === "fail-active-lock") {
             throw createActivePgliteLockError(pgliteDataDir, err);
         }
-        logger.warn(recoveryAction === "retry-without-reset"
-            ? `[eliza] Runtime migrations failed (${formatError(err)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying startup once without resetting data.`
-            : `[eliza] Runtime migrations failed (${formatError(err)}). Resetting local PGLite DB at ${pgliteDataDir} and retrying startup once.`);
+        if (recoveryAction === "fail-manual-reset") {
+            throw createManualResetRequiredPgliteError(pgliteDataDir, err);
+        }
+        logger.warn(`[eliza] Runtime migrations failed (${formatError(err)}). Cleared a stale PGLite lock in ${pgliteDataDir} and retrying startup once without resetting data.`);
         try {
             await shutdownRuntime(runtime, "PGLite recovery");
         }
         catch {
             // Ignore cleanup errors — retry creates a fresh runtime anyway.
         }
-        if (recoveryAction === "reset-data-dir") {
-            await resetPgliteDataDir(pgliteDataDir);
-            process.env.PGLITE_DATA_DIR = pgliteDataDir;
-        }
         return await startEliza({
             ...opts,
             pgliteRecoveryAttempted: true,
@@ -3452,36 +2822,10 @@ export async function startEliza(opts) {
     // stack on every hot-restart, close over stale runtime references, and
     // race with bun --watch's own process teardown.
     if (!opts?.headless) {
-        let isShuttingDown = false;
-        const shutdown = async () => {
-            if (isShuttingDown)
-                return;
-            isShuttingDown = true;
-            try {
-                // Stop sandbox manager before runtime
-                if (sandboxManager) {
-                    try {
-                        await sandboxManager.stop();
-                        logger.info("[eliza] Sandbox manager stopped");
-                    }
-                    catch (err) {
-                        logger.warn(`[eliza] Sandbox stop error: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-            }
-            catch (err) {
-                logger.warn(`[eliza] Sandbox shutdown error: ${formatError(err)}`);
-            }
-            try {
-                await shutdownRuntime(runtime, "signal shutdown");
-            }
-            catch (err) {
-                logger.warn(`[eliza] Error during shutdown: ${formatError(err)}`);
-            }
-            process.exit(0);
-        };
-        process.on("SIGINT", () => void shutdown());
-        process.on("SIGTERM", () => void shutdown());
+        registerSignalShutdownHandlers({
+            getRuntime: () => runtime,
+            getSandboxManager: () => sandboxManager,
+        });
     }
     const loadHooksSystem = async () => {
         try {
@@ -3503,7 +2847,9 @@ export async function startEliza(opts) {
     };
     // ── Headless mode — return runtime for API server wiring ──────────────
     if (opts?.headless) {
-        void loadHooksSystem();
+        void loadHooksSystem().catch((err) => {
+            logger.warn(`[eliza] Hooks system load failed: ${formatError(err)}`);
+        });
         logger.info("[eliza] Runtime initialised in headless mode (autonomy enabled)");
         return runtime;
     }
@@ -3516,8 +2862,8 @@ export async function startEliza(opts) {
     // desktop app, the API server is always available for the GUI admin
     // surface.
     try {
-        const { startApiServer } = await import("../api/server");
-        const apiPort = Number(process.env.ELIZA_PORT || process.env.ELIZA_PORT) || 2138;
+        const { startApiServer } = await import("../api/server.js");
+        const apiPort = resolveServerOnlyPort(process.env);
         const { port: actualApiPort } = await startApiServer({
             port: apiPort,
             runtime,
@@ -3525,8 +2871,34 @@ export async function startEliza(opts) {
                 logger.info("[eliza] Hot-reload: Restarting runtime...");
                 try {
                     // Stop the old runtime to release resources (DB connections, timers, etc.)
+                    //
+                    // WHY the 2s timeout: some services — notably PTYService —
+                    // shut down gracefully by awaiting each active session with a
+                    // per-session timeout (up to ~5s). runtime.stop() awaits every
+                    // service.stop() sequentially, so a single idle PTY session
+                    // turns a provider switch into a multi-second block. During
+                    // that window the runtime-operations active-op slot +
+                    // agentState === "restarting" guard reject further clicks,
+                    // which is why flipping through providers rapidly feels stuck.
+                    //
+                    // Cap the shutdown window at 2s; if it doesn't finish, log and
+                    // bring the new runtime up anyway. Services that miss the
+                    // window get GC'd when the process unwinds. This is fine for a
+                    // user-initiated restart — the user asked for a new runtime;
+                    // in-flight work on the old one is already obsolete.
                     try {
-                        await shutdownRuntime(runtime, "hot-reload cleanup");
+                        const SHUTDOWN_TIMEOUT_MS = 2000;
+                        let shutdownTimedOut = false;
+                        await Promise.race([
+                            shutdownRuntime(runtime, "hot-reload cleanup"),
+                            new Promise((resolve) => setTimeout(() => {
+                                shutdownTimedOut = true;
+                                resolve();
+                            }, SHUTDOWN_TIMEOUT_MS)),
+                        ]);
+                        if (shutdownTimedOut) {
+                            logger.warn(`[eliza] Hot-reload: old runtime shutdown exceeded ${SHUTDOWN_TIMEOUT_MS}ms; proceeding with new runtime`);
+                        }
                     }
                     catch (stopErr) {
                         logger.warn(`[eliza] Hot-reload: old runtime stop failed: ${formatError(stopErr)}`);
@@ -3543,10 +2915,24 @@ export async function startEliza(opts) {
                     applyCloudConfigToEnv(freshConfig);
                     applyX402ConfigToEnv(freshConfig);
                     applyDatabaseConfigToEnv(freshConfig);
+                    await autoFetchCloudGithubToken(freshConfig.cloud?.agentId?.trim() || agentId);
+                    try {
+                        const accountPool = await importAppCoreRuntime();
+                        accountPool.getDefaultAccountPool();
+                        await accountPool.applyAccountPoolApiCredentials({
+                            activeBackend: resolveServiceRoutingInConfig(freshConfig)?.llmText?.backend,
+                            accountStrategies: freshConfig.accountStrategies,
+                            serviceRouting: resolveServiceRoutingInConfig(freshConfig),
+                        });
+                        accountPool.startAccountPoolKeepAlive();
+                    }
+                    catch (poolErr) {
+                        logger.debug(`[eliza] Hot-reload: account pool bootstrap skipped: ${formatError(poolErr)}`);
+                    }
                     // Apply subscription-based credentials (Claude Max, Codex Max)
                     // that may have been set up during onboarding.
                     try {
-                        const { applySubscriptionCredentials } = await import("../auth/index");
+                        const { applySubscriptionCredentials } = await import("../auth/index.js");
                         await applySubscriptionCredentials(freshConfig);
                     }
                     catch (subErr) {
@@ -3566,14 +2952,15 @@ export async function startEliza(opts) {
                     // Filter out pre-registered plugins so they aren't double-loaded
                     // inside initialize()'s Promise.all — same pattern as the initial
                     // startup to avoid the TEXT_EMBEDDING race condition.
-                    const freshPrimaryModel = resolvePrimaryModel(freshConfig);
+                    const freshPreferredProviderId = resolvePreferredProviderId(freshConfig);
+                    const freshPreferredProviderPluginName = resolvePreferredProviderPluginName(freshConfig);
                     const freshOtherPlugins = resolvedPlugins.filter((p) => !PREREGISTER_PLUGINS.has(p.name));
-                    // Boost preferred model plugin priority (same as initial startup)
+                    // Boost the preferred provider plugin priority (same as initial startup)
                     const freshPluginsForRuntime = freshOtherPlugins.map((p) => p.plugin);
                     const freshVisionModeSetting = resolveVisionModeSetting(freshConfig);
-                    if (freshPrimaryModel) {
+                    if (freshPreferredProviderPluginName) {
                         for (const plugin of freshPluginsForRuntime) {
-                            if (plugin.name === freshPrimaryModel) {
+                            if (plugin.name === freshPreferredProviderPluginName) {
                                 plugin.priority = (plugin.priority ?? 0) + 10;
                                 break;
                             }
@@ -3584,8 +2971,8 @@ export async function startEliza(opts) {
                         plugins: [freshElizaPlugin, ...freshPluginsForRuntime],
                         ...(runtimeLogLevel ? { logLevel: runtimeLogLevel } : {}),
                         settings: {
-                            ...(freshPrimaryModel
-                                ? { MODEL_PROVIDER: freshPrimaryModel }
+                            ...(freshPreferredProviderId
+                                ? { MODEL_PROVIDER: freshPreferredProviderId }
                                 : {}),
                             ...(freshVisionModeSetting
                                 ? { VISION_MODE: freshVisionModeSetting }
@@ -3612,6 +2999,12 @@ export async function startEliza(opts) {
                     }
                     // Pre-register remaining core plugins sequentially (same as startup)
                     {
+                        try {
+                            await newRuntime.registerPlugin(rolesPlugin);
+                        }
+                        catch (err) {
+                            logger.warn(`[eliza] Hot-reload: roles capability pre-registration failed: ${formatError(err)}`);
+                        }
                         const alreadyPreRegistered = new Set([
                             "@elizaos/plugin-sql",
                             "@elizaos/plugin-local-embedding",
@@ -3630,18 +3023,60 @@ export async function startEliza(opts) {
                             }
                         }
                     }
+                    assertPersistentDatabaseRequired(newRuntime);
+                    try {
+                        const { ConnectorSetupService: CSSReload } = await import("../services/connector-setup-service.js");
+                        await newRuntime.registerService(CSSReload);
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    try {
+                        const { stewardEvmPreBoot: preBootHR } = await loadStewardEvmBridgeModule();
+                        await preBootHR?.(newRuntime);
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    assertPersistentDatabaseRequired(newRuntime);
                     await newRuntime.initialize();
-                    await waitForTrajectoryLoggerService(newRuntime, "hot-reload runtime.initialize()");
-                    ensureTrajectoryLoggerEnabled(newRuntime, "hot-reload runtime.initialize()");
-                    // Ensure AutonomyService survives hot-reload
-                    if (!newRuntime.getService("AUTONOMY")) {
+                    await prepareRuntimeForTrajectoryCapture(newRuntime, "hot-reload runtime.initialize()", config);
+                    try {
+                        const { applyPluginRoleGating } = await import("./plugin-role-gating.js");
+                        applyPluginRoleGating(newRuntime.plugins ?? []);
+                    }
+                    catch (err) {
+                        logger.debug(`[eliza] Hot-reload plugin provider role gating skipped: ${formatError(err)}`);
+                    }
+                    try {
+                        const { stewardEvmPostBoot: postBootHR } = await loadStewardEvmBridgeModule();
+                        await postBootHR?.(newRuntime);
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                    // Ensure AutonomyService survives hot-reload (respects ENABLE_AUTONOMY)
+                    const hotReloadAutonomyEnabled = (process.env.ENABLE_AUTONOMY ?? "true").toLowerCase() !== "false";
+                    if (hotReloadAutonomyEnabled && !newRuntime.getService("AUTONOMY")) {
                         try {
-                            await AutonomyService.start(newRuntime);
+                            await startAndRegisterAutonomyService(newRuntime);
                         }
                         catch (err) {
                             logger.warn(`[eliza] AutonomyService failed to start after hot-reload: ${formatError(err)}`);
                         }
                     }
+                    // Enable the autonomy loop after hot-reload (same as initial boot)
+                    if (hotReloadAutonomyEnabled) {
+                        const svc = getAutonomyService(newRuntime);
+                        if (svc) {
+                            try {
+                                await svc.enableAutonomy();
+                            }
+                            catch (err) {
+                                logger.warn(`[eliza] Failed to enable autonomy after hot-reload: ${formatError(err)}`);
+                            }
+                        }
+                    }
                     installActionAliases(newRuntime);
                     runtime = newRuntime;
                     logger.info("[eliza] Hot-reload: Runtime restarted successfully");
@@ -3678,19 +3113,13 @@ export async function startEliza(opts) {
         console.log("[eliza] Server running. Press Ctrl+C to stop.");
         // Keep process alive — the API server handles all interaction
         const keepAlive = setInterval(() => { }, 1 << 30); // ~12 days
-        // Cleanup on exit
-        const cleanup = async () => {
-            clearInterval(keepAlive);
-            try {
-                await shutdownRuntime(runtime, "server-only shutdown");
-            }
-            catch (err) {
-                logger.warn(`[eliza] Error stopping runtime: ${formatError(err)}`);
-            }
-            process.exit(0);
-        };
-        process.on("SIGINT", () => void cleanup());
-        process.on("SIGTERM", () => void cleanup());
+        registerSignalShutdownHandlers({
+            getRuntime: () => runtime,
+            getSandboxManager: () => sandboxManager,
+            beforeShutdown: () => {
+                clearInterval(keepAlive);
+            },
+        });
         return runtime;
     }
     // ── Interactive chat loop ────────────────────────────────────────────────
@@ -3840,18 +3269,12 @@ export async function startEliza(opts) {
     };
     prompt();
 }
-// When run directly (not imported), start immediately.
-// Use path.resolve to normalise both sides before comparing so that
-// symlinks, trailing slashes, and relative paths don't cause false negatives.
-// ---------------------------------------------------------------------------
-// Cloud thin-client mode
-// ---------------------------------------------------------------------------
-/**
- * Start in cloud mode — connect to a remote cloud agent via the thin client.
- * Skips all local runtime construction (plugins, database, etc.).
- */
 export async function startInCloudMode(config, agentId, opts) {
-    const { CloudManager } = await import("../cloud/cloud-manager");
+    // Cloud mode does not run a local AgentRuntime, but the registry must still
+    // be populated for any code path that touches `STATIC_ELIZA_PLUGINS` while
+    // the cloud proxy is active.
+    await ensureCoreStaticPluginsRegistered();
+    const { CloudManager } = await import("@elizaos/plugin-elizacloud");
     const cloudConfig = config.cloud;
     if (!cloudConfig) {
         throw new Error("Cloud mode requires a cloud configuration block in the config");
@@ -3864,13 +3287,13 @@ export async function startInCloudMode(config, agentId, opts) {
     });
     try {
         await manager.init();
-        const proxy = await manager.connect(agentId);
+        const proxy = (await manager.connect(agentId));
         if (opts?.headless || opts?.serverOnly) {
             // In headless/server mode, start the API server with the cloud proxy.
             // The proxy exposes the same interface the API server needs.
             logger.info(`[eliza] Cloud agent connected (headless). Agent: ${proxy.agentName}`);
-            // Return undefined — the cloud proxy handles everything.
-            // TODO: Wire proxy into the API server for GUI mode.
+            // Return undefined here; GUI cloud mode is handled through the
+            // dedicated cloud proxy routes instead of a local AgentRuntime.
             return undefined;
         }
         // Interactive CLI mode — simple chat loop against the cloud agent
@@ -3922,20 +3345,24 @@ export async function startInCloudMode(config, agentId, opts) {
         const msg = err instanceof Error ? err.message : String(err);
         logger.error(`[eliza] Failed to connect to cloud agent: ${msg}`);
         throw new Error(`Failed to connect to cloud agent: ${msg}\n` +
-            "You can retry with `eliza start`, or switch to local mode with `eliza config set cloud.runtime local`");
+            "You can retry with `eliza start`, or switch to local mode by setting `deploymentTarget.runtime` to `local`");
     }
 }
 const isDirectRun = (() => {
+    // Mobile (bundled) builds set ELIZA_DISABLE_DIRECT_RUN=1 via Bun's
+    // `--define`. After bundling, `import.meta.url` and `process.argv[1]`
+    // collapse to the same bundle path, so this check spuriously matches and
+    // the runtime self-invokes a SECOND `startEliza()` alongside the CLI's
+    // primary one. The second invocation lacks `{ serverOnly: true }` and
+    // drops into the readline chat loop, which closes on stdin EOF and tears
+    // the whole process down.
+    if (process.env.ELIZA_DISABLE_DIRECT_RUN === "1")
+        return false;
     const scriptArg = process.argv[1];
     if (!scriptArg)
         return false;
     const normalised = path.resolve(scriptArg);
-    // Exact match against this module's file URL
-    if (import.meta.url === pathToFileURL(normalised).href)
-        return true;
-    // Fallback: match the specific filename (handles tsx rewriting)
-    const base = path.basename(normalised);
-    return base === "eliza.ts" || base === "eliza";
+    return import.meta.url === pathToFileURL(normalised).href;
 })();
 if (isDirectRun) {
     startEliza().catch((err) => {