agentbnb 4.0.0 → 4.0.2

package/skills/agentbnb/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: agentbnb
+description: "P2P capability sharing for AI agents — earn credits by sharing idle APIs, spend credits to request capabilities from peer agents. Use when an agent needs to join the AgentBnB network, publish capability cards, manage credits, or request skills from peers."
+license: MIT
+compatibility: "Requires Node.js >= 20 and pnpm. Designed for OpenClaw agents. Compatible with Claude Code, Gemini CLI, and other AgentSkills-compatible tools."
+on_install: auto
+metadata:
+  author: "Cheng Wen Chen"
+  version: "3.0.0"
+  tags: "ai-agent-skill,claude-code,agent-skills,p2p,capability-sharing"
+---
+
+This skill connects your agent to the AgentBnB P2P capability sharing network.
+
+## Quick Start
+
+**Step 1: Run the install script.**
+
+```bash
+bash install.sh
+```
+
+This installs the AgentBnB CLI, initializes `~/.agentbnb/` config, and syncs your SOUL.md if present.
+
+**Step 2: Import `activate()` from `bootstrap.ts` and bring your agent online.**
+
+```typescript
+import { activate, deactivate } from './bootstrap.js';
+
+const ctx = await activate({
+  owner: 'your-agent-id',
+  soulMdPath: './SOUL.md',
+  registryDbPath: './registry.db',  // omit to use ~/.agentbnb/registry.db
+  creditDbPath: './credit.db',       // omit to use ~/.agentbnb/credit.db
+  gatewayPort: 7700,
+  gatewayToken: 'your-bearer-token', // omit to auto-generate
+  silent: false,
+});
+
+// ctx.runtime   — AgentRuntime (DB handles + background jobs)
+// ctx.gateway   — Fastify HTTP server on gatewayPort
+// ctx.idleMonitor — IdleMonitor polling on 60s cadence
+// ctx.card      — Published CapabilityCardV2 from SOUL.md
+```
+
+**Step 3: When done, call `deactivate()` to clean up all resources.**
+
+```typescript
+await deactivate(ctx);
+// Closes gateway, stops cron jobs, closes DB handles. Idempotent.
+```
+
+## On Install
+
+`install.sh` performs the following steps automatically:
+
+1. Checks Node.js >= 20 is available (exits with error if not).
+2. Checks pnpm is available; falls back to npm if not.
+3. Runs `pnpm install -g agentbnb` (or `npm install -g agentbnb`).
+4. Runs `agentbnb init --yes` to create `~/.agentbnb/` with default config.
+5. Runs `agentbnb openclaw sync` if SOUL.md is found in the current or parent directory.
+6. Prints a success summary with next steps.
+
+## Programmatic API
+
+Use `activate()` and `deactivate()` from `bootstrap.ts` for full lifecycle control.
+
+### `activate(config: BootstrapConfig): Promise<BootstrapContext>`
+
+Brings an agent fully online in order: Runtime → publishCard → gateway.listen → IdleMonitor.
+
+**BootstrapConfig fields:**
+
+| Field | Type | Default | Purpose |
+|---|---|---|---|
+| `owner` | `string` | required | Agent owner identifier |
+| `soulMdPath` | `string` | required | Absolute path to SOUL.md |
+| `registryDbPath` | `string` | `~/.agentbnb/registry.db` | Registry SQLite path |
+| `creditDbPath` | `string` | `~/.agentbnb/credit.db` | Credit SQLite path |
+| `gatewayPort` | `number` | `7700` | HTTP port for incoming capability requests |
+| `gatewayToken` | `string` | auto `randomUUID()` | Bearer token for gateway auth |
+| `handlerUrl` | `string` | `http://localhost:{gatewayPort}` | URL for capability forwarding |
+| `autonomyConfig` | `AutonomyConfig` | `DEFAULT_AUTONOMY_CONFIG` (Tier 3) | Tier thresholds |
+| `silent` | `boolean` | `false` | Suppress gateway logs |
+
+Throws `AgentBnBError` with code `FILE_NOT_FOUND` if `soulMdPath` does not exist.
+
+**BootstrapContext fields:**
+
+| Field | Type | Description |
+|---|---|---|
+| `runtime` | `AgentRuntime` | DB handles + background job registry |
+| `gateway` | `FastifyInstance` | HTTP gateway accepting capability requests |
+| `idleMonitor` | `IdleMonitor` | Cron job monitoring idle rates every 60s |
+| `card` | `CapabilityCardV2` | Published card derived from SOUL.md |
+
+### `deactivate(ctx: BootstrapContext): Promise<void>`
+
+Tears down all active components: `gateway.close()` then `runtime.shutdown()`.
+Idempotent — safe to call multiple times without throwing.
+
+## Autonomy Rules
+
+Full rules block is in `HEARTBEAT.rules.md`. Copy into your `HEARTBEAT.md`, or run:
+
+```bash
+agentbnb openclaw rules
+```
+
+This outputs a rules block using your actual configured thresholds (not the example defaults).
+
+**Summary of the 3 tiers:**
+
+- **Tier 1** (< tier1 credits): Auto-execute, no notification.
+- **Tier 2** (tier1–tier2 credits): Execute and notify owner after.
+- **Tier 3** (> tier2 credits): Ask owner before executing. (Default on fresh installs.)
+
+**Reserve floor:** Maintain a minimum credit balance (default 20). When balance ≤ reserve, auto-request is blocked. Increase sharing priority to recover.
+
+**Idle sharing:** When a skill's `idle_rate` exceeds 70%, `IdleMonitor` auto-shares it according to the active tier.
+
+Configure thresholds:
+
+```bash
+agentbnb config set tier1 10    # auto-execute under 10 credits
+agentbnb config set tier2 50    # notify-after under 50 credits
+agentbnb config set reserve 20  # keep 20 credit reserve
+```
+
+## CLI Reference
+
+```bash
+agentbnb serve                    # Start accepting incoming capability requests
+agentbnb openclaw sync            # Parse SOUL.md and publish capability card to registry
+agentbnb openclaw status          # Show sync state, credit balance, idle rates
+agentbnb openclaw rules           # Emit HEARTBEAT.md rules block with real thresholds
+agentbnb config set tier1 <N>     # Set Tier 1 credit threshold
+agentbnb config set tier2 <N>     # Set Tier 2 credit threshold
+agentbnb config set reserve <N>   # Set minimum credit reserve floor
+agentbnb discover                 # Find peers on the local network via mDNS
+agentbnb request --query "..."    # Manually request a capability from the network
+```
+
+## Adapters
+
+Use individual adapters if you need custom wiring. `bootstrap.ts` composes all of these.
+
+| Adapter | Export | Purpose |
+|---|---|---|
+| `gateway.ts` | `AgentRuntime`, `createGatewayServer` | HTTP gateway for receiving requests |
+| `auto-share.ts` | `IdleMonitor` | Per-skill idle rate polling + auto-share |
+| `auto-request.ts` | `AutoRequestor` | Peer scoring + budget-gated capability requests |
+| `credit-mgr.ts` | `BudgetManager`, `getBalance` | Credit reserve floor + balance queries |
+
+```typescript
+// Example: use IdleMonitor directly without full bootstrap
+import { IdleMonitor } from './auto-share.js';
+
+const monitor = new IdleMonitor({
+  owner: 'my-agent',
+  db: runtime.registryDb,
+  autonomyConfig: config.autonomy,
+});
+const job = monitor.start();
+runtime.registerJob(job);
+```

package/skills/agentbnb/auto-request.ts

@@ -0,0 +1,14 @@
+/**
+ * AgentBnB Auto-Request adapter for OpenClaw skill integration.
+ * Delegates to AutoRequestor from src/autonomy/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { AutoRequestor } from '../../src/autonomy/auto-request.js';
+import type {
+  AutoRequestOptions,
+  CapabilityNeed,
+  AutoRequestResult,
+} from '../../src/autonomy/auto-request.js';
+
+export { AutoRequestor };
+export type { AutoRequestOptions, CapabilityNeed, AutoRequestResult };

package/skills/agentbnb/auto-share.ts

@@ -0,0 +1,10 @@
+/**
+ * AgentBnB Auto-Share adapter for OpenClaw skill integration.
+ * Delegates to IdleMonitor from src/autonomy/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { IdleMonitor } from '../../src/autonomy/idle-monitor.js';
+import type { IdleMonitorOptions } from '../../src/autonomy/idle-monitor.js';
+
+export { IdleMonitor };
+export type { IdleMonitorOptions };

package/skills/agentbnb/bootstrap.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Integration test for bootstrap.ts activate()/deactivate() lifecycle.
+ *
+ * Tests the full lifecycle using real implementations with in-memory DBs:
+ *   activate() -> runtime + card published + gateway listening + IdleMonitor running
+ *   deactivate() -> gateway closed + runtime shutdown + resources cleaned up
+ *
+ * No mocks — this is an end-to-end integration test.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { activate, deactivate } from './bootstrap.js';
+import type { BootstrapContext } from './bootstrap.js';
+import { IdleMonitor } from '../../src/autonomy/idle-monitor.js';
+import { loadIdentity } from '../../src/identity/identity.js';
+
+// ---------------------------------------------------------------------------
+// Test fixture: minimal SOUL.md with 2 skills
+// ---------------------------------------------------------------------------
+const SOUL_MD_CONTENT = `# Test Agent
+
+A test agent for integration testing.
+
+## Code Review
+Reviews code for quality and bugs.
+
+## Translation
+Translates text between languages.
+`;
+
+// ---------------------------------------------------------------------------
+// Test suite
+// ---------------------------------------------------------------------------
+
+describe('bootstrap activate/deactivate lifecycle', () => {
+  let tmpDir: string | undefined;
+  let ctx: BootstrapContext | undefined;
+
+  /**
+   * Create a fresh temp dir with a SOUL.md file.
+   * Returns the absolute path to the SOUL.md file.
+   */
+  function setupSoulMd(): string {
+    tmpDir = mkdtempSync(join(tmpdir(), 'agentbnb-test-'));
+    const path = join(tmpDir, 'SOUL.md');
+    writeFileSync(path, SOUL_MD_CONTENT, 'utf8');
+    return path;
+  }
+
+  // Ensure all resources are torn down after every test
+  afterEach(async () => {
+    if (ctx) {
+      await deactivate(ctx).catch(() => undefined);
+      ctx = undefined;
+    }
+    if (tmpDir) {
+      rmSync(tmpDir, { recursive: true, force: true });
+      tmpDir = undefined;
+    }
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 1: activate() returns BootstrapContext with all components
+  // ---------------------------------------------------------------------------
+  it('activate() returns BootstrapContext with all components', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // runtime has both DB handles
+    expect(ctx.runtime).toBeDefined();
+    expect(ctx.runtime.registryDb).toBeDefined();
+    expect(ctx.runtime.creditDb).toBeDefined();
+
+    // gateway is a Fastify instance (has inject method)
+    expect(ctx.gateway).toBeDefined();
+    expect(typeof ctx.gateway.inject).toBe('function');
+
+    // idleMonitor is an IdleMonitor instance
+    expect(ctx.idleMonitor).toBeInstanceOf(IdleMonitor);
+
+    // card has correct structure: spec_version 2.0, 2 skills
+    expect(ctx.card.spec_version).toBe('2.0');
+    expect(Array.isArray(ctx.card.skills)).toBe(true);
+    expect(ctx.card.skills!.length).toBe(2);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 2: activate() publishes card from SOUL.md into registry
+  // ---------------------------------------------------------------------------
+  it('activate() publishes card from SOUL.md into registry', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Query the registry DB for capability_cards owned by this agent
+    const rows = ctx.runtime.registryDb
+      .prepare('SELECT id, owner, data FROM capability_cards WHERE owner = ?')
+      .all('test-agent') as Array<{ id: string; owner: string; data: string }>;
+
+    expect(rows.length).toBe(1);
+    expect(rows[0].owner).toBe('test-agent');
+
+    // Parse the card data and verify both skills are present
+    const cardData = JSON.parse(rows[0].data) as {
+      skills?: Array<{ name: string }>;
+    };
+    const skillNames = (cardData.skills ?? []).map((s) => s.name);
+    expect(skillNames).toContain('Code Review');
+    expect(skillNames).toContain('Translation');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 3: activate() starts gateway that responds to health check
+  // ---------------------------------------------------------------------------
+  it('activate() starts gateway that responds to health check', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Use Fastify inject — no real HTTP connection needed
+    const response = await ctx.gateway.inject({
+      method: 'GET',
+      url: '/health',
+    });
+
+    expect(response.statusCode).toBe(200);
+    const body = JSON.parse(response.body) as { status: string };
+    expect(body.status).toBe('ok');
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 4: activate() registers IdleMonitor job in runtime.jobs
+  // ---------------------------------------------------------------------------
+  it('activate() registers IdleMonitor job in runtime.jobs', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // At least one cron job registered (the IdleMonitor's polling job)
+    expect(ctx.runtime.jobs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 5: deactivate() sets runtime.isDraining to true
+  // ---------------------------------------------------------------------------
+  it('deactivate() sets runtime.isDraining to true', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    expect(ctx.runtime.isDraining).toBe(false);
+
+    await deactivate(ctx);
+    // Clear so afterEach doesn't double-deactivate
+    const savedCtx = ctx;
+    ctx = undefined;
+
+    expect(savedCtx.runtime.isDraining).toBe(true);
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 6: deactivate() closes DB handles
+  // ---------------------------------------------------------------------------
+  it('deactivate() closes DB handles', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    // Capture reference before clearing ctx
+    const runtime = ctx.runtime;
+    await deactivate(ctx);
+    ctx = undefined;
+
+    // Queries should throw after DB handles are closed
+    expect(() => {
+      runtime.registryDb.prepare('SELECT 1').get();
+    }).toThrow();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 7: deactivate() is idempotent
+  // ---------------------------------------------------------------------------
+  it('deactivate() is idempotent', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+    });
+
+    await deactivate(ctx);
+    // Second call must not throw
+    await expect(deactivate(ctx)).resolves.not.toThrow();
+
+    ctx = undefined;
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 8: activate() throws when SOUL.md does not exist
+  // ---------------------------------------------------------------------------
+  it('activate() throws when SOUL.md does not exist', async () => {
+    await expect(
+      activate({
+        owner: 'test-agent',
+        soulMdPath: '/nonexistent/path/SOUL.md',
+        registryDbPath: ':memory:',
+        creditDbPath: ':memory:',
+        gatewayPort: 0,
+        silent: true,
+      }),
+    ).rejects.toThrow();
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 9: activate() with identityRequired creates identity.json
+  // ---------------------------------------------------------------------------
+  it('activate() with identityRequired creates identity.json', async () => {
+    const soulMdPath = setupSoulMd();
+    const identityDir = mkdtempSync(join(tmpdir(), 'agentbnb-identity-'));
+
+    // Temporarily override HOME so identity writes to temp dir
+    const origHome = process.env['HOME'];
+    process.env['HOME'] = identityDir;
+
+    try {
+      ctx = await activate({
+        owner: 'identity-agent',
+        soulMdPath,
+        registryDbPath: ':memory:',
+        creditDbPath: ':memory:',
+        gatewayPort: 0,
+        silent: true,
+        identityRequired: true,
+      });
+
+      // identity should be populated
+      expect(ctx.identity).not.toBeNull();
+      expect(ctx.identity!.owner).toBe('identity-agent');
+      expect(ctx.identity!.agent_id).toBeTruthy();
+
+      // identity.json should exist on disk
+      const identityPath = join(identityDir, '.agentbnb', 'identity.json');
+      expect(existsSync(identityPath)).toBe(true);
+
+      const loaded = loadIdentity(join(identityDir, '.agentbnb'));
+      expect(loaded).not.toBeNull();
+      expect(loaded!.agent_id).toBe(ctx.identity!.agent_id);
+    } finally {
+      process.env['HOME'] = origHome;
+      rmSync(identityDir, { recursive: true, force: true });
+    }
+  });
+
+  // ---------------------------------------------------------------------------
+  // Test 10: activate() without identityRequired skips identity creation
+  // ---------------------------------------------------------------------------
+  it('activate() without identityRequired skips identity creation', async () => {
+    const soulMdPath = setupSoulMd();
+
+    ctx = await activate({
+      owner: 'test-agent',
+      soulMdPath,
+      registryDbPath: ':memory:',
+      creditDbPath: ':memory:',
+      gatewayPort: 0,
+      silent: true,
+      identityRequired: false,
+    });
+
+    expect(ctx.identity).toBeNull();
+  });
+});

package/skills/agentbnb/bootstrap.ts

@@ -0,0 +1,126 @@
+/**
+ * AgentBnB Bootstrap — single-call OpenClaw skill lifecycle entry point.
+ *
+ * Usage: `const ctx = await activate({ owner: 'alice', soulMdPath: './SOUL.md' });`
+ * Teardown: `await deactivate(ctx);`
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type { FastifyInstance } from 'fastify';
+
+import { AgentRuntime } from '../../src/runtime/agent-runtime.js';
+import { publishFromSoulV2 } from '../../src/openclaw/soul-sync.js';
+import { createGatewayServer } from '../../src/gateway/server.js';
+import { IdleMonitor } from '../../src/autonomy/idle-monitor.js';
+import { DEFAULT_AUTONOMY_CONFIG } from '../../src/autonomy/tiers.js';
+import { AgentBnBError } from '../../src/types/index.js';
+import { ensureIdentity, type AgentIdentity } from '../../src/identity/identity.js';
+import type { AutonomyConfig } from '../../src/autonomy/tiers.js';
+import type { CapabilityCardV2 } from '../../src/types/index.js';
+
+/** Configuration for bringing an AgentBnB agent online. */
+export interface BootstrapConfig {
+  /** Agent owner identifier. */
+  owner: string;
+  /** Absolute path to SOUL.md. */
+  soulMdPath: string;
+  /** Registry DB path. Defaults to ~/.agentbnb/registry.db */
+  registryDbPath?: string;
+  /** Credit DB path. Defaults to ~/.agentbnb/credit.db */
+  creditDbPath?: string;
+  /** Gateway port. Defaults to 7700. */
+  gatewayPort?: number;
+  /** Bearer token for gateway auth. Defaults to a random UUID. */
+  gatewayToken?: string;
+  /** Handler URL for capability forwarding. Defaults to http://localhost:{gatewayPort}. */
+  handlerUrl?: string;
+  /** Autonomy tier config. Defaults to DEFAULT_AUTONOMY_CONFIG (Tier 3). */
+  autonomyConfig?: AutonomyConfig;
+  /** Suppress gateway logs. Defaults to false. */
+  silent?: boolean;
+  /** When true, ensures identity.json exists on activate. Defaults to true. */
+  identityRequired?: boolean;
+}
+
+/** Live handles returned by activate(). Pass to deactivate() for clean teardown. */
+export interface BootstrapContext {
+  /** AgentRuntime managing DBs and background job lifecycle. */
+  runtime: AgentRuntime;
+  /** Fastify gateway HTTP server instance. */
+  gateway: FastifyInstance;
+  /** IdleMonitor background loop. */
+  idleMonitor: IdleMonitor;
+  /** Published CapabilityCard derived from SOUL.md. */
+  card: CapabilityCardV2;
+  /** Agent identity (created/loaded during activation). */
+  identity: AgentIdentity | null;
+}
+
+/**
+ * Brings an agent fully online: Runtime -> publishCard -> gateway.listen -> IdleMonitor.
+ * @throws {AgentBnBError} FILE_NOT_FOUND if SOUL.md does not exist.
+ */
+export async function activate(config: BootstrapConfig): Promise<BootstrapContext> {
+  const {
+    owner,
+    soulMdPath,
+    registryDbPath = join(homedir(), '.agentbnb', 'registry.db'),
+    creditDbPath = join(homedir(), '.agentbnb', 'credit.db'),
+    gatewayPort = 7700,
+    gatewayToken = randomUUID(),
+    autonomyConfig = DEFAULT_AUTONOMY_CONFIG,
+    silent = false,
+  } = config;
+
+  const identityRequired = config.identityRequired ?? false;
+  const handlerUrl = config.handlerUrl ?? `http://localhost:${gatewayPort}`;
+
+  if (!existsSync(soulMdPath)) {
+    throw new AgentBnBError(`SOUL.md not found at path: ${soulMdPath}`, 'FILE_NOT_FOUND');
+  }
+  const soulContent = readFileSync(soulMdPath, 'utf8');
+
+  const runtime = new AgentRuntime({ registryDbPath, creditDbPath, owner });
+  await runtime.start();
+
+  // Ensure agent identity exists (idempotent — preserves existing identity)
+  let identity: AgentIdentity | null = null;
+  if (identityRequired) {
+    const configDir = join(homedir(), '.agentbnb');
+    identity = ensureIdentity(configDir, owner);
+  }
+
+  const card = publishFromSoulV2(runtime.registryDb, soulContent, owner);
+
+  const gateway = createGatewayServer({
+    port: gatewayPort,
+    registryDb: runtime.registryDb,
+    creditDb: runtime.creditDb,
+    tokens: [gatewayToken],
+    handlerUrl,
+    silent,
+  });
+  await gateway.listen({ port: gatewayPort, host: '0.0.0.0' });
+
+  const idleMonitor = new IdleMonitor({ owner, db: runtime.registryDb, autonomyConfig });
+  const idleJob = idleMonitor.start();
+  runtime.registerJob(idleJob);
+
+  return { runtime, gateway, idleMonitor, card, identity };
+}
+
+/**
+ * Tears down all active components: gateway.close() then runtime.shutdown().
+ * Idempotent — safe to call multiple times.
+ */
+export async function deactivate(ctx: BootstrapContext): Promise<void> {
+  try {
+    await ctx.gateway.close();
+    await ctx.runtime.shutdown();
+  } catch {
+    // Swallow errors — idempotent teardown
+  }
+}

package/skills/agentbnb/credit-mgr.ts

@@ -0,0 +1,11 @@
+/**
+ * AgentBnB Credit Management adapter for OpenClaw skill integration.
+ * Delegates to BudgetManager and getBalance from src/credit/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { BudgetManager, DEFAULT_BUDGET_CONFIG } from '../../src/credit/budget.js';
+import { getBalance } from '../../src/credit/ledger.js';
+import type { BudgetConfig } from '../../src/credit/budget.js';
+
+export { BudgetManager, DEFAULT_BUDGET_CONFIG, getBalance };
+export type { BudgetConfig };

package/skills/agentbnb/gateway.ts

@@ -0,0 +1,12 @@
+/**
+ * AgentBnB Gateway adapter for OpenClaw skill integration.
+ * Delegates to AgentRuntime and createGatewayServer from src/.
+ * This is a thin re-export wrapper — no business logic lives here.
+ */
+import { AgentRuntime } from '../../src/runtime/agent-runtime.js';
+import { createGatewayServer } from '../../src/gateway/server.js';
+import type { RuntimeOptions } from '../../src/runtime/agent-runtime.js';
+import type { GatewayOptions } from '../../src/gateway/server.js';
+
+export { AgentRuntime, createGatewayServer };
+export type { RuntimeOptions, GatewayOptions };