@bahulam/code 0.1.10 → 0.1.12

package/src/tools/agent.mjs

@@ -58,9 +58,13 @@ export const AgentTool = {
     _backgroundAgents: new Map(),
     _nextBgId: 0,
 
-    async call(input) {
+    async call(input, options = {}) {
         const model = input.model || process.env.SUBAGENT_MODEL || 'claude-sonnet-4-6';
-        const tools = createToolRegistry();
+        const tools = createToolRegistry({
+            pluginRegistry: options.pluginRegistry || null,
+            stateEmit: options.stateEmit || null,
+            exposePluginTools: true,
+        });
         const permissions = createPermissionChecker({ defaultMode: 'bypassPermissions' });
 
         // Build type-specific system prompt prefix

package/src/tools/analyze-image.mjs

@@ -92,7 +92,7 @@ export const AnalyzeImageTool = {
     if (!creds.backendUrl || !creds.token) {
       return {
         success: false,
-        output: 'analyze_image requires CLI auth. Run `bahulam-code login` or set B0_TOKEN/KEPLER_TOKEN.',
+        output: 'analyze_image requires CLI auth. Run `bahulam-code login` or set B0_TOKEN.',
         _tool: 'analyze_image',
       };
     }

package/src/tools/project-overview.mjs

@@ -73,7 +73,7 @@ const PROJECT_MARKERS = [
     'pom.xml', 'build.gradle', 'build.gradle.kts', 'settings.gradle',  // Java/Kotlin
     'Makefile', 'CMakeLists.txt',  // C/C++
     'Dockerfile', 'docker-compose.yml', 'docker-compose.yaml',
-    'AGENTS.md', 'CLAUDE.md', 'KEPLER.md',  // Agent config lives at root
+    'AGENTS.md', 'BAHULAM.md', 'CLAUDE.md',  // Agent config lives at root
     '.editorconfig',               // Broad but a strong "this is a repo" signal
 ];
 
@@ -350,7 +350,7 @@ function defaultScratchRoots() {
         '/private/tmp',
         os.tmpdir(),
         process.env.TMPDIR,
-        ...(process.env.KEPLER_SCRATCH_ROOTS || '')
+        ...(process.env.BAHULAM_SCRATCH_ROOTS || '')
             .split(path.delimiter)
             .map(s => s.trim())
             .filter(Boolean),
@@ -399,13 +399,13 @@ export class ProjectRegistry {
 
     // PRD-69 project context is live metadata, not index cache. Re-read it on
     // every registration attempt so repeated get_project_overview calls pick up
-    // .bahulam/KEPLER.md, goal/plan/style, skills, AGENTS.md, etc. changes.
+    // .bahulam/BAHULAM.md, goal/plan/style, skills, AGENTS.md, etc. changes.
     _attachLiveContext(resource, root) {
-        // Resolver — prefers .bahulam/, falls back to .kepler/ for legacy projects.
         const bahulamDir = projectConfigDir(root);
         resource.environment = detectEnvironment();
-        resource.project_context = _readIfExists(bahulamDir, 'KEPLER.md', 10000) ||
-            _readIfExists(root, 'KEPLER.md', 10000) ||
+        resource.project_context = _readIfExists(root, 'AGENTS.md', 10000) ||
+            _readIfExists(bahulamDir, 'BAHULAM.md', 10000) ||
+            _readIfExists(root, 'BAHULAM.md', 10000) ||
             _readIfExists(bahulamDir, 'project.md', 8000);
         resource.style = _readIfExists(bahulamDir, 'style.md', 4000);
         resource.goal = _readIfExists(bahulamDir, 'goal.md', 2000);
@@ -413,7 +413,7 @@ export class ProjectRegistry {
         resource.skills_index = _scanSkills(bahulamDir);
 
         if (!resource.project_context) {
-            for (const name of ['.bahulam.md', 'AGENTS.md', 'CLAUDE.md']) {
+            for (const name of ['.bahulam.md', 'BAHULAM.md', 'AGENTS.md', 'CLAUDE.md']) {
                 const content = _readIfExists(root, name, 8000);
                 if (content) { resource.project_context = content; break; }
             }

package/src/tools/registry.mjs

@@ -39,6 +39,7 @@ import { ExploreTool, PlanTool, VerifyTool, DebugTool, RefactorTool } from './me
 import { RememberTool } from './remember.mjs';
 import { GenerateImageTool } from './generate-image.mjs';
 import { AnalyzeImageTool } from './analyze-image.mjs';
+import { loadPluginTool } from '../plugins/executor.mjs';
 
 const BUILTIN_TOOLS = [
     BashTool,
@@ -82,12 +83,95 @@ const BUILTIN_TOOLS = [
     RefactorTool,
 ];
 
-export function createToolRegistry() {
+export function createToolRegistry({
+    pluginRegistry = null,
+    stateEmit = null,
+    exposePluginTools = false,
+} = {}) {
     const tools = new Map();
     for (const Tool of BUILTIN_TOOLS) {
-        tools.set(Tool.name, Tool);
+        if (Tool === AgentTool) {
+            tools.set(Tool.name, {
+                ...Tool,
+                async call(input, options = {}) {
+                    return Tool.call(input, {
+                        ...options,
+                        pluginRegistry: options.pluginRegistry || pluginRegistry,
+                        stateEmit: options.stateEmit || stateEmit,
+                    });
+                },
+            });
+        } else {
+            tools.set(Tool.name, Tool);
+        }
     }
 
+    const pluginStateHandles = new Map();
+    async function pluginStateFor(pluginName) {
+        if (!pluginName) return null;
+        if (pluginStateHandles.has(pluginName)) return pluginStateHandles.get(pluginName);
+        const { makePluginState } = await import('../plugins/state.mjs');
+        const state = makePluginState(pluginName, { emit: stateEmit });
+        pluginStateHandles.set(pluginName, state);
+        return state;
+    }
+
+    function registerPluginToolsFromRegistry() {
+        if (!pluginRegistry) return;
+        for (const toolDef of pluginRegistry.listTools?.() || []) {
+            const name = String(toolDef.name || '').trim();
+            if (!name || tools.has(name)) continue;
+            const pluginName = toolDef._plugin_name || toolDef.plugin_name || null;
+            tools.set(name, {
+                name,
+                description: toolDef.description || '',
+                inputSchema: toolDef.input_schema || toolDef.parameters || { type: 'object', properties: {} },
+                validateInput() { return []; },
+                async call(input, options = {}) {
+                    const handler = await loadPluginTool(toolDef._plugin_dir, toolDef.tool || toolDef.handler);
+                    if (!handler) {
+                        return {
+                            success: false,
+                            output: `Plugin tool module could not be loaded: ${name}`,
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    }
+                    const handlerOpts = {
+                        ...options,
+                        pluginName,
+                        get state() {
+                            if (this._stateP) return this._stateP;
+                            this._stateP = pluginStateFor(pluginName);
+                            return this._stateP;
+                        },
+                    };
+                    try {
+                        const result = await handler.call(input || {}, handlerOpts);
+                        if (result && typeof result === 'object' && 'success' in result) {
+                            return { ...result, _tool: name, _plugin: pluginName };
+                        }
+                        return {
+                            success: true,
+                            output: typeof result === 'string' ? result : JSON.stringify(result),
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    } catch (err) {
+                        return {
+                            success: false,
+                            output: `Plugin tool error (${name}): ${err.message}`,
+                            _tool: name,
+                            _plugin: pluginName,
+                        };
+                    }
+                },
+            });
+        }
+    }
+
+    if (exposePluginTools) registerPluginToolsFromRegistry();
+
     const registry = {
         list() {
             return [...tools.values()].map(t => ({
@@ -97,12 +181,12 @@ export function createToolRegistry() {
             }));
         },
 
-        async call(name, input) {
+        async call(name, input, options = {}) {
             const tool = tools.get(name);
             if (!tool) throw new Error(`Unknown tool: ${name}`);
             const errors = tool.validateInput?.(input) || [];
             if (errors.length > 0) return `Validation error: ${errors.join(', ')}`;
-            const result = await tool.call(input);
+            const result = await tool.call(input, options);
 
             return result;
         },

package/src/ui/slash-commands.mjs

@@ -47,6 +47,8 @@ export const COMMANDS = {
   '/agents':      'List available agents',
   '/subagents':   'Alias of /agents (list/create/edit/sync sub-agents)',
   '/skills':      'List / install / view / remove skills (SKILL.md bundles)',
+  '/plugins':     'List / install / info / update / remove plugins (tools + agents + views)',
+  '/plugin':      'Alias of /plugins',
   '/run':         'Run a sub-agent or synced workflow',
   '/explore':     'Code explorer agent',
   '/review':      'Code review agent',
@@ -141,7 +143,7 @@ export const HELP_GROUPS = [
       ['/agents', 'List built-in and local agents'],
       ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
       ['/agents edit <name>', 'Open local agent YAML'],
-      ['/agents sync [name]', 'Sync all or one local agent to cloud'],
+      ['/agents sync [name]', 'Publish local agents to backend/account reuse'],
       ['/run <agent> [instruction]', 'Run a local or built-in agent'],
       ['/explore <instruction>', 'Explore code'],
       ['/review <instruction>', 'Review code'],
@@ -162,6 +164,22 @@ export const HELP_GROUPS = [
       ['/skills update <name>', 'Reinstall from the recorded source'],
     ],
   },
+  {
+    key: 'plugins',
+    title: 'Plugins',
+    summary: 'community-authored tools, agents, and workspace views',
+    commands: [
+      ['/plugins', 'List installed plugins'],
+      ['/plugins install <git-url|path|name>', 'Install from git URL, local path, or awesome-bahulam-plugins name'],
+      ['/plugins install <src> --project', 'Install into .bahulam/plugins (project scope)'],
+      ['/plugins install <src> --ref <tag>', 'Pin a git ref'],
+      ['/plugins validate <path|name>', 'Preflight a plugin without installing (schema + handlers + collisions)'],
+      ['/plugins info <name>', 'Show manifest details + install origin'],
+      ['/plugins enable|disable <name>', 'Toggle without deleting'],
+      ['/plugins update <name>', 'Pull the latest for git-installed plugins'],
+      ['/plugins remove <name>', 'Uninstall a plugin'],
+    ],
+  },
   {
     key: 'workflows',
     title: 'Workflows',

package/src/ui/sub-agent.mjs

@@ -70,11 +70,12 @@ export function displayQuery(query, max = 140) {
 
 export function renderSubAgentOpen({ id, type, query, parentDepth } = {}) {
   const t = type || 'sub-agent';
-  const depthBefore = _stack.length;
-  _stack.push({ id: id || `${t}-${depthBefore}-${tag()}`, type: t, startedAt: Date.now() });
+  const depthBefore = Number.isFinite(parentDepth) ? Math.max(0, parentDepth) : _stack.length;
+  _stack.push({ id: id || `${t}-${depthBefore}-${tag()}`, type: t, depth: depthBefore, startedAt: Date.now() });
 
   const indent = ' '.repeat(2 + depthBefore * 3);
-  const iconChar = SUB_ICONS[t] || icons.subAgent;
+  // Ordinal labels (explore#2) still get their base type's icon.
+  const iconChar = SUB_ICONS[t] || SUB_ICONS[String(t).replace(/#\d+$/, '')] || icons.subAgent;
   const shown = displayQuery(query);
   const head = `${indent}${iconChar} ${paint.brand.data(t)} ${paint.text.dim(`"${shown}"`)}`;
   const tag1 = paint.text.dim('▸ running');
@@ -95,6 +96,7 @@ export function renderSubAgentOpen({ id, type, query, parentDepth } = {}) {
  * and any of `{ costUsd, tokens, durationS, toolCalls, iterations }`.
  */
 export function renderSubAgentClose({
+  id,
   type,
   success = true,
   summary = '',
@@ -105,12 +107,16 @@ export function renderSubAgentClose({
   iterations,
   error,
 } = {}) {
-  // Match-pop: if the type doesn't match the top of stack we still pop the
-  // top entry — backends never emit interleaved open/close, so this is the
-  // safe behavior.
-  const opened = _stack.pop();
+  // Parallel sub-agents can complete out of stack order. Prefer exact id,
+  // then type, and fall back to the latest open entry for legacy streams.
+  let idx = -1;
+  if (id) idx = _stack.findLastIndex(entry => entry.id === id);
+  if (idx < 0 && type) idx = _stack.findLastIndex(entry => entry.type === type);
+  if (idx < 0) idx = _stack.length - 1;
+  const opened = idx >= 0 ? _stack.splice(idx, 1)[0] : null;
   const t = type || opened?.type || 'sub-agent';
-  const indent = ' '.repeat(2 + _stack.length * 3);
+  const closeDepth = Number.isFinite(opened?.depth) ? opened.depth : _stack.length;
+  const indent = ' '.repeat(2 + closeDepth * 3);
 
   if (!success) {
     const line = `${indent}${paint.text.dim('└')} ${paint.state.danger('✗')} ${paint.text.dim(`${t} agent failed`)}`;