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

package/packages/agent/src/runtime/default-documents.js

@@ -0,0 +1,283 @@
+import path from "node:path";
+import { logger, MemoryType, stringToUuid, } from "@elizaos/core";
+const DOCUMENT_BATCH_SIZE = 100;
+const DEFAULT_DOCUMENTS_SOURCE = "eliza-default-documents";
+const DOCUMENTS_TABLE = "documents";
+const DOCUMENT_FRAGMENTS_TABLE = "document_fragments";
+export const ELIZA_OVERVIEW_TEXT = "Eliza is an autonomous agent powered by elizaOS, the agent framework. Users can ask Eliza to write code, add new skills, and trigger recurring workflows with heartbeats that run at regular intervals. Eliza Cloud is an open source cloud backend that simplifies deploying and delivering Eliza.";
+export const ELIZA_HISTORY_TEXT = "ELIZA was created by Joseph Weizenbaum at MIT in the mid-1960s and is widely regarded as one of the earliest chatbots. Its best-known script, DOCTOR, used pattern matching to imitate a Rogerian psychotherapist and showed how simple language rules could feel surprisingly conversational. ELIZA helped define the history of chatbots and influenced later work on conversational agents.";
+export const ELIZA_CLOUD_BASICS_TEXT = "Eliza Cloud is the managed backend and app platform for Eliza and Milady when cloud mode is enabled. Builders can create and manage apps, keep an appId, use Cloud login and redirect flows so app users can authenticate against Cloud, route chat and media through Cloud, monetize app usage with inference markup and purchase-share settings, promote apps, connect payment requests, and deploy Docker containers when an app needs server-side execution.";
+export const ELIZA_CLOUD_MONETIZATION_TEXT = "Eliza and Milady can help builders make money with Cloud apps: create monetized apps, set inference markup and app-credit purchase share, send payment requests through Stripe/OxaPay app credits or x402 crypto payments, track whether requests were paid, route payment results back into the initiating conversation, earn from affiliate and creator revenue-share flows, and request admin-reviewed elizaOS token payouts on Base, BSC, Ethereum, or Solana. Paid actions require explicit user confirmation.";
+export const DEFAULT_DOCUMENTS = [
+    {
+        key: "eliza-overview",
+        version: 1,
+        filename: "eliza-overview.txt",
+        contentType: "text/plain",
+        text: ELIZA_OVERVIEW_TEXT,
+        fragments: [
+            {
+                text: ELIZA_OVERVIEW_TEXT,
+            },
+        ],
+    },
+    {
+        key: "eliza-history",
+        version: 1,
+        filename: "eliza-history.txt",
+        contentType: "text/plain",
+        text: ELIZA_HISTORY_TEXT,
+        fragments: [
+            {
+                text: ELIZA_HISTORY_TEXT,
+            },
+        ],
+    },
+    {
+        key: "eliza-cloud-basics",
+        version: 2,
+        filename: "eliza-cloud-basics.txt",
+        contentType: "text/plain",
+        text: ELIZA_CLOUD_BASICS_TEXT,
+        fragments: [
+            {
+                text: ELIZA_CLOUD_BASICS_TEXT,
+            },
+        ],
+    },
+    {
+        key: "eliza-cloud-monetization",
+        version: 1,
+        filename: "eliza-cloud-monetization.txt",
+        contentType: "text/plain",
+        text: ELIZA_CLOUD_MONETIZATION_TEXT,
+        fragments: [
+            {
+                text: ELIZA_CLOUD_MONETIZATION_TEXT,
+            },
+        ],
+    },
+];
+function getDocumentId(agentId, key) {
+    return stringToUuid(`eliza-default-knowledge:${agentId}:${key}:document`);
+}
+function getFragmentId(agentId, key, index) {
+    return stringToUuid(`eliza-default-knowledge:${agentId}:${key}:fragment:${index}`);
+}
+function getExpectedEmbeddingDimensions(runtime) {
+    const raw = runtime.getSetting("EMBEDDING_DIMENSION");
+    const parsed = typeof raw === "number"
+        ? raw
+        : typeof raw === "string"
+            ? Number.parseInt(raw, 10)
+            : Number.NaN;
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function normalizeProvidedEmbedding(runtime, document, index, embedding) {
+    if (!embedding || embedding.length === 0) {
+        return undefined;
+    }
+    if (!embedding.every((value) => Number.isFinite(value))) {
+        logger.warn(`[eliza] Ignoring bundled document embedding for ${document.filename} fragment ${index}: vector contains non-finite values.`);
+        return undefined;
+    }
+    const expectedDimensions = getExpectedEmbeddingDimensions(runtime);
+    if (expectedDimensions !== undefined &&
+        embedding.length !== expectedDimensions) {
+        logger.warn(`[eliza] Ignoring bundled document embedding for ${document.filename} fragment ${index}: expected ${expectedDimensions} dimensions, received ${embedding.length}.`);
+        return undefined;
+    }
+    return [...embedding];
+}
+function extractTimestamp(memory) {
+    const metadata = memory?.metadata;
+    const timestamp = metadata?.timestamp;
+    return typeof timestamp === "number" && Number.isFinite(timestamp)
+        ? timestamp
+        : Date.now();
+}
+function buildDocumentMetadata(document, documentId, agentId, timestamp) {
+    const parsed = path.parse(document.filename);
+    return {
+        type: MemoryType.DOCUMENT,
+        documentId,
+        filename: document.filename,
+        originalFilename: document.filename,
+        title: parsed.name || document.filename,
+        fileExt: parsed.ext.replace(/^\./, ""),
+        fileType: document.contentType,
+        contentType: document.contentType,
+        fileSize: Buffer.byteLength(document.text, "utf8"),
+        source: DEFAULT_DOCUMENTS_SOURCE,
+        timestamp,
+        scope: "global",
+        scopedToEntityId: undefined,
+        addedBy: agentId,
+        addedByRole: "RUNTIME",
+        addedFrom: "default-seed",
+        addedAt: timestamp,
+        bundledDocument: true,
+        bundledDocumentKey: document.key,
+        bundledDocumentVersion: document.version,
+        ...(document.metadata ?? {}),
+    };
+}
+function buildFragmentMetadata(document, documentId, _documentAgentId, index, agentId, timestamp) {
+    return {
+        type: MemoryType.FRAGMENT,
+        documentId,
+        position: index,
+        source: DEFAULT_DOCUMENTS_SOURCE,
+        timestamp,
+        scope: "global",
+        scopedToEntityId: undefined,
+        addedBy: agentId,
+        addedByRole: "RUNTIME",
+        addedFrom: "default-seed",
+        addedAt: timestamp,
+        bundledDocument: true,
+        bundledDocumentKey: document.key,
+        bundledDocumentVersion: document.version,
+    };
+}
+function embeddingsEqual(left, right) {
+    if (left === right)
+        return true;
+    if (!left || !right)
+        return false;
+    if (left.length !== right.length)
+        return false;
+    return left.every((value, index) => value === right[index]);
+}
+function documentMatchesDefinition(existing, document, documentId) {
+    if (!existing)
+        return false;
+    const metadata = existing.metadata;
+    return (existing.content.text === document.text &&
+        metadata?.type === MemoryType.DOCUMENT &&
+        metadata?.documentId === documentId &&
+        metadata?.filename === document.filename &&
+        metadata?.contentType === document.contentType &&
+        metadata?.bundledDocumentKey === document.key &&
+        metadata?.bundledDocumentVersion === document.version);
+}
+function fragmentMatchesDefinition(existing, document, documentId, index, text, embedding) {
+    if (!existing)
+        return false;
+    const metadata = existing.metadata;
+    const existingEmbedding = Array.isArray(existing.embedding)
+        ? existing.embedding
+        : undefined;
+    return (existing.content.text === text &&
+        metadata?.type === MemoryType.FRAGMENT &&
+        metadata?.documentId === documentId &&
+        metadata?.position === index &&
+        metadata?.bundledDocumentKey === document.key &&
+        metadata?.bundledDocumentVersion === document.version &&
+        embeddingsEqual(existingEmbedding, embedding));
+}
+async function listFragmentIdsForDocument(runtime, documentId) {
+    const fragmentIds = [];
+    let offset = 0;
+    while (true) {
+        const batch = await runtime.getMemories({
+            tableName: DOCUMENT_FRAGMENTS_TABLE,
+            roomId: runtime.agentId,
+            limit: DOCUMENT_BATCH_SIZE,
+            start: offset,
+        });
+        if (batch.length === 0)
+            break;
+        for (const memory of batch) {
+            const metadata = memory.metadata;
+            if (typeof memory.id === "string" &&
+                metadata?.documentId === documentId) {
+                fragmentIds.push(memory.id);
+            }
+        }
+        if (batch.length < DOCUMENT_BATCH_SIZE)
+            break;
+        offset += DOCUMENT_BATCH_SIZE;
+    }
+    return fragmentIds;
+}
+async function seedBundledDocument(runtime, document) {
+    const documentId = getDocumentId(runtime.agentId, document.key);
+    const existingDocument = await runtime.getMemoryById(documentId);
+    const documentTimestamp = extractTimestamp(existingDocument);
+    const documentCreatedAt = typeof existingDocument?.createdAt === "number"
+        ? existingDocument.createdAt
+        : Date.now();
+    const documentMemory = {
+        id: documentId,
+        agentId: runtime.agentId,
+        roomId: runtime.agentId,
+        worldId: runtime.agentId,
+        entityId: runtime.agentId,
+        content: { text: document.text },
+        metadata: buildDocumentMetadata(document, documentId, runtime.agentId, documentTimestamp),
+        createdAt: documentCreatedAt,
+    };
+    let changed = false;
+    if (!documentMatchesDefinition(existingDocument, document, documentId)) {
+        if (existingDocument) {
+            await runtime.updateMemory(documentMemory);
+        }
+        else {
+            await runtime.createMemory(documentMemory, DOCUMENTS_TABLE);
+        }
+        changed = true;
+    }
+    const staleFragmentIds = new Set(await listFragmentIdsForDocument(runtime, documentId));
+    for (const [index, fragment] of document.fragments.entries()) {
+        const fragmentId = getFragmentId(runtime.agentId, document.key, index);
+        const existingFragment = await runtime.getMemoryById(fragmentId);
+        const normalizedEmbedding = normalizeProvidedEmbedding(runtime, document, index, fragment.embedding);
+        const existingEmbedding = existingFragment?.content.text === fragment.text &&
+            Array.isArray(existingFragment.embedding) &&
+            existingFragment.embedding.length > 0
+            ? [...existingFragment.embedding]
+            : undefined;
+        const fragmentEmbedding = normalizedEmbedding ?? existingEmbedding;
+        const fragmentTimestamp = extractTimestamp(existingFragment);
+        const fragmentCreatedAt = typeof existingFragment?.createdAt === "number"
+            ? existingFragment.createdAt
+            : Date.now();
+        const fragmentMemory = {
+            id: fragmentId,
+            agentId: runtime.agentId,
+            roomId: runtime.agentId,
+            worldId: runtime.agentId,
+            entityId: runtime.agentId,
+            content: { text: fragment.text },
+            metadata: buildFragmentMetadata(document, documentId, runtime.agentId, index, runtime.agentId, fragmentTimestamp),
+            ...(fragmentEmbedding ? { embedding: fragmentEmbedding } : {}),
+            createdAt: fragmentCreatedAt,
+        };
+        if (!fragmentEmbedding) {
+            await runtime.addEmbeddingToMemory(fragmentMemory);
+        }
+        if (!fragmentMatchesDefinition(existingFragment, document, documentId, index, fragment.text, fragmentMemory.embedding)) {
+            if (existingFragment) {
+                await runtime.updateMemory(fragmentMemory);
+            }
+            else {
+                await runtime.createMemory(fragmentMemory, DOCUMENT_FRAGMENTS_TABLE);
+            }
+            changed = true;
+        }
+        staleFragmentIds.delete(fragmentId);
+    }
+    for (const fragmentId of staleFragmentIds) {
+        await runtime.deleteMemory(fragmentId);
+        changed = true;
+    }
+    if (changed) {
+        logger.info(`[eliza] Seeded bundled document "${document.filename}" (${document.fragments.length} fragment${document.fragments.length === 1 ? "" : "s"}).`);
+    }
+}
+export async function seedBundledDocuments(runtime, documents = DEFAULT_DOCUMENTS) {
+    for (const document of documents) {
+        await seedBundledDocument(runtime, document);
+    }
+}

package/packages/agent/src/runtime/eliza-plugin.d.ts

@@ -3,7 +3,7 @@
  * lifecycle actions (restart).
  *
  * Compaction is handled by core auto-compaction in the recent-messages provider.
- * Memory search/get actions are superseded by plugin-scratchpad.
+ * Memory search/get actions are superseded by the todos plugin.
  */
 import type { Plugin } from "@elizaos/core";
 export type ElizaPluginConfig = {

package/packages/agent/src/runtime/eliza-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eliza-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/eliza-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAEV,MAAM,EAIP,MAAM,eAAe,CAAC;AA6BvB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAoGpE"}
+{"version":3,"file":"eliza-plugin.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/eliza-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAiB,MAAM,EAAgB,MAAM,eAAe,CAAC;AA6CzE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAmBF,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAmJpE"}

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

@@ -3,24 +3,52 @@
  * lifecycle actions (restart).
  *
  * Compaction is handled by core auto-compaction in the recent-messages provider.
- * Memory search/get actions are superseded by plugin-scratchpad.
+ * Memory search/get actions are superseded by the todos plugin.
  */
-import { AgentEventService } from "@elizaos/core";
-import { emoteAction } from "../actions/emote";
-import { restartAction } from "../actions/restart";
-import { terminalAction } from "../actions/terminal";
-import { adminTrustProvider } from "../providers/admin-trust";
-import { createSessionKeyProvider } from "../providers/session-bridge";
-import { getSessionProviders, resolveDefaultSessionStorePath, } from "../providers/session-utils";
-import { createChannelProfileProvider } from "../providers/simple-mode";
-import { uiCatalogProvider } from "../providers/ui-catalog";
-import { DEFAULT_AGENT_WORKSPACE_DIR } from "../providers/workspace";
-import { createWorkspaceProvider } from "../providers/workspace-provider";
-import { createTriggerTaskAction } from "../triggers/action";
-import { registerTriggerTaskWorker } from "../triggers/runtime";
-import { loadCustomActions, setCustomActionsRuntime } from "./custom-actions";
+import { AgentEventService, promoteSubactionsToActions } from "@elizaos/core";
+import { contactAction } from "../actions/contact.js";
+import { databaseAction } from "../actions/database.js";
+import { logsAction } from "../actions/logs.js";
+import { memoryAction } from "../actions/memories.js";
+import { pageActionGroupActions } from "../actions/page-action-groups.js";
+import { pluginAction } from "../actions/plugin.js";
+import { runtimeAction } from "../actions/runtime.js";
+import { settingsAction } from "../actions/settings-actions.js";
+import { addRegisteredSkillSlug, clearRegisteredSkillSlugs, } from "../actions/skill-command.js";
+import { terminalAction } from "../actions/terminal.js";
+import { triggerAction } from "../actions/trigger.js";
+import { adminPanelProvider } from "../providers/admin-panel.js";
+import { adminTrustProvider } from "../providers/admin-trust.js";
+import { automationTerminalBridgeProvider } from "../providers/automation-terminal-bridge.js";
+import { escalationTriggerProvider } from "../providers/escalation-trigger.js";
+import { pageScopedContextProvider } from "../providers/page-scoped-context.js";
+import { pendingPermissionsProvider } from "../providers/pending-permissions-provider.js";
+import { recentConversationsProvider } from "../providers/recent-conversations.js";
+import { relevantConversationsProvider } from "../providers/relevant-conversations.js";
+import { roleBackfillProvider } from "../providers/role-backfill.js";
+import { rolodexProvider } from "../providers/rolodex.js";
+import { createSessionKeyProvider } from "../providers/session-bridge.js";
+import { getSessionProviders, resolveDefaultSessionStorePath, } from "../providers/session-utils.js";
+import { createChannelProfileProvider } from "../providers/simple-mode.js";
+import { createDynamicSkillProvider } from "../providers/skill-provider.js";
+import { createOngoingTasksProvider } from "../providers/tasks.js";
+import { uiCatalogProvider } from "../providers/ui-catalog.js";
+import { createUserNameProvider } from "../providers/user-name.js";
+import { createWorkspaceProvider } from "../providers/workspace-provider.js";
+import { ElizaCharacterPersistenceService } from "../services/character-persistence.js";
+import { AgentMediaGenerationService } from "../services/media-generation.js";
+import { PermissionRegistry } from "../services/permissions-registry.js";
+import { resolveDefaultAgentWorkspaceDir } from "../shared/workspace-resolution.js";
+import { registerTriggerTaskWorker } from "../triggers/runtime.js";
+import { setCustomActionsRuntime } from "./custom-actions.js";
+function isAgentSkillsService(value) {
+    return (Boolean(value) &&
+        typeof value === "object" &&
+        typeof value.getLoadedSkills ===
+            "function");
+}
 export function createElizaPlugin(config) {
-    const workspaceDir = config?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+    const workspaceDir = config?.workspaceDir ?? resolveDefaultAgentWorkspaceDir();
     const agentId = config?.agentId ?? "main";
     const sessionStorePath = config?.sessionStorePath ?? resolveDefaultSessionStorePath(agentId);
     const baseProviders = [
@@ -30,75 +58,122 @@ export function createElizaPlugin(config) {
             maxCharsPerFile: config?.initMaxChars,
         }),
         adminTrustProvider,
+        adminPanelProvider,
         createSessionKeyProvider({ defaultAgentId: agentId }),
         ...getSessionProviders({ storePath: sessionStorePath }),
+        createDynamicSkillProvider(),
+        pendingPermissionsProvider,
+        createUserNameProvider(),
+        createOngoingTasksProvider(),
     ];
-    // Emote IDs are now declared as an enum on the PLAY_EMOTE action parameter,
-    // so they appear in the `# Available Actions` section automatically via
-    // core's formatActions. No separate provider injection needed.
-    //
-    // Backwards-compat: character.settings.DISABLE_EMOTES still works — when set,
-    // the PLAY_EMOTE action is excluded at init time so it never appears in the
-    // prompt. Previously this was checked per-request in the emote provider.
-    // Custom actions provider — tells the LLM about available custom actions.
-    const customActionsProvider = {
-        name: "customActions",
-        description: "User-defined custom actions",
-        async get() {
-            const customActions = loadCustomActions();
-            if (customActions.length === 0) {
-                // Don't waste tokens telling the LLM there are no custom actions.
-                return { text: "" };
-            }
-            const lines = customActions.map((a) => {
-                const params = a.parameters
-                    ?.map((p) => `${p.name}${p.required ? " (required)" : ""}`)
-                    .join(", ") || "none";
-                return `- **${a.name}**: ${a.description} [params: ${params}]`;
-            });
-            return {
-                text: [
-                    "## Custom Actions",
-                    "",
-                    "The following custom actions are available:",
-                    ...lines,
-                ].join("\n"),
-            };
-        },
-    };
+    // PLAY_EMOTE lives in @elizaos/app-companion (emote catalog + action).
     const plugin = {
         name: "eliza",
         description: "Eliza workspace context, session keys, and lifecycle actions",
-        services: [AgentEventService],
+        services: [
+            AgentEventService,
+            ElizaCharacterPersistenceService,
+            AgentMediaGenerationService,
+            PermissionRegistry,
+        ],
         init: async (_pluginConfig, runtime) => {
             registerTriggerTaskWorker(runtime);
             setCustomActionsRuntime(runtime);
-            // Honour DISABLE_EMOTES: remove PLAY_EMOTE so it never appears in prompts.
-            if (runtime.character?.settings?.DISABLE_EMOTES) {
-                const idx = plugin.actions?.findIndex((a) => a.name === "PLAY_EMOTE");
-                if (idx != null && idx >= 0) {
-                    plugin.actions?.splice(idx, 1);
+            // Proactive agent (activity-profile) is now initialized by @elizaos/app-lifeops plugin init.
+            // ── Auto-register skills as slash commands ───────────────────────
+            // Runs after plugin-agent-skills init so getLoadedSkills() is populated.
+            // Uses a deferred check because skill loading is async and may complete
+            // after this init() returns.
+            const registerSkillsAsCommands = () => {
+                try {
+                    const skillsService = runtime.getService("AGENT_SKILLS_SERVICE");
+                    if (!isAgentSkillsService(skillsService))
+                        return false;
+                    const skills = skillsService.getLoadedSkills();
+                    if (skills.length === 0)
+                        return false;
+                    // Dynamically import plugin-commands registry (may not be loaded)
+                    let registerCommand;
+                    let initForRuntime;
+                    try {
+                        const cmds = require("@elizaos/plugin-commands");
+                        registerCommand = cmds.registerCommand;
+                        initForRuntime = cmds.initForRuntime;
+                    }
+                    catch {
+                        return false; // plugin-commands not available
+                    }
+                    // Ensure the command store is scoped to this runtime
+                    initForRuntime(runtime.agentId);
+                    clearRegisteredSkillSlugs();
+                    let registered = 0;
+                    for (const skill of skills) {
+                        const slug = skill.slug.toLowerCase();
+                        try {
+                            registerCommand({
+                                key: `skill-${slug}`,
+                                description: skill.description.substring(0, 80),
+                                textAliases: [`/${slug}`],
+                                scope: "both",
+                                category: "skills",
+                                acceptsArgs: true,
+                                args: [
+                                    {
+                                        name: "input",
+                                        description: "Task or question for this skill",
+                                        captureRemaining: true,
+                                    },
+                                ],
+                            });
+                            addRegisteredSkillSlug(slug);
+                            registered++;
+                        }
+                        catch {
+                            // Command may already be registered (e.g. /stop conflicts)
+                        }
+                    }
+                    if (registered > 0) {
+                        const { logger } = require("@elizaos/core");
+                        logger.info(`[eliza] Registered ${registered} skills as slash commands`);
+                    }
+                    return true;
                 }
+                catch {
+                    return false;
+                }
+            };
+            // Try immediately, then retry after a delay for async skill loading
+            if (!registerSkillsAsCommands()) {
+                setTimeout(registerSkillsAsCommands, 5000);
             }
         },
         providers: [
             ...baseProviders,
+            automationTerminalBridgeProvider,
+            pageScopedContextProvider,
+            recentConversationsProvider,
+            relevantConversationsProvider,
+            rolodexProvider,
             uiCatalogProvider,
-            // customActionsProvider,
+            roleBackfillProvider,
+            escalationTriggerProvider,
         ],
         actions: [
-            restartAction,
-            // sendMessageAction,
             terminalAction,
-            createTriggerTaskAction,
-            emoteAction,
-            // switchStreamSourceAction,
-            // goLiveAction,
-            // goOfflineAction,
-            // setStreamDestinationAction,
-            // speakOnStreamAction,
-            // manageOverlayWidgetAction,
-            // ...loadCustomActions(),
+            ...promoteSubactionsToActions(triggerAction),
+            ...pageActionGroupActions,
+            ...promoteSubactionsToActions(contactAction),
+            settingsAction,
+            ...promoteSubactionsToActions(pluginAction),
+            // Observability / introspection actions
+            ...promoteSubactionsToActions(logsAction),
+            ...promoteSubactionsToActions(runtimeAction),
+            ...promoteSubactionsToActions(databaseAction),
+            ...promoteSubactionsToActions(memoryAction),
+            // SCHEDULE_FOLLOW_UP is now the `followup` op on contactAction.
+            // ARCHIVE_CODING_TASK / REOPEN_CODING_TASK live as ops on the TASKS
+            // parent in @elizaos/plugin-agent-orchestrator (also surfaced via the
+            // CODE umbrella).
         ],
     };
     return plugin;