openbot 0.3.6 → 0.4.0

package/dist/plugins/storage-tools/index.js

@@ -32,7 +32,7 @@ const storageToolDefinitions = {
             state: z
                 .record(z.string(), z.unknown())
                 .optional()
-                .describe('JSON state object for the channel. Use for structured data like `todos` or metadata.'),
+                .describe('JSON state object for the channel. Use for structured metadata.'),
             spec: z
                 .string()
                 .optional()
@@ -46,7 +46,7 @@ const storageToolDefinitions = {
         inputSchema: z.object({
             state: z
                 .record(z.string(), z.unknown())
-                .describe('JSON state object for the thread. Use for structured data like `todos` or progress.'),
+                .describe('JSON state object for the thread. Use for structured progress or metadata.'),
         }),
     },
     create_variable: {

package/dist/plugins/thread-namer/index.js

@@ -0,0 +1,72 @@
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { THREAD_NAMER_AGENT_ID } from '../../app/agent-ids.js';
+import { loadConfig } from '../../app/config.js';
+const DEFAULT_MODEL = 'openai/gpt-4o-mini';
+const TITLE_SYSTEM_PROMPT = 'Generate a concise thread title from the user message. Reply with the title only: no quotes, no punctuation at the end, max 8 words.';
+function resolveModel(modelString) {
+    const [provider, ...rest] = modelString.split('/');
+    const modelId = rest.join('/');
+    if (!modelId) {
+        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
+    }
+    switch (provider) {
+        case 'openai':
+            return openai(modelId);
+        case 'anthropic':
+            return anthropic(modelId);
+        default:
+            throw new Error(`Unsupported AI provider: "${provider}"`);
+    }
+}
+/**
+ * `thread-namer` — internal agent plugin that generates short thread titles via LLM.
+ */
+export const threadNamerPlugin = {
+    id: 'thread-namer',
+    name: 'Thread namer',
+    description: 'Generates concise thread titles from seed messages.',
+    configSchema: {
+        type: 'object',
+        properties: {
+            model: {
+                type: 'string',
+                description: 'Provider model string, e.g. openai/gpt-4o-mini',
+                default: DEFAULT_MODEL,
+            },
+        },
+    },
+    factory: ({ agentId, config }) => {
+        if (agentId !== THREAD_NAMER_AGENT_ID) {
+            return () => { };
+        }
+        const configuredModel = typeof config?.model === 'string' && config.model.trim()
+            ? config.model.trim()
+            : loadConfig().model?.trim() || DEFAULT_MODEL;
+        return (builder) => {
+            builder.on('thread:title:generate', async function* (event) {
+                const data = (event.data || {});
+                const seedMessage = typeof data.seedMessage === 'string' ? data.seedMessage.trim() : '';
+                if (!seedMessage) {
+                    yield {
+                        type: 'thread:title:generated',
+                        data: { title: 'New thread', channelId: data.channelId },
+                    };
+                    return;
+                }
+                const result = await generateText({
+                    model: resolveModel(configuredModel),
+                    system: TITLE_SYSTEM_PROMPT,
+                    prompt: seedMessage,
+                });
+                const title = result.text.replace(/\s+/g, ' ').trim() || 'New thread';
+                yield {
+                    type: 'thread:title:generated',
+                    data: { title, channelId: data.channelId },
+                };
+            });
+        };
+    },
+};
+export default threadNamerPlugin;

package/dist/plugins/thread-naming/generate-title.js

@@ -0,0 +1,44 @@
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+const THREAD_TITLE_MAX_LENGTH = 80;
+function resolveModel(modelString) {
+    const [provider, ...rest] = modelString.split('/');
+    const modelId = rest.join('/');
+    if (!modelId) {
+        throw new Error(`Invalid model string: "${modelString}". Expected "provider/model-id".`);
+    }
+    switch (provider) {
+        case 'openai':
+            return openai(modelId);
+        case 'anthropic':
+            return anthropic(modelId);
+        default:
+            throw new Error(`Unsupported AI provider: "${provider}"`);
+    }
+}
+function normalizeTitle(raw) {
+    let title = raw
+        .replace(/^["'`]+|["'`]+$/g, '')
+        .replace(/[.!?]+$/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!title)
+        return '';
+    if (title.length > THREAD_TITLE_MAX_LENGTH) {
+        title = `${title.slice(0, THREAD_TITLE_MAX_LENGTH).trimEnd()}...`;
+    }
+    return title;
+}
+export async function generateThreadTitle(content, modelString) {
+    const normalized = content.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return undefined;
+    const result = await generateText({
+        model: resolveModel(modelString),
+        system: 'You name chat threads. Reply with ONLY a short title (3-6 words). No quotes, no trailing punctuation.',
+        prompt: normalized.slice(0, 500),
+        maxOutputTokens: 20,
+    });
+    return normalizeTitle(result.text) || undefined;
+}

package/dist/plugins/thread-naming/index.js

@@ -0,0 +1,103 @@
+import { ORCHESTRATOR_AGENT_ID } from '../../app/agent-ids.js';
+import { loadConfig } from '../../app/config.js';
+import { generateThreadTitle } from './generate-title.js';
+const namingInFlight = new Set();
+function resolveNamingModel(pluginConfig, agentPluginRefs) {
+    const fromPlugin = typeof pluginConfig.model === 'string' ? pluginConfig.model.trim() : '';
+    if (fromPlugin)
+        return fromPlugin;
+    const openbotRef = agentPluginRefs?.find((ref) => ref.id === 'openbot');
+    const fromOpenbot = typeof openbotRef?.config?.model === 'string' ? openbotRef.config.model.trim() : '';
+    if (fromOpenbot)
+        return fromOpenbot;
+    return loadConfig().model || 'openai/gpt-4o-mini';
+}
+async function maybeGenerateThreadName(args) {
+    const details = await args.storage.getThreadDetails({
+        channelId: args.channelId,
+        threadId: args.threadId,
+    });
+    const state = details.state || {};
+    if (state.nameStatus === 'llm' || state.nameStatus === 'manual')
+        return;
+    const title = await generateThreadTitle(args.content, args.model);
+    if (!title)
+        return;
+    await args.storage.patchThreadState({
+        channelId: args.channelId,
+        threadId: args.threadId,
+        state: { generatedName: title, nameStatus: 'llm' },
+    });
+    if (!args.emitEvent)
+        return;
+    await args.emitEvent({
+        type: 'client:ui:thread:updated',
+        data: {
+            channelId: args.channelId,
+            threadId: args.threadId,
+            name: title,
+        },
+        meta: {
+            agentId: ORCHESTRATOR_AGENT_ID,
+            channelId: args.channelId,
+            threadId: args.threadId,
+        },
+    });
+}
+/**
+ * `thread-naming` — generates short LLM titles for new threads on the system agent.
+ * Runs in the background on the first user message so the main turn is not blocked.
+ */
+export const threadNamingPlugin = {
+    id: 'thread-naming',
+    name: 'Thread naming',
+    description: 'Automatically generates short LLM titles for new conversation threads.',
+    configSchema: {
+        type: 'object',
+        properties: {
+            model: {
+                type: 'string',
+                description: 'Provider model string for title generation. Defaults to the openbot plugin model, then workspace config.',
+            },
+        },
+    },
+    factory: ({ agentId, agentDetails, config, storage, emitEvent }) => {
+        if (agentId !== ORCHESTRATOR_AGENT_ID) {
+            return () => { };
+        }
+        const model = resolveNamingModel(config, agentDetails.pluginRefs);
+        return (builder) => {
+            builder.on('agent:invoke', async function* (event, context) {
+                const invoke = event;
+                if (invoke.data?.role && invoke.data.role !== 'user')
+                    return;
+                const threadId = context.state.threadId;
+                const channelId = context.state.channelId;
+                if (!threadId || !channelId)
+                    return;
+                const content = typeof invoke.data?.content === 'string' ? invoke.data.content : '';
+                if (!content.trim())
+                    return;
+                const key = `${channelId}:${threadId}`;
+                if (namingInFlight.has(key))
+                    return;
+                namingInFlight.add(key);
+                void maybeGenerateThreadName({
+                    storage,
+                    channelId,
+                    threadId,
+                    content,
+                    model,
+                    emitEvent,
+                })
+                    .catch((error) => {
+                    console.warn('[thread-naming] Failed to generate thread name:', error);
+                })
+                    .finally(() => {
+                    namingInFlight.delete(key);
+                });
+            });
+        };
+    },
+};
+export default threadNamingPlugin;

package/dist/plugins/threads/index.js

@@ -0,0 +1,114 @@
+import { generateId } from 'melony';
+import { STATE_AGENT_ID, THREAD_NAMER_AGENT_ID } from '../../app/agent-ids.js';
+import { runAgent } from '../../harness/index.js';
+const THREAD_TITLE_MAX_LENGTH = 80;
+function buildFallbackTitle(seedMessage) {
+    const normalized = seedMessage.replace(/\s+/g, ' ').trim();
+    if (!normalized)
+        return 'New thread';
+    if (normalized.length <= THREAD_TITLE_MAX_LENGTH)
+        return normalized;
+    return `${normalized.slice(0, THREAD_TITLE_MAX_LENGTH).trimEnd()}...`;
+}
+async function requestTitleFromSystem(args) {
+    let title;
+    await runAgent({
+        runId: `tn_${generateId()}`,
+        agentId: THREAD_NAMER_AGENT_ID,
+        channelId: args.channelId,
+        threadId: args.threadId,
+        persistEvents: false,
+        event: {
+            type: 'thread:title:generate',
+            data: {
+                seedMessage: args.seedMessage,
+                channelId: args.channelId,
+            },
+        },
+        onEvent: async (chunk) => {
+            if (chunk.type === 'thread:title:generated') {
+                const generated = chunk.data.title;
+                if (typeof generated === 'string' && generated.trim()) {
+                    title = generated.trim();
+                }
+            }
+        },
+    });
+    if (!title) {
+        throw new Error('Thread namer did not return a title');
+    }
+    return title;
+}
+/**
+ * `threads` — orchestrates explicit thread creation on the state agent.
+ */
+export const threadsPlugin = {
+    id: 'threads',
+    name: 'Threads',
+    description: 'Creates threads with LLM-generated titles and notifies clients.',
+    factory: ({ agentId, storage }) => {
+        if (agentId !== STATE_AGENT_ID) {
+            return () => { };
+        }
+        return (builder) => {
+            builder.on('thread:create', async function* (event, context) {
+                const data = (event.data || {});
+                const channelId = (data.channelId || context.state.channelId || '').trim();
+                const threadId = (data.threadId || '').trim();
+                if (!channelId || !threadId) {
+                    yield {
+                        type: 'thread:create:failed',
+                        data: {
+                            channelId,
+                            threadId,
+                            error: 'channelId and threadId are required',
+                        },
+                    };
+                    return;
+                }
+                const seedMessage = typeof data.seedMessage === 'string' ? data.seedMessage.trim() : '';
+                let title = threadId;
+                if (seedMessage) {
+                    try {
+                        title = await requestTitleFromSystem({ channelId, threadId, seedMessage });
+                    }
+                    catch (error) {
+                        console.warn('[threads] Title generation failed, using fallback', error);
+                        title = buildFallbackTitle(seedMessage);
+                    }
+                }
+                try {
+                    await storage.createThread({
+                        channelId,
+                        threadId,
+                        threadTitle: title,
+                        initialState: data.initialState,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (message.includes('already exists')) {
+                        const existing = await storage.getThreadDetails({ channelId, threadId });
+                        title = existing.name || title;
+                    }
+                    else {
+                        yield {
+                            type: 'thread:create:failed',
+                            data: { channelId, threadId, error: message },
+                        };
+                        return;
+                    }
+                }
+                yield {
+                    type: 'thread:created',
+                    data: { channelId, threadId, title },
+                };
+                yield {
+                    type: 'client:invalidate',
+                    data: { channelId, scopes: ['threads'], threadId },
+                };
+            });
+        };
+    },
+};
+export default threadsPlugin;

package/dist/plugins/todo/index.js

@@ -1,54 +1,53 @@
 import z from 'zod';
-/**
- * `todo` — shared, per-thread task list for autonomous multi-agent flows.
- *
- * Todos live in `threadDetails.state.todos` and are owned by the system
- * (handlers in `bus/services.ts`). Any agent in the thread can read the
- * list via context, and propose mutations through these tools. Each item
- * may carry an `assignee` agent id; combine with `handoff` to drive an
- * autonomous, multi-step plan across agents.
- *
- * Keep the surface minimal: two tools (replace-all, patch-one) cover plan
- * authoring, status transitions, and reassignment.
- */
 const todoStatus = z.enum(['pending', 'in_progress', 'done', 'cancelled']);
 const todoToolDefinitions = {
     todo_write: {
-        description: 'Author or rewrite the shared todo plan for the current thread. Pass the full ordered list — missing items are removed. Use at the start of multi-step work, or whenever the plan changes shape. For status flips, prefer `todo_update`.',
+        description: 'Manage the shared todo list (create, update, append, remove).',
         inputSchema: z.object({
             todos: z
                 .array(z.object({
                 id: z
                     .string()
                     .optional()
-                    .describe('Stable id. Reuse existing ids to preserve history; omit to create.'),
-                content: z.string().min(1).describe('What needs to be done. One concrete step.'),
+                    .describe('Stable id. Reuse existing ids to update; omit to create.'),
+                content: z.string().min(1).optional().describe('What needs to be done.'),
                 status: todoStatus.optional().describe('Defaults to `pending`.'),
                 assignee: z
                     .string()
                     .optional()
-                    .describe('Agent id responsible for this step. Pair with `handoff` to delegate.'),
+                    .describe('Suggested agent id for this step (plain id, no @ prefix).'),
+                deleted: z.boolean().optional().describe('If true, remove this item.'),
             }))
-                .describe('The complete, ordered plan.'),
+                .describe('List of todo items to write or patch.'),
+            merge: z
+                .boolean()
+                .optional()
+                .describe('If true (default), patches existing items by id and appends new ones. If false, replaces the entire list.'),
         }),
     },
-    todo_update: {
-        description: 'Patch a single todo by id. Use to mark progress (`in_progress`, `done`, `cancelled`), rephrase, or reassign without rewriting the whole list.',
+    delegate_to_agent: {
+        description: 'Run a worker agent on a self-contained task and return their output. ' +
+            'Call when a todo step should be executed by a participant; review the result and update todos before delegating again or replying to the user.',
         inputSchema: z.object({
-            id: z.string().describe('Todo id from `todo_write` or the rendered list.'),
-            status: todoStatus.optional(),
-            content: z.string().min(1).optional(),
-            assignee: z.string().optional().describe('Use empty string to clear.'),
+            agentId: z
+                .string()
+                .min(1)
+                .describe('Worker agent id from channel participants (plain id, no @ prefix).'),
+            task: z
+                .string()
+                .min(1)
+                .describe('Complete instruction for the worker — they do not see the full todo plan.'),
+            todoId: z.string().optional().describe('Optional todo id this step relates to.'),
         }),
     },
 };
 export const todoPlugin = {
     id: 'todo',
     name: 'Todo',
-    description: 'Shared per-thread task list for coordinating multi-step, multi-agent work.',
+    description: 'Shared todo list and worker delegation for multi-step orchestration.',
     toolDefinitions: todoToolDefinitions,
     factory: () => () => {
-        // Handlers live in bus/services.ts; this plugin only contributes tool definitions.
+        // Handlers live in bus/services.ts.
     },
 };
 export default todoPlugin;

package/dist/plugins/ui/index.js

@@ -61,7 +61,7 @@ const renderWidgetSchema = z.union([
         actions: z.array(actionSchema).optional(),
     }),
     z.object({
-        kind: z.enum(['approval', 'todo_list']).describe('Legacy preset. Prefer choice or list.'),
+        kind: z.literal('approval').describe('Legacy preset. Prefer choice or list.'),
         widgetId: z.string().optional(),
         title: z.string().optional(),
         props: z.record(z.string(), z.unknown()).optional(),
@@ -72,21 +72,6 @@ const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArr
 const readString = (value) => typeof value === 'string' && value.trim() ? value : undefined;
 const asFields = (value) => Array.isArray(value) ? value : undefined;
 const asListItems = (value) => Array.isArray(value) ? value : undefined;
-const todoToListItem = (todo, index) => {
-    if (!isRecord(todo)) {
-        return { id: `todo_${index + 1}`, label: String(todo) };
-    }
-    return {
-        id: readString(todo.id) || `todo_${index + 1}`,
-        label: readString(todo.label) ||
-            readString(todo.task) ||
-            readString(todo.title) ||
-            `Todo ${index + 1}`,
-        description: readString(todo.description),
-        status: readString(todo.status),
-        metadata: todo,
-    };
-};
 const createWidgetId = (data, toolCallId) => {
     if ('widgetId' in data && data.widgetId)
         return data.widgetId;
@@ -116,21 +101,6 @@ const normalizeWidget = (data, state, toolCallId) => {
             ],
         };
     }
-    if (data.kind === 'todo_list') {
-        const props = data.props || {};
-        const stateTodos = isRecord(state.threadDetails?.state)
-            ? state.threadDetails.state.todos
-            : undefined;
-        const todos = asListItems(props.todos) || asListItems(stateTodos) || [];
-        return {
-            widgetId,
-            kind: 'list',
-            title: data.title || readString(props.title) || 'Task List',
-            description: readString(props.description),
-            metadata: { ...(data.metadata || {}), legacyKind: 'todo_list' },
-            items: todos.map(todoToListItem),
-        };
-    }
     if (data.kind === 'form') {
         const propsSource = data.props;
         const props = isRecord(propsSource) ? propsSource : {};
@@ -160,7 +130,7 @@ const normalizeWidget = (data, state, toolCallId) => {
 };
 const uiToolDefinitions = {
     render_ui_widget: {
-        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy presets approval and todo_list are accepted.',
+        description: 'Render a small server-driven UI widget in the conversation. Prefer primitive kinds: message, choice, form, or list. Legacy preset approval is accepted.',
         inputSchema: renderWidgetSchema,
     },
 };

package/dist/registry/plugins.js

@@ -1,29 +1,23 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
+import { openbotPlugin } from '../plugins/openbot/index.js';
 import { shellPlugin } from '../plugins/shell/index.js';
-import { mcpPlugin } from '../plugins/mcp/index.js';
-import { delegationPlugin } from '../plugins/delegation/index.js';
 import { storageToolsPlugin } from '../plugins/storage-tools/index.js';
 import { uiPlugin } from '../plugins/ui/index.js';
 import { approvalPlugin } from '../plugins/approval/index.js';
 import { memoryPlugin } from '../plugins/memory/index.js';
-import { todoPlugin } from '../plugins/todo/index.js';
 import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
 let pluginsDir = null;
 const loadedPlugins = new Set();
 const cache = new Map();
 const BUILT_IN = {
-    [aiSdkPlugin.id]: aiSdkPlugin,
+    [openbotPlugin.id]: openbotPlugin,
     [shellPlugin.id]: shellPlugin,
-    [mcpPlugin.id]: mcpPlugin,
-    [delegationPlugin.id]: delegationPlugin,
     [storageToolsPlugin.id]: storageToolsPlugin,
     [uiPlugin.id]: uiPlugin,
     [approvalPlugin.id]: approvalPlugin,
     [memoryPlugin.id]: memoryPlugin,
-    [todoPlugin.id]: todoPlugin,
 };
 /** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
 export function parsePluginModule(module) {
@@ -61,7 +55,7 @@ export function initPlugins(dir) {
 }
 /**
  * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "ai-sdk", "shell"), or
+ *   - a built-in id (e.g. "openbot", "shell"), or
  *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
  *     in which case the folder layout is `plugins/<id>/dist/index.js`.
  */

package/dist/services/plugins/domain.js

@@ -0,0 +1 @@
+export {};

package/dist/services/plugins/plugin-cache.js

@@ -0,0 +1,9 @@
+/** Resolved plugins (built-in + community); shared with registry resolution. */
+export const resolvedPluginCache = new Map();
+/** Community plugin ids that have already been logged as loaded once. */
+export const loadedCommunityPlugins = new Set();
+/** Drop a single id from the in-memory resolver cache (e.g. after install/uninstall). */
+export function invalidatePlugin(id) {
+    resolvedPluginCache.delete(id);
+    loadedCommunityPlugins.delete(id);
+}

package/dist/services/plugins/registry.js

@@ -0,0 +1,110 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { openbotPlugin } from '../../plugins/openbot/index.js';
+import { shellPlugin } from '../../plugins/shell/index.js';
+import { storagePlugin } from '../../plugins/storage/index.js';
+import { approvalPlugin } from '../../plugins/approval/index.js';
+import { memoryPlugin } from '../../plugins/memory/index.js';
+import { delegationPlugin } from '../../plugins/delegation/index.js';
+import { pluginManagerPlugin } from '../../plugins/plugin-manager/index.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../../app/config.js';
+import { invalidatePlugin as clearResolvedPluginEntry, loadedCommunityPlugins, resolvedPluginCache, } from './plugin-cache.js';
+let pluginsDir = null;
+const BUILT_IN = {
+    [openbotPlugin.id]: openbotPlugin,
+    [shellPlugin.id]: shellPlugin,
+    [storagePlugin.id]: storagePlugin,
+    [approvalPlugin.id]: approvalPlugin,
+    [memoryPlugin.id]: memoryPlugin,
+    [delegationPlugin.id]: delegationPlugin,
+    [pluginManagerPlugin.id]: pluginManagerPlugin,
+};
+/** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
+export function parsePluginModule(module) {
+    const raw = module.plugin ??
+        module.default;
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const factory = raw.factory;
+    if (typeof factory !== 'function')
+        return null;
+    const name = typeof raw.name === 'string' ? raw.name : '';
+    const description = typeof raw.description === 'string' ? raw.description : '';
+    const image = typeof raw.image === 'string' ? raw.image : undefined;
+    const configSchema = raw.configSchema;
+    const toolDefinitions = raw.toolDefinitions;
+    return {
+        name,
+        description,
+        image,
+        configSchema,
+        toolDefinitions,
+        factory: factory,
+    };
+}
+/** Initialize the on-disk plugins directory (defaults to ~/.openbot/plugins). */
+export function initPlugins(dir) {
+    if (dir) {
+        pluginsDir = dir;
+    }
+    else {
+        const config = loadConfig();
+        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+        pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
+    }
+}
+/**
+ * Resolve a Plugin by id. The id is either:
+ *   - a built-in id (e.g. "openbot", "shell"), or
+ *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
+ *     in which case the folder layout is `plugins/<id>/dist/index.js`.
+ */
+export async function resolvePlugin(id) {
+    if (resolvedPluginCache.has(id))
+        return resolvedPluginCache.get(id);
+    if (BUILT_IN[id]) {
+        resolvedPluginCache.set(id, BUILT_IN[id]);
+        return BUILT_IN[id];
+    }
+    if (!pluginsDir) {
+        initPlugins();
+    }
+    if (!pluginsDir)
+        return null;
+    const distPath = path.join(pluginsDir, id, 'dist', 'index.js');
+    if (!fs.existsSync(distPath)) {
+        console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
+        return null;
+    }
+    try {
+        const module = await import(pathToFileURL(distPath).href);
+        const parsed = parsePluginModule(module);
+        if (!parsed) {
+            console.warn(`[plugins] Plugin "${id}" at ${distPath} has no recognizable export.`);
+            return null;
+        }
+        const plugin = { id, ...parsed, name: parsed.name || id };
+        resolvedPluginCache.set(id, plugin);
+        if (!loadedCommunityPlugins.has(id)) {
+            console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
+            loadedCommunityPlugins.add(id);
+        }
+        return plugin;
+    }
+    catch (e) {
+        console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
+        return null;
+    }
+}
+/** Drop a single id from the in-memory cache (e.g. after fresh install). */
+export function invalidatePlugin(id) {
+    clearResolvedPluginEntry(id);
+}
+/** List built-in plugins (for marketplace/registry views). */
+export function listBuiltInPlugins() {
+    return Object.values(BUILT_IN);
+}
+export function getPluginsDir() {
+    return pluginsDir;
+}