agentbnb 7.0.0 → 8.2.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agentbnb",
   "name": "AgentBnB",
   "description": "Where AI agents hire AI agents — join the network, hire agent specialists, earn credits, and coordinate with peers. Agents run autonomously on their own will.",
-  "version": "7.0.0",
+  "version": "8.2.0",
   "kind": "tools",
   "configSchema": {
     "type": "object",

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "7.0.0",
+  "version": "8.2.0",
   "description": "P2P Agent Capability Sharing Protocol — Airbnb for AI agent pipelines",
   "type": "module",
   "main": "dist/index.js",

package/skills/agentbnb/bootstrap.test.ts

@@ -55,7 +55,8 @@ vi.mock('../../src/registry/store.js', () => ({
 
 import { loadConfig } from '../../src/cli/config.js';
 import { activate, deactivate } from './bootstrap.js';
-import type { BootstrapContext } from './bootstrap.js';
+import bootstrapDefault from './bootstrap.js';
+import type { BootstrapContext, OnboardDeps } from './bootstrap.js';
 
 const mockLoadConfig = vi.mocked(loadConfig);
 
@@ -104,16 +105,71 @@ describe('bootstrap activate/deactivate lifecycle', () => {
   });
 
   // ---------------------------------------------------------------------------
-  // Test 1: CONFIG_NOT_FOUND when no config exists
+  // Test 1: INIT_FAILED when CLI not found and config missing
   // ---------------------------------------------------------------------------
-  it('activate() throws CONFIG_NOT_FOUND when config is missing', async () => {
+  it('activate() throws INIT_FAILED when CLI not found and config missing', async () => {
     mockLoadConfig.mockReturnValue(null);
+    const deps: OnboardDeps = {
+      findCli: () => null,
+      runCommand: vi.fn(),
+    };
 
-    await expect(activate()).rejects.toMatchObject({
-      code: 'CONFIG_NOT_FOUND',
+    await expect(activate({}, deps)).rejects.toMatchObject({
+      code: 'INIT_FAILED',
     });
   });
 
+  // ---------------------------------------------------------------------------
+  // Test 1b: Auto-onboard runs init + openclaw sync when config missing
+  // ---------------------------------------------------------------------------
+  it('activate() auto-onboards when config missing and CLI available', async () => {
+    mockLoadConfig.mockReturnValueOnce(null).mockReturnValue(MINIMAL_CONFIG as ReturnType<typeof loadConfig>);
+    const mockRun = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+    const deps: OnboardDeps = {
+      findCli: () => '/usr/local/bin/agentbnb',
+      runCommand: mockRun,
+    };
+
+    ctx = await activate({}, deps);
+
+    expect(mockRun).toHaveBeenCalledTimes(2);
+    expect(mockRun.mock.calls[0][0]).toMatch(/agentbnb init --owner .* --yes --no-detect/);
+    expect(mockRun.mock.calls[1][0]).toBe('agentbnb openclaw sync');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 1c: Auto-onboard continues if openclaw sync fails
+  // ---------------------------------------------------------------------------
+  it('activate() continues if openclaw sync fails during auto-onboard', async () => {
+    mockLoadConfig.mockReturnValueOnce(null).mockReturnValue(MINIMAL_CONFIG as ReturnType<typeof loadConfig>);
+    const mockRun = vi.fn()
+      .mockResolvedValueOnce({ stdout: '', stderr: '' })
+      .mockRejectedValueOnce(new Error('SOUL.md not found'));
+    const deps: OnboardDeps = {
+      findCli: () => '/usr/local/bin/agentbnb',
+      runCommand: mockRun,
+    };
+
+    ctx = await activate({}, deps);
+
+    expect(ctx.startDisposition).toBe('started');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 1d: Skips auto-onboard when config already exists
+  // ---------------------------------------------------------------------------
+  it('activate() skips auto-onboard when config already exists', async () => {
+    const mockRun = vi.fn();
+    const deps: OnboardDeps = {
+      findCli: () => '/usr/local/bin/agentbnb',
+      runCommand: mockRun,
+    };
+
+    ctx = await activate({}, deps);
+
+    expect(mockRun).not.toHaveBeenCalled();
+  });
+
   // ---------------------------------------------------------------------------
   // Test 2: BootstrapContext shape
   // ---------------------------------------------------------------------------
@@ -230,3 +286,36 @@ describe('bootstrap activate/deactivate lifecycle', () => {
     expect(process.listenerCount('SIGTERM')).toBeLessThan(sigtermAfterActivate);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Default export (OpenClaw plugin definition)
+// ---------------------------------------------------------------------------
+
+describe('bootstrap default export (OpenClaw plugin definition)', () => {
+  it('has id, name, description, and register', () => {
+    expect(bootstrapDefault).toHaveProperty('id', 'agentbnb');
+    expect(bootstrapDefault).toHaveProperty('name', 'AgentBnB');
+    expect(bootstrapDefault).toHaveProperty('description');
+    expect(typeof bootstrapDefault.description).toBe('string');
+    expect(bootstrapDefault).toHaveProperty('register');
+    expect(typeof bootstrapDefault.register).toBe('function');
+  });
+
+  it('register() calls api.registerTool with a factory', () => {
+    const mockRegisterTool = vi.fn();
+    bootstrapDefault.register({ registerTool: mockRegisterTool });
+    expect(mockRegisterTool).toHaveBeenCalledTimes(1);
+    expect(typeof mockRegisterTool.mock.calls[0][0]).toBe('function');
+  });
+
+  it('factory returns 5 tools', () => {
+    let factory: ((ctx: { workspaceDir?: string; agentDir?: string }) => unknown[]) | undefined;
+    const mockRegisterTool = vi.fn((fn: typeof factory) => { factory = fn; });
+    bootstrapDefault.register({ registerTool: mockRegisterTool });
+
+    // Call the factory with a mock context — it will fail on config read,
+    // so we mock createAllTools indirectly by checking the factory is callable
+    expect(factory).toBeDefined();
+    expect(typeof factory).toBe('function');
+  });
+});

package/skills/agentbnb/bootstrap.ts

@@ -8,12 +8,15 @@
  * Teardown: `await deactivate(ctx);`
  */
 
-import { join } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { spawnSync } from 'node:child_process';
+import { spawnSync, exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import { randomUUID } from 'node:crypto';
 
+const execAsync = promisify(exec);
+
 /**
  * Derives a workspace-specific AGENTBNB_DIR using a priority chain:
  *
@@ -170,6 +173,109 @@ function registerDecomposerCard(configDir: string, owner: string): void {
   }
 }
 
+/**
+ * Checks if the `agentbnb` CLI is available in PATH.
+ * @returns Absolute path to the CLI, or null if not found.
+ */
+export function findCli(): string | null {
+  const result = spawnSync('which', ['agentbnb'], { encoding: 'utf-8', stdio: 'pipe' });
+  if (result.status === 0 && result.stdout.trim()) {
+    return result.stdout.trim();
+  }
+  return null;
+}
+
+/**
+ * Runs a shell command asynchronously. Exported for test injection.
+ */
+export async function runCommand(cmd: string, env: Record<string, string | undefined>): Promise<{ stdout: string; stderr: string }> {
+  return execAsync(cmd, { env });
+}
+
+/**
+ * Derives a human-readable agent name from the config directory path.
+ * If configDir is `~/.openclaw/agents/genesis-bot/.agentbnb`, returns "genesis-bot".
+ * Falls back to a random identifier.
+ */
+function deriveAgentName(configDir: string): string {
+  // configDir is typically <workspace>/.agentbnb — parent dir is the agent workspace
+  const parent = basename(dirname(configDir));
+  if (parent && parent !== '.' && parent !== '.agentbnb' && parent !== homedir().split('/').pop()) {
+    return parent;
+  }
+  return `agent-${randomUUID().slice(0, 8)}`;
+}
+
+/**
+ * First-time auto-onboarding: initializes identity, publishes capabilities, and
+ * grants the Demand Voucher (50 credits). Called when activate() detects no config.json.
+ *
+ * Steps:
+ * 1. Check agentbnb CLI is available
+ * 2. Run `agentbnb init --owner <name> --yes --no-detect` (keypair + config)
+ * 3. Run `agentbnb openclaw sync` (publish SOUL.md capabilities)
+ * 4. Demand Voucher is auto-issued by the registry on first registration
+ *
+ * @param configDir - The AGENTBNB_DIR for this agent.
+ * @returns The loaded AgentBnBConfig after init.
+ * @throws {AgentBnBError} INIT_FAILED if CLI not found or init fails.
+ */
+/** Injectable dependencies for autoOnboard (test seam). */
+export interface OnboardDeps {
+  findCli: () => string | null;
+  runCommand: (cmd: string, env: Record<string, string | undefined>) => Promise<{ stdout: string; stderr: string }>;
+}
+
+/** Default production dependencies. */
+const defaultDeps: OnboardDeps = { findCli, runCommand };
+
+async function autoOnboard(configDir: string, deps: OnboardDeps = defaultDeps): Promise<import('./../../src/cli/config.js').AgentBnBConfig> {
+  process.stderr.write('[agentbnb] First-time setup: initializing agent identity...\n');
+
+  // Step 0: Check CLI exists
+  const cliPath = deps.findCli();
+  if (!cliPath) {
+    process.stderr.write('[agentbnb] CLI not found. Run: npm install -g agentbnb\n');
+    throw new AgentBnBError(
+      'agentbnb CLI not found in PATH. Install with: npm install -g agentbnb',
+      'INIT_FAILED',
+    );
+  }
+
+  const env = { ...process.env, AGENTBNB_DIR: configDir };
+  const agentName = deriveAgentName(configDir);
+
+  // Step 1: Initialize identity (keypair + config.json + credit bootstrap)
+  try {
+    await deps.runCommand(`agentbnb init --owner "${agentName}" --yes --no-detect`, env);
+    process.stderr.write(`[agentbnb] Agent "${agentName}" initialized.\n`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new AgentBnBError(`Auto-init failed: ${msg}`, 'INIT_FAILED');
+  }
+
+  // Step 2: Publish capabilities from SOUL.md (if it exists)
+  try {
+    await deps.runCommand('agentbnb openclaw sync', env);
+    process.stderr.write('[agentbnb] Capabilities published from SOUL.md.\n');
+  } catch {
+    // Non-fatal: SOUL.md may not exist yet, or sync may fail for other reasons.
+    // Agent is still initialized and can publish capabilities later.
+    process.stderr.write('[agentbnb] Note: openclaw sync skipped (SOUL.md may not exist yet).\n');
+  }
+
+  // Step 3: Demand Voucher (50 credits) is auto-issued by bootstrapAgent() during init.
+  // No action needed here.
+
+  const config = loadConfig();
+  if (!config) {
+    throw new AgentBnBError('AgentBnB config still not found after auto-init', 'CONFIG_NOT_FOUND');
+  }
+
+  process.stderr.write('[agentbnb] Agent initialized and published to AgentBnB network.\n');
+  return config;
+}
+
 /**
  * Brings an AgentBnB node online (idempotent — safe to call when already running).
  * Registers SIGTERM/SIGINT handlers that conditionally stop the node on process exit.
@@ -179,7 +285,7 @@ function registerDecomposerCard(configDir: string, owner: string): void {
  * TODO: Once ServiceCoordinator gains its own signal handling, remove the handlers
  * registered here to avoid double-handler conflicts. Track in Layer A implementation.
  */
-export async function activate(config: BootstrapConfig = {}): Promise<BootstrapContext> {
+export async function activate(config: BootstrapConfig = {}, _onboardDeps?: OnboardDeps): Promise<BootstrapContext> {
   // Per-workspace isolation: determine the correct config directory.
   // Priority: config.agentDir > config.workspaceDir/.agentbnb > AGENTBNB_DIR env > resolveWorkspaceDir()
   if (config.agentDir) {
@@ -211,20 +317,8 @@ export async function activate(config: BootstrapConfig = {}): Promise<BootstrapC
 
   let agentConfig = loadConfig();
   if (!agentConfig) {
-    // Auto-init for first-time OpenClaw plugin activation
-    const result = spawnSync('agentbnb', ['init', '--yes', '--no-detect'], {
-      stdio: 'pipe',
-      env: { ...process.env },
-      encoding: 'utf-8',
-    });
-    if (result.error || result.status !== 0) {
-      const msg = result.error?.message ?? (result.stderr as string | null)?.trim() ?? 'agentbnb init failed';
-      throw new AgentBnBError(`Auto-init failed: ${msg}`, 'INIT_FAILED');
-    }
-    agentConfig = loadConfig();
-    if (!agentConfig) {
-      throw new AgentBnBError('AgentBnB config still not found after auto-init', 'CONFIG_NOT_FOUND');
-    }
+    // First-time setup: auto-onboard this agent onto the AgentBnB network.
+    agentConfig = await autoOnboard(configDir, _onboardDeps);
   }
 
   // Print startup diagnostic so it's always visible in agent logs.
@@ -293,3 +387,31 @@ export async function deactivate(ctx: BootstrapContext): Promise<void> {
     }
   }
 }
+
+// ---------------------------------------------------------------------------
+// OpenClaw Plugin Definition — default export
+// ---------------------------------------------------------------------------
+
+import { createAllTools, resetContextCache } from './openclaw-tools.js';
+import type { AgentTool } from './openclaw-tools.js';
+
+/**
+ * OpenClaw plugin definition. When OpenClaw loads this plugin, `register()`
+ * is called to register the AgentBnB tools with the bot's LLM.
+ *
+ * The existing named exports (activate, deactivate, findCli, runCommand)
+ * remain unchanged — they handle the node lifecycle. This default export
+ * adds tool registration so the LLM can discover, hire, and orchestrate agents.
+ */
+export default {
+  id: 'agentbnb',
+  name: 'AgentBnB',
+  description:
+    'Where AI agents hire AI agents — discover, request, and orchestrate agent capabilities.',
+
+  register(api: { registerTool: (factory: (toolCtx: { workspaceDir?: string; agentDir?: string }) => AgentTool[]) => void }) {
+    api.registerTool(
+      (toolCtx: { workspaceDir?: string; agentDir?: string }) => createAllTools(toolCtx),
+    );
+  },
+};

package/skills/agentbnb/openclaw-tools.test.ts

@@ -0,0 +1,328 @@
+/**
+ * Unit tests for openclaw-tools.ts — OpenClaw tool factory.
+ *
+ * Tests verify:
+ *   - Tool factory returns 5 tools with correct shape
+ *   - Tool names are kebab-case with agentbnb- prefix
+ *   - Parameter schemas are valid JSON Schema
+ *   - Result conversion from MCP format to AgentToolResult
+ *   - Context caching and multi-agent isolation
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  createAllTools,
+  createDiscoverTool,
+  createRequestTool,
+  createConductTool,
+  createStatusTool,
+  createPublishTool,
+  toAgentToolResult,
+  buildMcpContext,
+  resolveConfigDir,
+  resetContextCache,
+} from './openclaw-tools.js';
+import type { AgentTool, OpenClawToolContext } from './openclaw-tools.js';
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+vi.mock('../../src/identity/identity.js', () => ({
+  ensureIdentity: vi.fn((_dir: string, owner: string) => ({
+    agent_id: 'mock-agent-id',
+    owner,
+    public_key: 'deadbeef'.repeat(8),
+    created_at: '2026-01-01T00:00:00.000Z',
+  })),
+}));
+
+vi.mock('../../src/mcp/tools/discover.js', () => ({
+  handleDiscover: vi.fn(async () => ({
+    content: [{ type: 'text', text: JSON.stringify({ results: [], count: 0 }) }],
+  })),
+}));
+
+vi.mock('../../src/mcp/tools/request.js', () => ({
+  handleRequest: vi.fn(async () => ({
+    content: [{ type: 'text', text: JSON.stringify({ success: true }) }],
+  })),
+}));
+
+vi.mock('../../src/mcp/tools/conduct.js', () => ({
+  handleConduct: vi.fn(async () => ({
+    content: [{ type: 'text', text: JSON.stringify({ success: true, plan: [] }) }],
+  })),
+}));
+
+vi.mock('../../src/mcp/tools/status.js', () => ({
+  handleStatus: vi.fn(async () => ({
+    content: [{ type: 'text', text: JSON.stringify({ agent_id: 'mock', balance: 50 }) }],
+  })),
+}));
+
+vi.mock('../../src/mcp/tools/publish.js', () => ({
+  handlePublish: vi.fn(async () => ({
+    content: [{ type: 'text', text: JSON.stringify({ success: true, card_id: 'abc' }) }],
+  })),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Creates a temp dir ending with `.agentbnb` containing config.json.
+ * resolveConfigDir() uses the dir as-is when it ends with `.agentbnb`.
+ */
+function createTempConfigDir(): string {
+  const parent = mkdtempSync(join(tmpdir(), 'agentbnb-test-'));
+  const configDir = join(parent, '.agentbnb');
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(
+    join(configDir, 'config.json'),
+    JSON.stringify({
+      owner: 'test-agent',
+      gateway_url: 'http://localhost:7700',
+      gateway_port: 7700,
+      db_path: ':memory:',
+      credit_db_path: ':memory:',
+      token: 'test-token',
+      registry: 'https://hub.agentbnb.dev',
+    }),
+  );
+  return configDir;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('openclaw-tools', () => {
+  beforeEach(() => {
+    resetContextCache();
+  });
+
+  afterEach(() => {
+    resetContextCache();
+  });
+
+  // -------------------------------------------------------------------------
+  // 1. Tool factory shape
+  // -------------------------------------------------------------------------
+  describe('createAllTools()', () => {
+    it('returns array of 5 tools', () => {
+      const configDir = createTempConfigDir();
+      const tools = createAllTools({ agentDir: configDir });
+      expect(tools).toHaveLength(5);
+    });
+
+    it('each tool has required properties', () => {
+      const configDir = createTempConfigDir();
+      const tools = createAllTools({ agentDir: configDir });
+      for (const tool of tools) {
+        expect(tool).toHaveProperty('name');
+        expect(tool).toHaveProperty('label');
+        expect(tool).toHaveProperty('description');
+        expect(tool).toHaveProperty('parameters');
+        expect(tool).toHaveProperty('execute');
+        expect(typeof tool.name).toBe('string');
+        expect(typeof tool.label).toBe('string');
+        expect(typeof tool.description).toBe('string');
+        expect(typeof tool.parameters).toBe('object');
+        expect(typeof tool.execute).toBe('function');
+      }
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 2. Tool names — kebab-case with agentbnb- prefix
+  // -------------------------------------------------------------------------
+  describe('tool names', () => {
+    it('all names follow agentbnb-<action> pattern', () => {
+      const configDir = createTempConfigDir();
+      const tools = createAllTools({ agentDir: configDir });
+      const names = tools.map((t) => t.name);
+
+      expect(names).toEqual([
+        'agentbnb-discover',
+        'agentbnb-request',
+        'agentbnb-conduct',
+        'agentbnb-status',
+        'agentbnb-publish',
+      ]);
+
+      for (const name of names) {
+        expect(name).toMatch(/^agentbnb-[a-z]+$/);
+      }
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 3. Parameter schemas
+  // -------------------------------------------------------------------------
+  describe('parameter schemas', () => {
+    it('discover requires query', () => {
+      const configDir = createTempConfigDir();
+      const tool = createDiscoverTool({ agentDir: configDir });
+      const schema = tool.parameters as { required: string[]; properties: Record<string, unknown> };
+      expect(schema.required).toContain('query');
+      expect(schema.properties).toHaveProperty('query');
+      expect(schema.properties).toHaveProperty('level');
+      expect(schema.properties).toHaveProperty('online_only');
+    });
+
+    it('request has no required fields', () => {
+      const configDir = createTempConfigDir();
+      const tool = createRequestTool({ agentDir: configDir });
+      const schema = tool.parameters as { required: string[] };
+      expect(schema.required).toEqual([]);
+    });
+
+    it('conduct requires task', () => {
+      const configDir = createTempConfigDir();
+      const tool = createConductTool({ agentDir: configDir });
+      const schema = tool.parameters as { required: string[] };
+      expect(schema.required).toContain('task');
+    });
+
+    it('status has no required fields', () => {
+      const configDir = createTempConfigDir();
+      const tool = createStatusTool({ agentDir: configDir });
+      const schema = tool.parameters as { required: string[]; properties: Record<string, unknown> };
+      expect(schema.required).toEqual([]);
+      expect(Object.keys(schema.properties)).toHaveLength(0);
+    });
+
+    it('publish requires card_json', () => {
+      const configDir = createTempConfigDir();
+      const tool = createPublishTool({ agentDir: configDir });
+      const schema = tool.parameters as { required: string[] };
+      expect(schema.required).toContain('card_json');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 4. Result conversion
+  // -------------------------------------------------------------------------
+  describe('toAgentToolResult()', () => {
+    it('converts MCP format to AgentToolResult with parsed details', () => {
+      const mcpResult = {
+        content: [{ type: 'text' as const, text: '{"results":[],"count":0}' }],
+      };
+      const result = toAgentToolResult(mcpResult);
+      expect(result.content).toBe('{"results":[],"count":0}');
+      expect(result.details).toEqual({ results: [], count: 0 });
+    });
+
+    it('handles non-JSON text gracefully', () => {
+      const mcpResult = {
+        content: [{ type: 'text' as const, text: 'not json' }],
+      };
+      const result = toAgentToolResult(mcpResult);
+      expect(result.content).toBe('not json');
+      expect(result.details).toBeUndefined();
+    });
+
+    it('handles empty content array', () => {
+      const mcpResult = { content: [] as Array<{ type: string; text: string }> };
+      const result = toAgentToolResult(mcpResult);
+      expect(result.content).toBe('{}');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 5. Context caching
+  // -------------------------------------------------------------------------
+  describe('context caching', () => {
+    it('same configDir reuses cached context', () => {
+      const configDir = createTempConfigDir();
+      const ctx1 = buildMcpContext({ agentDir: configDir });
+      const ctx2 = buildMcpContext({ agentDir: configDir });
+      expect(ctx1).toBe(ctx2); // same reference
+    });
+
+    it('resetContextCache() clears the cache', () => {
+      const configDir = createTempConfigDir();
+      const ctx1 = buildMcpContext({ agentDir: configDir });
+      resetContextCache();
+      const ctx2 = buildMcpContext({ agentDir: configDir });
+      expect(ctx1).not.toBe(ctx2); // different reference
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 6. Multi-agent isolation
+  // -------------------------------------------------------------------------
+  describe('multi-agent isolation', () => {
+    it('different workspaceDir values produce different contexts', () => {
+      const dir1 = createTempConfigDir();
+      const dir2 = createTempConfigDir();
+
+      const ctx1 = buildMcpContext({ agentDir: dir1 });
+      const ctx2 = buildMcpContext({ agentDir: dir2 });
+
+      expect(ctx1).not.toBe(ctx2);
+      expect(ctx1.configDir).not.toBe(ctx2.configDir);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 7. resolveConfigDir
+  // -------------------------------------------------------------------------
+  describe('resolveConfigDir()', () => {
+    it('uses agentDir directly if it ends with .agentbnb', () => {
+      const dir = resolveConfigDir({ agentDir: '/tmp/test/.agentbnb' });
+      expect(dir).toBe('/tmp/test/.agentbnb');
+    });
+
+    it('appends .agentbnb to agentDir if it does not end with .agentbnb', () => {
+      const dir = resolveConfigDir({ agentDir: '/tmp/test-agent' });
+      expect(dir).toBe('/tmp/test-agent/.agentbnb');
+    });
+
+    it('derives from workspaceDir when agentDir is not set', () => {
+      const dir = resolveConfigDir({ workspaceDir: '/tmp/workspace' });
+      expect(dir).toBe('/tmp/workspace/.agentbnb');
+    });
+
+    it('falls back to ~/.agentbnb when neither is set', () => {
+      const dir = resolveConfigDir({});
+      expect(dir).toMatch(/\.agentbnb$/);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 8. buildMcpContext error on missing config
+  // -------------------------------------------------------------------------
+  describe('buildMcpContext()', () => {
+    it('throws when config.json does not exist', () => {
+      const dir = mkdtempSync(join(tmpdir(), 'agentbnb-noconfig-'));
+      expect(() => buildMcpContext({ agentDir: dir })).toThrow(/not initialized/);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // 9. Tool execution delegates to MCP handlers
+  // -------------------------------------------------------------------------
+  describe('tool execution', () => {
+    it('discover tool delegates to handleDiscover', async () => {
+      const configDir = createTempConfigDir();
+      const tool = createDiscoverTool({ agentDir: configDir });
+      const result = await tool.execute('call-1', { query: 'stock analysis' });
+      expect(result.content).toBeTruthy();
+      expect(result.details).toEqual({ results: [], count: 0 });
+    });
+
+    it('status tool delegates to handleStatus', async () => {
+      const configDir = createTempConfigDir();
+      const tool = createStatusTool({ agentDir: configDir });
+      const result = await tool.execute('call-2', {});
+      expect(result.details).toEqual({ agent_id: 'mock', balance: 50 });
+    });
+  });
+});