@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/runtime/plugin-role-gating.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Legacy provider role gating.
+ *
+ * Action access is declared on each action's `roleGate` and enforced by core
+ * execution paths. This module only keeps provider redaction for legacy
+ * providers that do not yet run through the context catalog.
+ *
+ * @module plugin-role-gating
+ */
+import type { Plugin } from "@elizaos/core";
+type RoleGate = "user" | "admin" | "owner";
+declare const ROLE_GATED_PLUGINS: Readonly<Record<string, RoleGate>>;
+declare const ACTION_ROLE_OVERRIDES: Readonly<Record<string, RoleGate>>;
+declare const PROVIDER_ROLE_OVERRIDES: Readonly<Record<string, RoleGate>>;
+/**
+ * Apply role gating to all registered plugins. Call after runtime.initialize().
+ *
+ * Providers in PROVIDER_ROLE_OVERRIDES get gated. Actions are intentionally
+ * not wrapped here; use action.roleGate.
+ */
+export declare function applyPluginRoleGating(plugins: Plugin[]): void;
+/** Exported for testing. */
+export { ACTION_ROLE_OVERRIDES, PROVIDER_ROLE_OVERRIDES, ROLE_GATED_PLUGINS };
+//# sourceMappingURL=plugin-role-gating.d.ts.map

package/dist/packages/agent/src/runtime/plugin-role-gating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-role-gating.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/plugin-role-gating.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAGV,MAAM,EAIP,MAAM,eAAe,CAAC;AAGvB,KAAK,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAE3C,QAAA,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAM,CAAC;AAElE,QAAA,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAM,CAAC;AAOrE,QAAA,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CA0C/D,CAAC;AAoDF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAoB7D;AAED,4BAA4B;AAC5B,OAAO,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/packages/agent/src/runtime/plugin-role-gating.js

@@ -0,0 +1,106 @@
+import { logger } from "@elizaos/core";
+const ROLE_GATED_PLUGINS = {};
+const ACTION_ROLE_OVERRIDES = {};
+// ---------------------------------------------------------------------------
+// Provider-level gating — providers that expose sensitive context.
+// Keys are exact provider `name` strings.
+// ---------------------------------------------------------------------------
+const PROVIDER_ROLE_OVERRIDES = {
+    // Shell
+    shellHistoryProvider: "admin",
+    terminalUsage: "admin",
+    // Orchestrator
+    ACTIVE_WORKSPACE_CONTEXT: "admin",
+    CODING_AGENT_EXAMPLES: "admin",
+    // Secrets
+    SECRETS_STATUS: "admin",
+    SECRETS_INFO: "admin",
+    MISSING_SECRETS: "admin",
+    // Cron
+    cronContext: "admin",
+    // Cloud
+    elizacloud_status: "admin",
+    elizacloud_credits: "admin",
+    elizacloud_health: "admin",
+    elizacloud_models: "admin",
+    // Todos
+    todos: "user",
+    // Browser / wallet operational state
+    app_browser_workspace: "owner",
+    computerState: "owner",
+    "get-balance": "owner",
+    "solana-wallet": "owner",
+    wallet: "owner",
+    walletBalance: "owner",
+    walletPortfolio: "owner",
+    tokenPrices: "owner",
+    chainInfo: "owner",
+    // Apps / plugins expose local installation/runtime state.
+    available_apps: "owner",
+    pluginConfigurationStatus: "owner",
+    pluginState: "owner",
+    registryPlugins: "owner",
+};
+// ---------------------------------------------------------------------------
+// Gating implementation
+// ---------------------------------------------------------------------------
+function roleCheckPasses(check, gate) {
+    switch (gate) {
+        case "owner":
+            return check.isOwner === true;
+        case "admin":
+            return check.isAdmin === true;
+        case "user":
+            // USER, ADMIN, and OWNER all pass the "user" gate.
+            // Only GUEST (rank 0) is blocked.
+            return check.role !== "GUEST" && check.role !== "NONE";
+        default:
+            return false;
+    }
+}
+/**
+ * Wrap a provider's get function so it returns empty content for callers
+ * below the gate. Providers don't block; they just withhold context.
+ */
+function gateProvider(provider, gate) {
+    if (provider.__roleGate === gate) {
+        return;
+    }
+    const originalGet = provider.get;
+    provider.get = async (runtime, message, state) => {
+        const { checkSenderRole } = await import("./roles.js");
+        const check = await checkSenderRole(runtime, message);
+        if (!check || !roleCheckPasses(check, gate)) {
+            return { text: "" };
+        }
+        return originalGet.call(provider, runtime, message, state);
+    };
+    provider.__roleGate = gate;
+}
+/**
+ * Apply role gating to all registered plugins. Call after runtime.initialize().
+ *
+ * Providers in PROVIDER_ROLE_OVERRIDES get gated. Actions are intentionally
+ * not wrapped here; use action.roleGate.
+ */
+export function applyPluginRoleGating(plugins) {
+    let totalProviders = 0;
+    for (const plugin of plugins) {
+        // Gate providers
+        if (plugin.providers?.length) {
+            for (const provider of plugin.providers) {
+                const providerName = provider.name ?? "";
+                const providerGate = PROVIDER_ROLE_OVERRIDES[providerName];
+                if (providerGate) {
+                    gateProvider(provider, providerGate);
+                    totalProviders++;
+                }
+            }
+        }
+    }
+    if (totalProviders > 0) {
+        logger.info(`[role-gating] Total: ${totalProviders} provider(s) gated`);
+    }
+}
+/** Exported for testing. */
+export { ACTION_ROLE_OVERRIDES, PROVIDER_ROLE_OVERRIDES, ROLE_GATED_PLUGINS };

package/dist/packages/agent/src/runtime/plugin-types.d.ts

@@ -0,0 +1,64 @@
+import { type Plugin } from "@elizaos/core";
+import type { PluginInstallRecord } from "../config/types.eliza.ts";
+/** A successfully resolved plugin ready for AgentRuntime registration. */
+export interface ResolvedPlugin {
+    /** npm package name (e.g. "@elizaos/plugin-anthropic"). */
+    name: string;
+    /** The Plugin instance extracted from the module. */
+    plugin: Plugin;
+}
+/** Shape we expect from a dynamically-imported plugin package. */
+export interface PluginModuleShape {
+    default?: Plugin;
+    plugin?: Plugin;
+    [key: string]: unknown;
+}
+/**
+ * Static plugin registry.
+ *
+ * Populated by eliza.ts at module-load time with all statically-imported
+ * plugin modules. Defined here (as a mutable record) so that
+ * plugin-resolver.ts can read it without importing eliza.ts, breaking the
+ * circular dependency.
+ */
+export declare const STATIC_ELIZA_PLUGINS: Record<string, unknown>;
+/** Subdirectory under the Eliza state dir for drop-in custom plugins. */
+export declare const CUSTOM_PLUGINS_DIRNAME = "plugins/custom";
+/** Subdirectory under the Eliza state dir for ejected plugins. */
+export declare const EJECTED_PLUGINS_DIRNAME = "plugins/ejected";
+export declare function findRuntimePluginExport(mod: PluginModuleShape): Plugin | null;
+/**
+ * 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 declare function scanDropInPlugins(dir: string): Promise<Record<string, PluginInstallRecord>>;
+/**
+ * Merge drop-in plugins into the load set. Filters out denied, core-colliding,
+ * and already-installed names. Mutates `pluginsToLoad` and `installRecords`.
+ */
+export declare function mergeDropInPlugins(params: {
+    dropInRecords: Record<string, PluginInstallRecord>;
+    installRecords: Record<string, PluginInstallRecord>;
+    corePluginNames: ReadonlySet<string>;
+    denyList: ReadonlySet<string>;
+    pluginsToLoad: Set<string>;
+}): {
+    accepted: string[];
+    skipped: string[];
+};
+export declare function resolveElizaPluginImportSpecifier(pluginName: string, runtimeModuleUrl?: string): string;
+export declare function findPluginBrowserStagehandDir(startDir: string): string | null;
+/**
+ * `@elizaos/plugin-browser` expects `dist/server/` with the stagehand binary
+ * tree inside the npm package, but the published tarball does not ship it.
+ * When missing, symlink to a repo checkout at `plugins/plugin-browser/stagehand-server`
+ * (discovered via {@link findPluginBrowserStagehandDir}) so the plugin's
+ * process-manager can spawn the server.
+ *
+ * **Why:** Without the symlink, browser automation fails at runtime even when
+ * the user built stagehand locally -- the plugin only looks under its package root.
+ *
+ * @returns `true` when `dist/server` already resolves or symlink succeeded.
+ */
+export declare function ensureBrowserServerLink(): boolean;
+//# sourceMappingURL=plugin-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-types.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/plugin-types.ts"],"names":[],"mappings":"AAeA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAIpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAMpE,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAMD;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,CAAC;AAEhE,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,kEAAkE;AAClE,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AA6BzD,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CAsB7E;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CA2C9C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACnD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACpD,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC9B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC5B,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAyB5C;AAED,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,gBAAgB,SAAkB,GACjC,MAAM,CAaR;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB7E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CAyEjD"}

package/dist/packages/agent/src/runtime/plugin-types.js

@@ -0,0 +1,306 @@
+import { existsSync, symlinkSync } from "node:fs";
+import fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { logger } from "@elizaos/core";
+import { formatError } from "@elizaos/shared";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * Static plugin registry.
+ *
+ * Populated by eliza.ts at module-load time with all statically-imported
+ * plugin modules. Defined here (as a mutable record) so that
+ * plugin-resolver.ts can read it without importing eliza.ts, breaking the
+ * circular dependency.
+ */
+export const STATIC_ELIZA_PLUGINS = {};
+/** 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";
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+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");
+}
+// ---------------------------------------------------------------------------
+// Utility functions
+// ---------------------------------------------------------------------------
+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. 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;
+    }
+    return null;
+}
+/**
+ * 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 };
+}
+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 findPluginBrowserStagehandDir(startDir) {
+    let dir = path.resolve(startDir);
+    for (let depth = 0; depth < 14; depth++) {
+        const candidate = path.join(dir, "plugins", "plugin-browser", "stagehand-server");
+        const distIndex = path.join(candidate, "dist", "index.js");
+        const srcEntry = path.join(candidate, "src", "index.ts");
+        if (existsSync(distIndex) || existsSync(srcEntry)) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * `@elizaos/plugin-browser` expects `dist/server/` with the stagehand binary
+ * tree inside the npm package, but the published tarball does not ship it.
+ * When missing, symlink to a repo checkout at `plugins/plugin-browser/stagehand-server`
+ * (discovered via {@link findPluginBrowserStagehandDir}) so the plugin's
+ * process-manager can spawn the server.
+ *
+ * **Why:** Without the symlink, browser automation fails at runtime even when
+ * the user built stagehand locally -- the plugin only looks under its package root.
+ *
+ * @returns `true` when `dist/server` already resolves or symlink succeeded.
+ */
+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;
+        const thisDir = path.dirname(fileURLToPath(import.meta.url));
+        const stagehandDir = findPluginBrowserStagehandDir(thisDir);
+        if (!stagehandDir) {
+            logger.debug("[eliza] plugin-browser: no stagehand-server under plugins/plugin-browser — " +
+                "run node scripts/link-browser-server.mjs or add the plugin checkout");
+            return false;
+        }
+        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("bun install --ignore-scripts", {
+                        cwd: stagehandDir,
+                        stdio: "ignore",
+                        timeout: 60_000,
+                    });
+                }
+                // Prefer local tsc binary, fall back to bunx
+                const localTsc = path.join(stagehandDir, "node_modules", ".bin", "tsc");
+                const tscCmd = existsSync(localTsc) ? localTsc : "bunx 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.debug("[eliza] plugin-browser: stagehand-server present but dist/index.js missing — build it");
+            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;
+    }
+}
+/** @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())
+        return false;
+    // Keep the plugin listed as installed but force node_modules resolution.
+    record.installPath = "";
+    record.source = "npm";
+    return true;
+}
+/** Read package.json exports/main to find the importable entry file. */
+/** @internal Exported for testing. */
+export async function resolvePackageEntry(pkgRoot, exportSubpath = ".") {
+    const fallback = path.join(pkgRoot, "dist", "index");
+    const subpath = exportSubpath.replace(/^\.\//, "");
+    const fallbackCandidates = [
+        ...(exportSubpath === "."
+            ? [
+                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"),
+            ]
+            : [
+                path.join(pkgRoot, "dist", subpath),
+                path.join(pkgRoot, "dist", `${subpath}.js`),
+                path.join(pkgRoot, "dist", `${subpath}.mjs`),
+                path.join(pkgRoot, subpath),
+                path.join(pkgRoot, `${subpath}.mjs`),
+                path.join(pkgRoot, `${subpath}.js`),
+                path.join(pkgRoot, `${subpath}.ts`),
+                path.join(pkgRoot, "src", subpath),
+                path.join(pkgRoot, "src", `${subpath}.js`),
+                path.join(pkgRoot, "src", `${subpath}.mjs`),
+                path.join(pkgRoot, "src", `${subpath}.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[exportSubpath] !== undefined) {
+            const entry = pkg.exports[exportSubpath];
+            const resolved = typeof entry === "string" ? entry : entry.import || entry.default;
+            if (typeof resolved === "string") {
+                return chooseExisting(path.resolve(pkgRoot, resolved), ...fallbackCandidates);
+            }
+        }
+        if (exportSubpath === "." && typeof pkg.exports === "string") {
+            return chooseExisting(path.resolve(pkgRoot, pkg.exports), ...fallbackCandidates);
+        }
+        if (exportSubpath === "." && pkg.main) {
+            return chooseExisting(path.resolve(pkgRoot, pkg.main), ...fallbackCandidates);
+        }
+        return chooseExisting(...fallbackCandidates);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return chooseExisting(...fallbackCandidates);
+        }
+        throw err;
+    }
+}

package/dist/packages/agent/src/runtime/prompt-compaction.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Intent detection and context-aware action compaction.
+ *
+ * Extracted from prompt-optimization.ts to keep files under ~500 LOC.
+ * These helpers detect user intent from prompt content and strip
+ * irrelevant action params to reduce context window usage.
+ */
+export declare function compactInitialCodeMarker(prompt: string): string;
+export declare function compactRegistryCatalog(prompt: string): string;
+export declare function compactCodingActionExamples(prompt: string): string;
+export declare function compactUiCatalog(prompt: string): string;
+export declare function compactLoadedPluginLists(prompt: string): string;
+export declare function compactEmoteCatalog(prompt: string): string;
+export declare function compactWorkspaceContextForNonCoding(prompt: string): string;
+export declare function compactUiComponentCatalog(prompt: string): string;
+export declare function compactInstalledSkills(prompt: string): string;
+/** Actions that are always included at full detail. */
+export declare const UNIVERSAL_ACTIONS: Set<string>;
+/**
+ * Map intent categories → action names that get full params when detected.
+ *
+ * Names must match registered Action.name strings. Verified live (2026-05-08):
+ *   TASKS         — plugins/plugin-agent-orchestrator/src/actions/tasks.ts:2029
+ *                   (polymorphic action that subsumes the old START_CODING_TASK
+ *                   / CREATE_TASK / SPAWN_AGENT / CREATE_WORKSPACE /
+ *                   SUBMIT_WORKSPACE / LIST_AGENTS / SEND_TO_AGENT /
+ *                   STOP_AGENT / MANAGE_ISSUES sub-ops)
+ *   RUNTIME       — packages/agent/src/actions/runtime.ts:405 (op:"restart"
+ *                   replaces the old RESTART_AGENT)
+ *   SHELL         — packages/agent/src/actions/terminal.ts:261
+ *   PLAY_EMOTE    — plugins/app-companion/src/actions/emote.ts:22
+ *
+ * GitHub issue ops live under GITHUB_ISSUE in plugin-github but that plugin
+ * isn't loaded by default — kept out of the map to avoid validator noise; it
+ * still gets surfaced when present because action listing is dynamic.
+ */
+export declare const INTENT_ACTION_MAP: Record<string, Set<string>>;
+export declare function hasIntent(prompt: string, keywords: RegExp): boolean;
+/**
+ * Validate INTENT_ACTION_MAP against the runtime's registered actions.
+ * Logs warnings for any mapped action names that don't exist in the runtime.
+ * Call once at startup after plugins are loaded.
+ */
+export declare function validateIntentActionMap(registeredActions: string[], logger?: {
+    warn: (msg: string) => void;
+}): void;
+/**
+ * Detect which intent categories are present in the prompt.
+ * Returns array of category names (e.g. ["coding", "terminal"]).
+ * Multiple categories can match simultaneously.
+ */
+export declare function detectIntentCategories(prompt: string): string[];
+/**
+ * Build the set of action names that should get full param detail.
+ * Universal actions are always included. Intent-matched actions are
+ * added based on detected categories. Everything else gets stub-only.
+ */
+export declare function buildFullParamActionSet(intentCategories: string[]): Set<string>;
+/**
+ * Strip internal thoughts, action lists, and entity UUIDs from conversation
+ * history when no coding/swarm intent is detected. For general chat, the
+ * agent's previous reasoning and action selections are noise — only the
+ * actual messages matter. Coding tasks keep the full context so the swarm
+ * coordinator can see its previous reasoning chain.
+ *
+ * Targets lines like:
+ *   (Eliza's internal thought: User wants me to spawn...)
+ *   (Eliza's actions: REPLY, START_CODING_TASK)
+ *   12:53 (17 minutes ago) [b850bc30-45f8-0041-a00a-83df46d8555d]
+ *                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ UUID
+ */
+export declare function compactConversationHistory(prompt: string): string;
+/**
+ * Strip the task-agent examples provider section when no task/coding intent
+ * is detected. These examples teach the LLM how to use START_CODING_TASK /
+ * SPAWN_AGENT / FINALIZE_WORKSPACE and related aliases, which are unnecessary
+ * for general chat, emote, or plugin-config messages.
+ */
+export declare function compactCodingExamplesForIntent(prompt: string): string;
+/**
+ * Context-aware action formatting. Replaces the available-actions block in
+ * the prompt with a version where only intent-relevant actions keep full
+ * parameter detail — the rest are stubs with just name + description.
+ *
+ * Supports the legacy line-oriented prompt encoding emitted by older actions providers:
+ *   actions[N]:
+ *   - ACTION: description
+ *     aliases[..]: ...
+ *     tags[..]: ...
+ *     params[..]: ...
+ *     example: ...
+ *
+ * If no intents are detected (general chat), only universal actions
+ * (REPLY, NONE, IGNORE) keep full params — all others are stubbed.
+ */
+export declare function compactActionsForIntent(prompt: string): string;
+export declare function compactModelPrompt(prompt: string): string;
+//# sourceMappingURL=prompt-compaction.d.ts.map

package/dist/packages/agent/src/runtime/prompt-compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-compaction.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/prompt-compaction.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAKD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM7D;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMlE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKvD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAY/D;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK1D;AAED,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK1E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAM7D;AA0BD,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,aAAuC,CAAC;AAEtE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAOzD,CAAC;AAEF,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAsBnE;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GACvC,IAAI,CAWN;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,MAAM,EAAE,GACzB,GAAG,CAAC,MAAM,CAAC,CAcb;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA6BjE;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAYrE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAoB9D;AAyFD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA0BzD"}