openbot 0.3.6 → 0.4.2

package/dist/services/plugins/service.js

@@ -0,0 +1,232 @@
+import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, DEFAULT_MARKETPLACE_REGISTRY_URL, loadConfig, resolvePath, } from '../../app/config.js';
+import { invalidatePlugin } from './plugin-cache.js';
+const execAsync = promisify(exec);
+const DEFAULT_MARKETPLACE_AGENTS = [];
+const DEFAULT_MARKETPLACE_CHANNELS = [];
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Parses JSON from a remote registry file. Supports either
+ * `{ "agents": [ ... ], "channels": [ ... ] }` or a top-level array (legacy agents-only).
+ */
+export function parseMarketplaceRegistryJson(data) {
+    const isLegacyArray = Array.isArray(data);
+    const rawAgents = isLegacyArray
+        ? data
+        : isRecord(data) && Array.isArray(data.agents)
+            ? data.agents
+            : [];
+    const rawChannels = !isLegacyArray && isRecord(data) && Array.isArray(data.channels)
+        ? data.channels
+        : isRecord(data) && Array.isArray(data.templates)
+            ? data.templates
+            : [];
+    const agents = (Array.isArray(rawAgents) ? rawAgents : []).map((item, i) => {
+        if (!isRecord(item)) {
+            throw new Error(`agents[${i}]: expected object`);
+        }
+        const id = item.id;
+        const name = item.name;
+        const description = item.description;
+        const instructions = item.instructions;
+        const pluginsRaw = item.plugins;
+        if (typeof id !== 'string' || !id)
+            throw new Error(`agents[${i}].id must be a non-empty string`);
+        if (typeof name !== 'string')
+            throw new Error(`agents[${i}].name must be a string`);
+        if (typeof description !== 'string')
+            throw new Error(`agents[${i}].description must be a string`);
+        if (typeof instructions !== 'string') {
+            throw new Error(`agents[${i}].instructions must be a string`);
+        }
+        if (!Array.isArray(pluginsRaw))
+            throw new Error(`agents[${i}].plugins must be an array`);
+        const plugins = pluginsRaw.map((p, j) => {
+            if (!isRecord(p) || typeof p.id !== 'string' || !p.id) {
+                throw new Error(`agents[${i}].plugins[${j}]: expected { "id": string, "config"?: object }`);
+            }
+            const ref = { id: p.id };
+            if (p.config !== undefined) {
+                if (!isRecord(p.config))
+                    throw new Error(`agents[${i}].plugins[${j}].config must be an object`);
+                ref.config = p.config;
+            }
+            return ref;
+        });
+        const listing = { id, name, description, instructions, plugins };
+        if (item.image !== undefined) {
+            if (typeof item.image !== 'string')
+                throw new Error(`agents[${i}].image must be a string`);
+            listing.image = item.image;
+        }
+        return listing;
+    });
+    const channels = (Array.isArray(rawChannels) ? rawChannels : []).map((item, i) => {
+        if (!isRecord(item)) {
+            throw new Error(`channels[${i}]: expected object`);
+        }
+        const id = item.id;
+        const name = item.name;
+        const description = item.description;
+        const participants = item.participants;
+        if (typeof id !== 'string' || !id)
+            throw new Error(`channels[${i}].id must be a non-empty string`);
+        if (typeof name !== 'string')
+            throw new Error(`channels[${i}].name must be a string`);
+        if (typeof description !== 'string')
+            throw new Error(`channels[${i}].description must be a string`);
+        if (!Array.isArray(participants))
+            throw new Error(`channels[${i}].participants must be an array`);
+        const listing = {
+            id,
+            name,
+            description,
+            participants: participants.filter((p) => typeof p === 'string'),
+        };
+        if (typeof item.image === 'string')
+            listing.image = item.image;
+        if (typeof item.spec === 'string')
+            listing.spec = item.spec;
+        if (isRecord(item.initialState))
+            listing.initialState = item.initialState;
+        if (Array.isArray(item.starterPrompts)) {
+            listing.starterPrompts = item.starterPrompts.map((p, j) => {
+                if (!isRecord(p) || typeof p.label !== 'string' || typeof p.prompt !== 'string') {
+                    throw new Error(`channels[${i}].starterPrompts[${j}] must have label and prompt`);
+                }
+                return { label: p.label, prompt: p.prompt };
+            });
+        }
+        return listing;
+    });
+    return { agents, channels };
+}
+async function fetchMarketplaceRegistryFromUrl(url) {
+    const res = await fetch(url, {
+        headers: { Accept: 'application/json' },
+        signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+        throw new Error(`Registry HTTP ${res.status} ${res.statusText}`);
+    }
+    const json = await res.json();
+    return parseMarketplaceRegistryJson(json);
+}
+/**
+ * Resolves marketplace registry (agents and channels) from configured registry URL.
+ */
+export async function resolveMarketplaceRegistry() {
+    const { marketplaceRegistryUrl } = loadConfig();
+    const registryUrl = marketplaceRegistryUrl?.trim() || DEFAULT_MARKETPLACE_REGISTRY_URL;
+    try {
+        return await fetchMarketplaceRegistryFromUrl(registryUrl);
+    }
+    catch (err) {
+        console.warn(`[plugins] marketplace registry fetch failed (${registryUrl}), using built-in list:`, err instanceof Error ? err.message : err);
+        return { agents: DEFAULT_MARKETPLACE_AGENTS, channels: DEFAULT_MARKETPLACE_CHANNELS };
+    }
+}
+/**
+ * Resolves marketplace agent listings from configured registry URL.
+ * @deprecated Use resolveMarketplaceRegistry instead.
+ */
+export async function resolveMarketplaceAgentList() {
+    const registry = await resolveMarketplaceRegistry();
+    return registry.agents;
+}
+const getPluginsDir = () => {
+    const config = loadConfig();
+    const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
+    return path.join(baseDir, DEFAULT_PLUGINS_DIR);
+};
+/**
+ * Lifecycle for community-built plugins distributed via npm.
+ * Each plugin is installed to `<plugins>/<npm-name>/` and is identified
+ * everywhere (AGENT.md `plugins[].id`, registry, runtime resolution) by its
+ * npm name. Scoped packages (`@scope/foo`) live under `<plugins>/@scope/foo/`.
+ */
+export const pluginService = {
+    isInstalled: async (packageName) => {
+        const finalPath = path.join(getPluginsDir(), packageName);
+        return existsSync(path.join(finalPath, 'dist', 'index.js'));
+    },
+    install: async ({ packageName, version }) => {
+        const pluginsDir = getPluginsDir();
+        await fs.mkdir(pluginsDir, { recursive: true });
+        const finalPath = path.join(pluginsDir, packageName);
+        if (existsSync(path.join(finalPath, 'package.json'))) {
+            try {
+                const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
+                if (!version || pkgJson.version === version) {
+                    console.log(`[plugins] ${packageName}${version ? `@${version}` : ''} is already installed.`);
+                    return { name: pkgJson.name, version: pkgJson.version };
+                }
+            }
+            catch {
+                // corrupted; reinstall below
+            }
+        }
+        const target = version ? `${packageName}@${version}` : packageName;
+        console.log(`[plugins] Installing ${target} to ${pluginsDir}...`);
+        const tempDir = path.join(pluginsDir, '.tmp_' + Date.now());
+        try {
+            await fs.mkdir(tempDir, { recursive: true });
+            await execAsync(`npm install ${target} --no-save --prefix "${tempDir}"`);
+            const installedPath = path.join(tempDir, 'node_modules', packageName);
+            if (!existsSync(installedPath)) {
+                throw new Error(`npm did not produce ${installedPath}`);
+            }
+            await fs.mkdir(path.dirname(finalPath), { recursive: true });
+            await fs.rm(finalPath, { recursive: true, force: true });
+            await fs.rename(installedPath, finalPath);
+            console.log(`[plugins] Running npm install in ${finalPath}...`);
+            try {
+                await execAsync(`npm install`, { cwd: finalPath });
+                console.log(`[plugins] npm install completed in ${finalPath}`);
+            }
+            catch (e) {
+                console.warn(`[plugins] Failed to run npm install in ${finalPath}:`, e);
+            }
+            const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
+            invalidatePlugin(packageName);
+            return { name: pkgJson.name, version: pkgJson.version };
+        }
+        catch (error) {
+            console.error(`[plugins] Failed to install ${packageName}:`, error);
+            throw new Error(`Failed to install plugin ${packageName}: ${error.message}`);
+        }
+        finally {
+            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
+        }
+    },
+    uninstall: async (packageName) => {
+        const pluginsDir = getPluginsDir();
+        const pluginPath = path.join(pluginsDir, packageName);
+        try {
+            await fs.rm(pluginPath, { recursive: true, force: true });
+            invalidatePlugin(packageName);
+            console.log(`[plugins] Uninstalled plugin ${packageName}`);
+            if (packageName.startsWith('@')) {
+                const scopeDir = path.dirname(pluginPath);
+                try {
+                    const remaining = await fs.readdir(scopeDir);
+                    if (remaining.length === 0)
+                        await fs.rmdir(scopeDir);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[plugins] Failed to uninstall ${packageName}:`, error);
+            throw new Error(`Failed to uninstall plugin ${packageName}: ${error.message}`);
+        }
+    },
+};

package/dist/services/plugins/types.js

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

package/dist/services/process.js

@@ -0,0 +1,29 @@
+import { loadVariables } from '../app/config.js';
+/** Keys last applied from workspace `variables.json` (used to unset removed entries). */
+let lastWorkspaceVariableKeys = new Set();
+function applyVariablesList(variables) {
+    const nextKeys = new Set(variables.map((v) => v.key));
+    for (const key of lastWorkspaceVariableKeys) {
+        if (!nextKeys.has(key)) {
+            delete process.env[key];
+        }
+    }
+    for (const variable of variables) {
+        process.env[variable.key] = variable.value;
+    }
+    lastWorkspaceVariableKeys = nextKeys;
+}
+export const processService = {
+    /**
+     * Reload workspace variables from disk into `process.env`.
+     * Call after server start and whenever `variables.json` changes.
+     */
+    syncWorkspaceVariablesToProcessEnv: () => {
+        const { variables } = loadVariables();
+        applyVariablesList(variables);
+    },
+    /** Apply a variable list directly (same unset semantics as sync). Prefer `syncWorkspaceVariablesToProcessEnv` when reading from disk. */
+    applyVariablesToProcessEnv: (variables) => {
+        applyVariablesList(variables);
+    },
+};

package/dist/services/storage.js

@@ -5,10 +5,10 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
-import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
-import { AI_SDK_SYSTEM_PROMPT } from '../plugins/ai-sdk/system-prompt.js';
+import { openbotPlugin } from '../plugins/openbot/index.js';
+import { OPENBOT_SYSTEM_PROMPT } from '../plugins/openbot/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../registry/plugins.js';
-import { processService } from '../harness/process.js';
+import { processService } from '../harness/index.js';
 import { memoryService } from './memory.js';
 const resolveBaseDir = () => {
     const config = loadConfig();
@@ -79,11 +79,9 @@ const getConversationDir = (channelId, threadId) => {
 /** Built-in orchestrator agent id. Not creatable as a normal disk agent. */
 const SYSTEM_AGENT_ID = 'system';
 const SYSTEM_DEFAULT_PLUGINS = [
-    { id: 'ai-sdk', config: { model: 'openai/gpt-5.4-nano' } },
+    { id: 'openbot', config: { model: 'openai/gpt-5.4-nano' } },
     { id: 'storage-tools' },
-    // { id: 'mcp' },
     { id: 'shell' },
-    { id: 'todo' },
     // { id: 'ui' },
     { id: 'approval' },
     { id: 'memory' },
@@ -93,8 +91,8 @@ function getSystemAgentDetails(overrides) {
         id: SYSTEM_AGENT_ID,
         name: 'OpenBot',
         image: getBundledSystemAgentImage(),
-        description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff.',
-        instructions: AI_SDK_SYSTEM_PROMPT,
+        description: 'First-party orchestration agent for OpenBot.',
+        instructions: OPENBOT_SYSTEM_PROMPT,
         plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
         pluginRefs: SYSTEM_DEFAULT_PLUGINS,
         createdAt: new Date(),
@@ -105,18 +103,21 @@ function getSystemAgentDetails(overrides) {
     const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
         ? overrides.pluginRefs
         : defaults.pluginRefs;
+    const diskInstructions = overrides.instructions?.trim();
+    const instructions = diskInstructions && diskInstructions.length > 0 ? diskInstructions : defaults.instructions;
     return {
         ...defaults,
         ...overrides,
         id: SYSTEM_AGENT_ID,
+        instructions,
         image: overrides.image || defaults.image,
         plugins: refs.map((ref) => ref.id),
         pluginRefs: refs,
         updatedAt: new Date(),
     };
 }
-// Suppress unused warning until system agent customization re-uses aiSdkPlugin metadata.
-void aiSdkPlugin;
+// Suppress unused warning until system agent customization re-uses openbotPlugin metadata.
+void openbotPlugin;
 const RESERVED_DISK_AGENT_IDS = new Set([SYSTEM_AGENT_ID]);
 const assertValidDiskAgentId = (agentId) => {
     if (!agentId || typeof agentId !== 'string') {

package/dist/services/thread-naming.js

@@ -0,0 +1,81 @@
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { anthropic } from '@ai-sdk/anthropic';
+import { loadConfig } from '../app/config.js';
+import { storageService } from '../plugins/storage/service.js';
+const THREAD_TITLE_MAX_LENGTH = 80;
+const namingInFlight = new Set();
+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 config = loadConfig();
+    const model = resolveModel(modelString || config.model || 'openai/gpt-4o-mini');
+    const result = await generateText({
+        model,
+        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;
+}
+export async function maybeGenerateThreadName(args) {
+    const key = `${args.channelId}:${args.threadId}`;
+    if (namingInFlight.has(key))
+        return;
+    namingInFlight.add(key);
+    try {
+        const details = await storageService.getThreadDetails({
+            channelId: args.channelId,
+            threadId: args.threadId,
+        });
+        const state = details.state || {};
+        if (state.nameStatus === 'llm' || state.nameStatus === 'manual')
+            return;
+        if (state.nameStatus !== 'provisional')
+            return;
+        const title = await generateThreadTitle(args.content);
+        if (!title)
+            return;
+        await storageService.patchThreadState({
+            channelId: args.channelId,
+            threadId: args.threadId,
+            state: { generatedName: title, nameStatus: 'llm' },
+        });
+        await args.onUpdated?.(title);
+    }
+    catch (error) {
+        console.warn('[thread-naming] Failed to generate thread name:', error);
+    }
+    finally {
+        namingInFlight.delete(key);
+    }
+}

package/docs/agents.md

@@ -14,12 +14,9 @@ You define an agent with a YAML-fronted markdown file at
 name: Researcher
 description: Web research and synthesis specialist.
 plugins:
-  - id: ai-sdk
+  - id: openbot
     config:
       model: anthropic/claude-3-5-sonnet-20240620
-  - id: mcp
-  - id: shell
-  - id: delegation
 ---
 
 You are a web research specialist. Use the available tools to gather and
@@ -29,25 +26,31 @@ synthesize information. Be concise and cite sources where relevant.
 The body below the frontmatter is the system prompt passed to the runtime
 plugin as `agentDetails.instructions`.
 
+Set `hidden: true` to omit the agent from `action:storage:get-agents` (it
+remains available via `action:storage:get-agent-details` and can still run on
+the bus). Built-in **`state`** is hidden by default.
+
 ### Required: at least one runtime plugin
 
 A runtime plugin is one that handles `agent:invoke` (the LLM loop). Without
 one, the agent will not respond to user input. Built-in runtime plugins:
 
-- `ai-sdk` — generic LLM runtime (Vercel AI SDK). Consumes tools from other
-  plugins listed alongside it.
+- `openbot` — the standard, opinionated OpenBot agent runtime. It is
+  **batteries-included** and provides inbuilt tools (bash, memory, storage,
+  delegation, and approval).
 - `claude-code` — runs Claude inside the Claude Agent SDK with its own tools.
 - `gemini-cli` — spawns Google's `gemini` CLI in headless mode.
 
 `claude-code` and `gemini-cli` own their own tool loops, so attaching tool
-plugins like `shell` or `mcp` to them has no effect. Pair tool plugins with
-`ai-sdk`.
+plugins like `bash` to them has no effect.
+
+## Built-in agents
 
-## Built-in agent
+OpenBot ships a built-in **`system`** agent (the orchestrator) with the `openbot`
+runtime. A built-in **`state`** agent backs deterministic
+`/api/state` handling and infra events.
 
-OpenBot ships a built-in `system` agent (the orchestrator) with the
-`ai-sdk` runtime plus the standard tool plugins (storage, shell, mcp,
-delegation, ui, approval, memory). It cannot be deleted.
+You can optionally persist overrides for either id at `~/.openbot/agents/system/AGENT.md` or `~/.openbot/agents/state/AGENT.md`. When present, settings are merged on top of the code defaults (`getAgentDetails`). The **`state`** agent is not listed by **`action:storage:get-agents`** (`hidden: true`); **`system`** is listed. Use **`action:storage:create-agent`** to create an overlay once, **`action:storage:update-agent`** for partial updates (creating the file if missing for `system` / `state`), and **`action:storage:delete-agent`** to remove only that `AGENT.md` and revert to defaults (other files under the folder are left untouched).
 
 ## Memory
 

package/docs/architecture.md

@@ -5,7 +5,7 @@ OpenBot is an orchestration platform built on a modular, event-driven architectu
 ## Core Components
 
 ### 1. Orchestrator & routing
-The orchestrator is the execution entry point for agent work: it normalizes incoming events, runs the queue processor (handoffs and todo-driven assignees), builds per-agent Melony runtimes, and streams emitted events back to callers (for example storage and SSE). Routing across the agent network uses:
+The orchestrator is the execution entry point for agent work: it normalizes incoming events, runs the queue processor (todo-driven assignees), builds per-agent Melony runtimes, and streams emitted events back to callers (for example storage and SSE). Routing across the agent network uses:
 
 1. **Command Prefix** — Explicit delegation to a specific agent (e.g., `/os list files`).
 2. **DM context** — Direct communication with a specific agent.
@@ -18,7 +18,7 @@ A dynamic registry that manages all available agents. Agents can be:
 - **TS Packages**: Advanced agents with custom logic in `~/.openbot/agents/*/index.ts`.
 
 ### 3. Plugin registry
-The "capability layer" that provides tools and logic shared across the platform. Plugins (like `shell`, `file-system`, or `mcp`) define the actions agents can perform.
+The "capability layer" that provides tools and logic shared across the platform. Plugins (like `bash` or `file-system`) define the actions agents can perform.
 
 ### 4. Orchestration layer (Melony)
 The underlying event bus that handles all communication. It ensures that agents can collaborate asynchronously, share context, and emit real-time updates to the UI.

package/docs/plugins.md

@@ -43,17 +43,36 @@ name collisions.
 
 | Id              | Role       | Notes                                                     |
 | --------------- | ---------- | --------------------------------------------------------- |
-| `ai-sdk`        | Runtime    | Generic LLM loop on Vercel AI SDK; consumes external tools |
+| `openbot`       | Runtime    | Standard batteries-included OpenBot agent runtime.        |
 | `claude-code`   | Runtime    | Claude Agent SDK; owns its own tool loop                  |
 | `gemini-cli`    | Runtime    | Google `gemini` CLI in headless mode                      |
-| `shell`         | Tool       | `shell_exec`                                              |
-| `mcp`           | Tool       | `mcp_list_tools`, `mcp_call`                              |
-| `delegation`    | Tool       | `handoff`, `delegate`                                     |
-| `storage-tools` | Tool       | `create_channel`, `patch_*`, `create_variable`, ...       |
-| `ui`            | Tool       | `render_ui_widget`                                        |
-| `approval`      | Middleware | Gates protected actions behind a UI confirmation widget   |
+| `bash`          | Tool       | `bash` (inbuilt in `openbot`)                             |
+| `storage`       | Tool       | `create_channel`, `patch_*`, ... (inbuilt in `openbot`)   |
+| `memory`        | Tool       | `remember`, `recall`, `forget` (inbuilt in `openbot`)     |
+| `plugin-manager`| Infra      | Marketplace list, npm plugin install/uninstall, agent install |
 
-## Community plugins
+## Batteries-included: `openbot` runtime
+
+The `openbot` plugin is the standard runtime for OpenBot agents. It is designed
+to be isolated and self-contained, providing a core ecosystem of inbuilt tools:
+
+- **Bash**: Stateful system tasks and file operations.
+- **Memory**: Long-term durable fact storage.
+- **Storage**: Channel and thread management.
+- **Delegation**: Calling upon other specialized agents.
+- **Approval**: Gating protected actions behind UI confirmation.
+
+When you use the `openbot` runtime, these tools are automatically available.
+You can configure the inbuilt `approval` plugin via the `openbot` plugin config:
+
+```yaml
+plugins:
+  - id: openbot
+    config:
+      model: openai/gpt-4o-mini
+      approval:
+        actions: [action:bash, action:create_channel]
+```
 
 A community plugin is just an npm package whose default export matches the
 `Plugin` interface. Reference it by its npm package name in AGENT.md:
@@ -71,18 +90,11 @@ On first use OpenBot installs the package into
 
 ## Approval plugin
 
-The `approval` plugin reads its rules from per-agent config:
+The `approval` plugin gates protected tool calls behind a UI confirmation widget. By default, it gates `action:bash`.
 
 ```yaml
 plugins:
   - id: approval
     config:
-      rules:
-        - action: action:shell_exec
-          message: The agent wants to run a terminal command.
-          detailKeys: [command, cwd, shell, timeoutMs]
-          hiddenKeys: [env]
+      actions: [action:bash]
 ```
-
-If `rules` is omitted, sensible defaults are applied (currently: gate
-`action:shell_exec`).

package/docs/templates/AGENT.example.md

@@ -9,32 +9,26 @@ description: One-line description shown in agent pickers and lists.
 
 # Plugins compose the agent. Order matters for tool collisions (first wins).
 # At least one plugin must handle `agent:invoke` (a "runtime" plugin like
-# `ai-sdk`, `claude-code`, or `gemini-cli`). Tool plugins like `shell`, `mcp`,
-# `delegation`, `storage-tools`, and `ui` contribute tools to whichever runtime
+# `openbot`, `claude-code`, or `gemini-cli`). Tool plugins like `bash`,
+# `delegation`, and `storage-tools` contribute tools to whichever runtime
 # plugin can consume them.
 #
-# Built-in plugin ids: ai-sdk, claude-code, gemini-cli, shell, mcp, delegation,
-# storage-tools, ui, approval.
+# Built-in plugin ids: openbot, claude-code, gemini-cli, bash, delegation,
+# storage-tools, approval.
 #
 # Community plugins are referenced by their npm package name (e.g.
 # `openbot-plugin-search` or `@scope/openbot-plugin-foo`) and are auto-installed
 # on first use into ~/.openbot/plugins/<id>/.
 plugins:
-  - id: ai-sdk
+  - id: openbot
     config:
       model: openai/gpt-4o-mini
-  - id: shell
-  - id: mcp
+  - id: bash
   - id: delegation
-  - id: storage-tools
-  - id: ui
+  - id: storage
   - id: approval
     config:
-      rules:
-        - action: action:shell_exec
-          message: The agent wants to run a terminal command.
-          detailKeys: [command, cwd, shell, timeoutMs]
-          hiddenKeys: [env]
+      actions: [action:bash]
 ---
 
 <!--

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.3.6",
+  "version": "0.4.2",
   "private": false,
   "type": "module",
   "engines": {
@@ -13,7 +13,6 @@
     "@ai-sdk/anthropic": "^3.0.33",
     "@ai-sdk/openai": "^3.0.13",
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "@types/cors": "^2.8.19",
     "ai": "^6.0.42",
     "commander": "^14.0.2",

package/src/app/agent-ids.ts

@@ -0,0 +1,5 @@
+/** Built-in orchestrator agent id. Optional `agents/system/AGENT.md` overrides code defaults. */
+export const ORCHESTRATOR_AGENT_ID = 'system';
+
+/** Built-in infra agent for deterministic `/api/state` and marketplace/plugin lifecycle; optional AGENT.md overlay. */
+export const STATE_AGENT_ID = 'state';

package/src/app/cli.ts

@@ -25,7 +25,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.3.6');
+program.name('openbot').description('OpenBot CLI').version('0.4.2');
 
 program
   .command('start')