@bahulam/code 0.1.15 → 0.1.17

package/src/core/headless.mjs

@@ -76,7 +76,28 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
         const { dispatch } = await import('../orchestration/dispatch.mjs');
         const { listLocalWorkflows } = await import('../agents/workflow_scaffold.mjs');
         const pluginRegistry = new PluginRegistry().scan();
-        const toolExecutor = createToolExecutor({ pluginRegistry });
+        let toolExecutor = null;
+        const runDelegateFromTool = async ({ agent: targetAgent, slug, instruction: task, options = {} }) => {
+            const outcome = await dispatch({
+                type: 'invoke',
+                source: 'tool:delegate',
+                target: { kind: 'agent', slug: slug || targetAgent?.slug, agent: targetAgent },
+                params: { instruction: task || '' },
+                channel: 'local',
+                substrate: 'direct',
+                signal: options.signal,
+            }, {
+                toolExecutor,
+                listRunnables: () => toolExecutor.listRunnables(),
+                listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
+                renderEvent: (event) => emit({ type: event.type, ...event.data }),
+                credentials: { apiKey: anthKey, openRouterKey: orKey },
+                defaultModel: model || null,
+                cwd: process.cwd(),
+            });
+            return outcome;
+        };
+        toolExecutor = createToolExecutor({ pluginRegistry, delegateRunner: runDelegateFromTool });
         const timer = setTimeout(() => {
             emit({ type: 'timeout', duration_s: timeout });
             process.exit(2);
@@ -121,7 +142,30 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     const pluginRegistry = new PluginRegistry().scan();
 
     // Projects are registered and indexed only when the agent requests an overview.
-    const toolExecutor = createToolExecutor({ pluginRegistry });
+    let toolExecutor = null;
+    const runDelegateFromTool = async ({ agent: targetAgent, slug, instruction: task, options = {} }) => {
+        const { dispatch } = await import('../orchestration/dispatch.mjs');
+        const { listLocalWorkflows } = await import('../agents/workflow_scaffold.mjs');
+        const outcome = await dispatch({
+            type: 'invoke',
+            source: 'tool:delegate',
+            target: { kind: 'agent', slug: slug || targetAgent?.slug, agent: targetAgent },
+            params: { instruction: task || '' },
+            channel: 'local',
+            substrate: 'direct',
+            signal: options.signal,
+        }, {
+            toolExecutor,
+            listRunnables: () => toolExecutor.listRunnables(),
+            listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
+            renderEvent: (event) => emit({ type: event.type, ...event.data }),
+            credentials: { apiKey: anthKey, openRouterKey: orKey },
+            defaultModel: model || null,
+            cwd: process.cwd(),
+        });
+        return outcome;
+    };
+    toolExecutor = createToolExecutor({ pluginRegistry, delegateRunner: runDelegateFromTool });
 
     // Auto-approve everything — no prompts
     const approval = new ApprovalManager({ autoApprove: true });

package/src/core/stream-client.mjs

@@ -226,6 +226,7 @@ export class BahulamStreamClient {
         };
 
         for (const agent of clientAgents || []) addAgent(agent);
+        for (const agent of context?.agent_context?.available_agents || []) addAgent(agent);
         for (const agent of context?.agent_ctx?.available_agents || []) addAgent(agent);
         for (const agent of context?.available_agents || []) addAgent(agent);
         if (context?.sub_agent) addAgent(context.sub_agent);

package/src/core/tool-executor.mjs

@@ -16,15 +16,14 @@ import { analyzeCode } from '../context/ast-parser.mjs';
 import { ProjectRegistry } from '../tools/project-overview.mjs';
 import { SkillInstaller } from '../skills/installer.mjs';
 import { SkillsLoader } from '../skills/loader.mjs';
-import { agentToSpec, createAgentFile, listLocalAgents, syncAgentsToBackend } from '../agents/scaffold.mjs';
+import { createAgentFile, listLocalAgents, syncAgentsToBackend } from '../agents/scaffold.mjs';
+import { compactAgentMetadata, createAgentRegistry } from '../agents/registry.mjs';
 import { createWorkflowFile, listLocalWorkflows, WORKFLOW_SYNC_ENDPOINT, slugifyWorkflowName } from '../agents/workflow_scaffold.mjs';
 import { BahulamAuth } from '../auth/bahulam-auth.mjs';
 import { detectImageFile } from './attachments.mjs';
 import { streamResponse } from './streaming.mjs';
 import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
-import { loadBahulamSettings } from '../config/settings-loader.mjs';
-import { BUILTIN_AGENTS } from '../terminal/agents.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
 import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
@@ -60,6 +59,7 @@ export function createToolExecutor({
     // REPL/headless callers leave this null — state still works, just
     // no reactive pulse.
     stateEmit = null,
+    delegateRunner = null,
     // Execution channel. 'main' (REPL/headless/CLI): plugin agents are
     // workspace-scoped and excluded from listings and the agent-context
     // envelope unless allowlisted in settings plugins.agent_allowlist.
@@ -81,6 +81,12 @@ export function createToolExecutor({
     // guards it, but doing it here means the first read is a plain fs stat
     // rather than a mkdir round-trip.
     try { ensureBahulamDir('global'); } catch { /* ignore */ }
+    let activeDelegateRunner = delegateRunner;
+    const agentRegistry = createAgentRegistry({
+        cwd: () => process.cwd(),
+        pluginRegistry,
+        channel,
+    });
     let _memoryCache = null; // { key: string, facts: Fact[], digest: string }
     function _readMemorySnapshot() {
         const gPath = globalMemoryPath();
@@ -232,169 +238,16 @@ export function createToolExecutor({
         return ['read_file', 'search_code', 'list_files'];
     }
 
-    function agentMatches(agent, query) {
-        const needle = String(query || '').trim().toLowerCase();
-        if (!needle) return true;
-        return [
-            agent.slug,
-            agent.name,
-            agent.description,
-            agent.role,
-            agent.model,
-            ...(Array.isArray(agent.tools) ? agent.tools : []),
-            ...(Array.isArray(agent.capabilities) ? agent.capabilities : []),
-            ...(Array.isArray(agent.domains) ? agent.domains : []),
-        ].some(value => String(value || '').toLowerCase().includes(needle));
-    }
-
-    function compactAgentMetadata(agent) {
-        return {
-            slug: agent.slug,
-            name: agent.name,
-            description: agent.description || '',
-            role: agent.role || 'specialist',
-            model: agent.model || null,
-            models: agent.models && Object.keys(agent.models).length ? agent.models : undefined,
-            tools: Array.isArray(agent.tools) ? agent.tools : [],
-            capabilities: Array.isArray(agent.capabilities) ? agent.capabilities : [],
-            domains: Array.isArray(agent.domains) ? agent.domains : [],
-            source_scope: agent.source_scope || 'unknown',
-            source: agent.source || '',
-            content_hash: agent.content_hash || '',
-            runnable: agent.runnable !== false,
-        };
-    }
-
-    function pluginAgentToLocalShape(agentDef) {
-        const pluginName = agentDef._plugin_name
-            || String(agentDef.source || '').replace(/^plugin:/, '')
-            || 'unknown';
-        const source = `plugin:${pluginName}`;
-        const base = {
-            ...agentDef,
-            slug: agentDef.slug || agentDef.name || '',
-            name: agentDef.name || agentDef.slug || '',
-            description: agentDef.description || '',
-            role: agentDef.role || 'specialist',
-            model: agentDef.model || null,
-            models: agentDef.models || undefined,
-            tools: Array.isArray(agentDef.tools)
-                ? agentDef.tools
-                : (Array.isArray(agentDef.agent_tools) ? agentDef.agent_tools : []),
-            capabilities: Array.isArray(agentDef.capabilities) ? agentDef.capabilities : [],
-            domains: Array.isArray(agentDef.domains) ? agentDef.domains : [],
-            system_prompt: agentDef.system_prompt || agentDef.prompt || agentDef.instructions || '',
-            prompt: agentDef.prompt || agentDef.system_prompt || agentDef.instructions || '',
-            source_scope: 'plugin',
-            source,
-        };
-        const spec = {
-            ...agentToSpec(base),
-            source,
-            source_scope: 'plugin',
-            plugin_name: pluginName,
-        };
-        if (spec.config?.metadata && typeof spec.config.metadata === 'object') {
-            spec.config.metadata.source = source;
-            spec.config.metadata.source_scope = 'plugin';
-        }
-        const content = JSON.stringify(spec);
-        return {
-            ...base,
-            slug: spec.slug,
-            spec,
-            source,
-            source_scope: 'plugin',
-            content_hash: crypto.createHash('sha256').update(content).digest('hex'),
-        };
-    }
-
-    function listPluginAgents() {
-        if (!pluginRegistry) return [];
-        return pluginRegistry.listAgents()
-            .map(pluginAgentToLocalShape)
-            .filter(agent => agent.slug);
-    }
-
-    // Plugin agents are workspace-scoped entities. They enter the
-    // main-loop registry only via an explicit settings allowlist.
-    function pluginAgentAllowlist() {
-        try {
-            const { settings } = loadBahulamSettings({ cwd: process.cwd() });
-            const list = settings?.plugins?.agent_allowlist;
-            return Array.isArray(list) ? list.map(item => String(item)) : [];
-        } catch {
-            return [];
-        }
-    }
-
-    const BUILTIN_RUNNABLES = BUILTIN_AGENTS.map(def => ({
-        slug: def.command,
-        name: def.name,
-        description: def.description || '',
-        role: 'builtin',
-        model: null,
-        models: undefined,
-        tools: [],
-        capabilities: [],
-        domains: [],
-        source_scope: 'builtin',
-        source: 'builtin',
-        content_hash: '',
-        read_only: Boolean(def.readOnly),
-        runnable: true,
-    }));
-
-    // The deterministic sub-agent registry. Resolution precedence:
-    // project agent → global agent → builtin → allowlisted plugin agent.
-    // In workspace-channel executors the session plugin's agents are
-    // runnable without an allowlist entry.
     function listRunnables() {
-        const bySlug = new Map();
-        for (const agent of listLocalAgents(process.cwd())) {
-            if (agent.slug && !bySlug.has(agent.slug)) {
-                bySlug.set(agent.slug, { ...agent, runnable: true });
-            }
-        }
-        for (const builtin of BUILTIN_RUNNABLES) {
-            if (!bySlug.has(builtin.slug)) bySlug.set(builtin.slug, builtin);
-        }
-        const allowlist = new Set(pluginAgentAllowlist());
-        for (const agent of listPluginAgents()) {
-            if (!agent.slug || bySlug.has(agent.slug)) continue;
-            if (channel === 'workspace' || allowlist.has(agent.slug)) {
-                bySlug.set(agent.slug, { ...agent, runnable: true });
-            }
-        }
-        return [...bySlug.values()];
-    }
-
-    // Installed plugin agents NOT admitted to the main-loop registry —
-    // still discoverable (scope:'plugin') but flagged not runnable.
-    function listWorkspaceScopedPluginAgents() {
-        const runnableSlugs = new Set(listRunnables().map(agent => agent.slug));
-        return listPluginAgents()
-            .filter(agent => agent.slug && !runnableSlugs.has(agent.slug))
-            .map(agent => ({ ...agent, runnable: false }));
+        return agentRegistry.listRunnables();
     }
 
-    // Agent-context envelope population: the runnable registry minus
-    // builtins (the backend has its own delegation vocabulary for those;
-    // adding them to available_agents would change wire behavior).
     function listAvailableAgents() {
-        return listRunnables().filter(agent => agent.source_scope !== 'builtin');
+        return agentRegistry.listAvailableAgents();
     }
 
     function filterLocalAgents(args = {}) {
-        const scope = String(args.scope || '').trim();
-        if (scope && !['project', 'global', 'plugin', 'builtin'].includes(scope)) {
-            throw new Error('scope must be "project", "global", "plugin", or "builtin"');
-        }
-        const pool = scope === 'plugin'
-            ? [...listRunnables(), ...listWorkspaceScopedPluginAgents()]
-            : listRunnables();
-        const combined = pool.filter(agent => !scope || agent.source_scope === scope);
-        return combined.filter(agent => agentMatches(agent, args.query || args.name || ''));
+        return agentRegistry.filterAgents(args);
     }
 
     function selectAgentsForSync(args = {}) {
@@ -1067,6 +920,57 @@ export function createToolExecutor({
             };
         },
 
+        // Reserved meta-tool adapter. Cloud backends may implement Delegate
+        // natively; local callbacks use this to route through the exact same
+        // registry + dispatch funnel as /run and workflows.
+        delegate: async (args = {}, options = {}) => {
+            throwIfAborted(options.signal);
+            const target = String(args.agent || args.name || args.slug || args.sub_agent || '').trim();
+            const instruction = String(args.instruction || args.task || args.prompt || args.request || '').trim();
+            if (!target) {
+                return { success: false, output: 'delegate requires an agent slug or name.', _tool: 'delegate' };
+            }
+            if (!instruction) {
+                return { success: false, output: 'delegate requires an instruction.', _tool: 'delegate' };
+            }
+            const agent = agentRegistry.findAgent(target);
+            if (!agent) {
+                return {
+                    success: false,
+                    output: `Unknown delegate target '${target}'. Available agents: ${listRunnables().map(item => item.slug).join(', ') || '(none)'}`,
+                    _tool: 'delegate',
+                };
+            }
+            if (typeof activeDelegateRunner !== 'function') {
+                return {
+                    success: false,
+                    output: 'Local delegate execution is not wired for this surface. Use /run <agent> "<task>" or delegate from a cloud execute session.',
+                    _tool: 'delegate',
+                    agent: compactAgentMetadata(agent),
+                };
+            }
+            const delegated = await activeDelegateRunner({
+                agent,
+                slug: agent.slug,
+                instruction,
+                context: args.context && typeof args.context === 'object' ? args.context : {},
+                options,
+            });
+            const payload = delegated?.result || delegated || {};
+            const output = payload.output
+                || payload.final_response
+                || payload.result
+                || (typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2));
+            return {
+                success: delegated?.dispatched === false ? false : payload.success !== false,
+                output: String(output || ''),
+                agent: compactAgentMetadata(agent),
+                run_id: payload.run_id || payload.graph_run_id || null,
+                node_results: payload.node_results || undefined,
+                _tool: 'delegate',
+            };
+        },
+
         analyze_image: async (args, options = {}) => {
             throwIfAborted(options.signal);
             const tool = occRegistry.get('analyze_image');
@@ -2807,6 +2711,22 @@ export function createToolExecutor({
 
         listRunnables,
 
+        findAgent(target) {
+            return agentRegistry.findAgent(target);
+        },
+
+        filterAgents(args = {}) {
+            return agentRegistry.filterAgents(args);
+        },
+
+        getSubAgentObservability() {
+            return agentRegistry.observability();
+        },
+
+        setDelegateRunner(fn) {
+            activeDelegateRunner = typeof fn === 'function' ? fn : null;
+        },
+
         // Plugin tool schemas (name/description/input_schema) for callers
         // that compose model-facing tool lists — e.g. the graph engine's
         // direct substrate giving a plugin agent its declared tools.
@@ -2849,6 +2769,7 @@ export function createToolExecutor({
                     source: agent.source,
                     spec: agent.spec,
                 })),
+                sub_agent_observability: agentRegistry.observability(),
                 // Background jobs the model should know about. Stable fields
                 // only (no durations) so the entry — and the prompt cache —
                 // changes on status transitions, not every turn.

package/src/local-service/agent-relay.mjs

@@ -19,6 +19,8 @@ import {
 import { BahulamStreamClient } from '../core/stream-client.mjs';
 import { createToolExecutor } from '../core/tool-executor.mjs';
 import { buildWorkScope } from '../core/work-scope.mjs';
+import { listLocalWorkflows } from '../agents/workflow_scaffold.mjs';
+import { dispatch } from '../orchestration/dispatch.mjs';
 import { BrowserApprovalManager } from './approval-bridge.mjs';
 
 const __require = createRequire(import.meta.url);
@@ -617,7 +619,31 @@ export class LocalAgentRelay {
       try { this.emit('plugin_state_changed', evt); }
       catch { /* never let SSE failure break a tool call */ }
     };
-    const toolExecutor = createToolExecutor({ pluginRegistry, stateEmit, channel: 'workspace' });
+    let toolExecutor = null;
+    const runDelegateFromTool = async ({ agent, slug, instruction, options = {} }) => {
+      const turnId = `delegate_${Date.now().toString(36)}`;
+      return await dispatch({
+        type: 'invoke',
+        source: 'tool:delegate',
+        target: { kind: 'agent', slug: slug || agent?.slug, agent },
+        params: { instruction: instruction || '' },
+        channel: 'local',
+        signal: options.signal,
+      }, {
+        toolExecutor,
+        listRunnables: () => toolExecutor?.listRunnables?.() || [],
+        listLocalWorkflows: () => listLocalWorkflows(this.session.root_path),
+        renderEvent: event => this._emitAgentEvent(event, { turnId, contentText: event?.data?.text || event?.data?.content || null }),
+        sessionSubstrate: this._makeWorkspaceSessionSubstrate(pluginRegistry),
+        auth: { token: creds.token || null },
+        credentials: {
+          apiKey: process.env.ANTHROPIC_API_KEY || creds.anthropicKey || null,
+          openRouterKey: process.env.OPENROUTER_API_KEY || creds.openRouterKey || null,
+        },
+        cwd: this.session.root_path,
+      });
+    };
+    toolExecutor = createToolExecutor({ pluginRegistry, stateEmit, channel: 'workspace', delegateRunner: runDelegateFromTool });
     await toolExecutor.waitForAutoRegister?.();
     await toolExecutor.registerProjectRoots?.([this.session.root_path], { forceRefresh: false });
 
@@ -726,6 +752,35 @@ export class LocalAgentRelay {
     return execContext;
   }
 
+  _makeWorkspaceSessionSubstrate(pluginRegistry) {
+    return (agent, node, instruction, { scopedExecutor } = {}) => (async function* (relay) {
+      const execContext = await relay._buildExecContext(instruction);
+      const slug = agent.slug || agent.command || agent.name || node?.agent_slug || node?.id || 'agent';
+      execContext.sub_agent = {
+        slug,
+        name: agent.name || slug,
+        role: agent.role || 'specialist',
+        description: agent.description || '',
+        tools: Array.isArray(agent.tools) ? agent.tools : [],
+        source: agent.source || '',
+      };
+      const systemPrompt = agent.systemPrompt || agent.system_prompt || agent.prompt || `You are ${agent.name || slug}, a Bahulam Code sub-agent.`;
+      const fullInstruction = `${systemPrompt}\n\n---\n\nUser request: ${instruction || 'Run your assigned task now.'}`;
+      const client = new BahulamStreamClient({
+        baseUrl: relay.creds.backendUrl,
+        token: relay.creds.token,
+        toolExecutor: scopedExecutor || relay.toolExecutor,
+        approvalManager: relay.approvalManager,
+        mode: 'remote',
+        pluginRegistry,
+      });
+      if (relay.resumeSessionId) client.sessionId = relay.resumeSessionId;
+      for await (const event of client.execute(fullInstruction, execContext)) {
+        yield event;
+      }
+    })(this);
+  }
+
   _buildInstruction(prompt, currentPath, attachments = []) {
     const lines = [
       'You are running inside Bahulam Local IDE.',

package/src/local-service/server.mjs

@@ -538,7 +538,7 @@ async function routeRequest({ req, res, sessionId, token, events, sseClients, em
   }
 
   // Plugin workspace views (PRD-101 §4.6): panels declared under
-  // spec.workspace.views in plugin.yaml, rendered as sandboxed iframes.
+  // config.views in plugin.yaml, rendered as sandboxed iframes.
   // Generic infra — ANY installed plugin (project-local or ~/.bahulam)
   // contributes tabs; its whole directory is served statically so views
   // can ship css/js/assets with relative paths.
@@ -650,7 +650,7 @@ function scanPlugins(session) {
       if (!pluginName || !manifest._dir) continue;
       if (scope !== '__all__' && pluginName.toLowerCase() !== scope) continue;
       dirs.set(pluginName, manifest._dir);
-      (manifest.spec?.workspace?.views || []).forEach((view) => {
+      (manifest.config?.views || []).forEach((view) => {
         const source = String(view?.source || '').trim().replace(/^\.\//, '');
         if (!source) return;
         views.push({

package/src/orchestration/dispatch.mjs

@@ -70,7 +70,7 @@ function resolveAgentBySlug(slug, ctx) {
 
 /**
  * Bare-name resolution order (uniform across surfaces, preserves today's
- * /run behavior): project agent → global agent → builtin → allowlisted
+ * /run behavior): project agent → global agent → platform → allowlisted
  * plugin agent → local workflow → synced server workflow fallback.
  * listRunnables() already returns agents deduped in that precedence.
  */

package/src/plugins/executor.mjs

@@ -68,7 +68,7 @@ export async function loadPluginTool(pluginDir, handlerPath) {
  */
 export async function createPluginToolExecutor(manifest, opts = {}) {
   const pluginDir = manifest._dir || '';
-  const tools = manifest.spec?.tools || [];
+  const tools = manifest.config?.tools || [];
   const handlers = new Map(); // name → { handler, toolDef }
   const pluginName = manifest.metadata?.name || '';
 
@@ -118,4 +118,4 @@ export async function createPluginToolExecutor(manifest, opts = {}) {
     /** Get (or open) the plugin's state handle — used by the view API. */
     get state() { return getState(); },
   };
-}
+}

package/src/plugins/loader.mjs

@@ -7,9 +7,10 @@
 
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import { execSync } from 'child_process';
 import { PluginRegistry } from './registry.mjs';
+import { parsePluginManifestFile } from './manifest.mjs';
+import { bahulamHome } from '../core/paths.mjs';
 
 export class PluginLoader {
   /**
@@ -21,11 +22,11 @@ export class PluginLoader {
   constructor(options = {}) {
     const { pluginDir, pluginDirs, disabled } = options;
     this.registry = new PluginRegistry({
-      pluginDir: pluginDir || path.join(os.homedir(), '.bahulam', 'plugins'),
+      pluginDir: pluginDir || path.join(bahulamHome(), 'plugins'),
       pluginDirs,
       disabled,
     });
-    this.pluginDir = pluginDir || path.join(os.homedir(), '.bahulam', 'plugins');
+    this.pluginDir = pluginDir || path.join(bahulamHome(), 'plugins');
   }
 
   /**
@@ -73,7 +74,6 @@ export class PluginLoader {
       const exists = fs.existsSync(manifestPath) ? manifestPath : (fs.existsSync(altPath) ? altPath : null);
 
       if (exists) {
-        const { parsePluginManifestFile } = await import('./manifest.mjs');
         const manifest = parsePluginManifestFile(exists);
         if (manifest) {
           this.registry.register(manifest);
@@ -135,4 +135,4 @@ export class PluginLoader {
   count() {
     return this.registry.count();
   }
-}
+}