agentbnb 3.0.0 → 3.1.1

package/dist/cli/index.js

@@ -1,41 +1,30 @@
 #!/usr/bin/env node
 import {
-  getActivityFeed,
-  getCard,
-  getRequestLog,
-  getSkillRequestCount,
-  insertCard,
-  insertRequestLog,
-  listCards,
-  openDatabase,
-  updateCard,
-  updateReputation,
-  updateSkillAvailability,
-  updateSkillIdleRate
-} from "../chunk-PJSYSVKN.js";
+  executeCapabilityRequest,
+  generateKeyPair,
+  loadKeyPair,
+  releaseRequesterEscrow,
+  saveKeyPair,
+  settleRequesterEscrow,
+  signEscrowReceipt
+} from "../chunk-MGHI67GR.js";
+import {
+  RelayMessageSchema
+} from "../chunk-3Y36WQDV.js";
 import {
   AutoRequestor,
   BudgetManager,
   DEFAULT_AUTONOMY_CONFIG,
   DEFAULT_BUDGET_CONFIG,
-  bootstrapAgent,
-  confirmEscrowDebit,
   filterCards,
   getAutonomyTier,
-  getBalance,
-  getTransactions,
-  holdEscrow,
   insertAuditEvent,
   interpolateObject,
   listPendingRequests,
-  openCreditDb,
-  recordEarning,
-  releaseEscrow,
   requestCapability,
   resolvePendingRequest,
-  searchCards,
-  settleEscrow
-} from "../chunk-V7M6GIJZ.js";
+  searchCards
+} from "../chunk-2ETVQXP7.js";
 import {
   findPeer,
   getConfigDir,
@@ -45,85 +34,134 @@ import {
   saveConfig,
   savePeer
 } from "../chunk-BEI5MTNZ.js";
+import {
+  getActivityFeed,
+  getCard,
+  getRequestLog,
+  getSkillRequestCount,
+  insertCard,
+  insertRequestLog,
+  listCards,
+  openDatabase,
+  updateCard,
+  updateSkillAvailability,
+  updateSkillIdleRate
+} from "../chunk-QAY6XTT7.js";
+import {
+  bootstrapAgent,
+  getBalance,
+  getTransactions,
+  holdEscrow,
+  openCreditDb,
+  releaseEscrow
+} from "../chunk-MZCNJ5PY.js";
 import {
   AgentBnBError,
-  CapabilityCardSchema,
+  AnyCardSchema,
   CapabilityCardV2Schema
-} from "../chunk-TQMI73LL.js";
+} from "../chunk-7RU5INZI.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { createRequire } from "module";
 import { randomBytes } from "crypto";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { networkInterfaces, homedir } from "os";
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 
-// src/credit/signing.ts
-import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
-import { writeFileSync, readFileSync, existsSync, chmodSync } from "fs";
+// src/identity/identity.ts
+import { z } from "zod";
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
-function generateKeyPair() {
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
-    publicKeyEncoding: { type: "spki", format: "der" },
-    privateKeyEncoding: { type: "pkcs8", format: "der" }
-  });
-  return {
-    publicKey: Buffer.from(publicKey),
-    privateKey: Buffer.from(privateKey)
-  };
-}
-function saveKeyPair(configDir, keys) {
-  const privatePath = join(configDir, "private.key");
-  const publicPath = join(configDir, "public.key");
-  writeFileSync(privatePath, keys.privateKey);
-  chmodSync(privatePath, 384);
-  writeFileSync(publicPath, keys.publicKey);
+var AgentIdentitySchema = z.object({
+  /** Deterministic ID derived from public key: sha256(hex).slice(0, 16). */
+  agent_id: z.string().min(1),
+  /** Human-readable owner name (from config or init). */
+  owner: z.string().min(1),
+  /** Hex-encoded Ed25519 public key. */
+  public_key: z.string().min(1),
+  /** ISO 8601 timestamp of identity creation. */
+  created_at: z.string().datetime(),
+  /** Optional guarantor info if linked to a human. */
+  guarantor: z.object({
+    github_login: z.string().min(1),
+    verified_at: z.string().datetime()
+  }).optional()
+});
+var AgentCertificateSchema = z.object({
+  identity: AgentIdentitySchema,
+  /** ISO 8601 timestamp of certificate issuance. */
+  issued_at: z.string().datetime(),
+  /** ISO 8601 timestamp of certificate expiry. */
+  expires_at: z.string().datetime(),
+  /** Hex-encoded public key of the issuer (same as identity for self-signed). */
+  issuer_public_key: z.string().min(1),
+  /** Base64url Ed25519 signature over { identity, issued_at, expires_at, issuer_public_key }. */
+  signature: z.string().min(1)
+});
+var IDENTITY_FILENAME = "identity.json";
+function deriveAgentId(publicKeyHex) {
+  return createHash("sha256").update(publicKeyHex, "hex").digest("hex").slice(0, 16);
 }
-function loadKeyPair(configDir) {
-  const privatePath = join(configDir, "private.key");
-  const publicPath = join(configDir, "public.key");
-  if (!existsSync(privatePath) || !existsSync(publicPath)) {
-    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+function createIdentity(configDir, owner) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
   }
-  return {
-    publicKey: readFileSync(publicPath),
-    privateKey: readFileSync(privatePath)
+  let keys;
+  try {
+    keys = loadKeyPair(configDir);
+  } catch {
+    keys = generateKeyPair();
+    saveKeyPair(configDir, keys);
+  }
+  const publicKeyHex = keys.publicKey.toString("hex");
+  const agentId = deriveAgentId(publicKeyHex);
+  const identity = {
+    agent_id: agentId,
+    owner,
+    public_key: publicKeyHex,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
   };
+  saveIdentity(configDir, identity);
+  return identity;
 }
-function canonicalJson(data) {
-  return JSON.stringify(data, Object.keys(data).sort());
-}
-function signEscrowReceipt(data, privateKey) {
-  const message = Buffer.from(canonicalJson(data), "utf-8");
-  const keyObject = createPrivateKey({ key: privateKey, format: "der", type: "pkcs8" });
-  const signature = sign(null, message, keyObject);
-  return signature.toString("base64url");
-}
-function verifyEscrowReceipt(data, signature, publicKey) {
+function loadIdentity(configDir) {
+  const filePath = join(configDir, IDENTITY_FILENAME);
+  if (!existsSync(filePath)) return null;
   try {
-    const message = Buffer.from(canonicalJson(data), "utf-8");
-    const keyObject = createPublicKey({ key: publicKey, format: "der", type: "spki" });
-    const sigBuffer = Buffer.from(signature, "base64url");
-    return verify(null, message, keyObject, sigBuffer);
+    const raw = readFileSync(filePath, "utf-8");
+    return AgentIdentitySchema.parse(JSON.parse(raw));
   } catch {
-    return false;
+    return null;
+  }
+}
+function saveIdentity(configDir, identity) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
   }
+  const filePath = join(configDir, IDENTITY_FILENAME);
+  writeFileSync(filePath, JSON.stringify(identity, null, 2), "utf-8");
+}
+function ensureIdentity(configDir, owner) {
+  const existing = loadIdentity(configDir);
+  if (existing) return existing;
+  return createIdentity(configDir, owner);
 }
 
 // src/credit/escrow-receipt.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 import { randomUUID } from "crypto";
-var EscrowReceiptSchema = z.object({
-  requester_owner: z.string().min(1),
-  requester_public_key: z.string().min(1),
-  amount: z.number().positive(),
-  card_id: z.string().min(1),
-  skill_id: z.string().optional(),
-  timestamp: z.string(),
-  nonce: z.string().uuid(),
-  signature: z.string().min(1)
+var EscrowReceiptSchema = z2.object({
+  requester_owner: z2.string().min(1),
+  requester_public_key: z2.string().min(1),
+  amount: z2.number().positive(),
+  card_id: z2.string().min(1),
+  skill_id: z2.string().optional(),
+  timestamp: z2.string(),
+  nonce: z2.string().uuid(),
+  signature: z2.string().min(1)
 });
 function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
   const escrowId = holdEscrow(db, opts.owner, opts.amount, opts.cardId);
@@ -144,24 +182,6 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
   return { escrowId, receipt };
 }
 
-// src/credit/settlement.ts
-function settleProviderEarning(providerDb, providerOwner, receipt) {
-  recordEarning(
-    providerDb,
-    providerOwner,
-    receipt.amount,
-    receipt.card_id,
-    receipt.nonce
-  );
-  return { settled: true };
-}
-function settleRequesterEscrow(requesterDb, escrowId) {
-  confirmEscrowDebit(requesterDb, escrowId);
-}
-function releaseRequesterEscrow(requesterDb, escrowId) {
-  releaseEscrow(requesterDb, escrowId);
-}
-
 // src/autonomy/idle-monitor.ts
 import { Cron } from "croner";
 var IdleMonitor = class {
@@ -507,8 +527,183 @@ function buildDraftCard(apiKey, owner) {
   };
 }
 
+// src/onboarding/index.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/onboarding/capability-templates.ts
+var API_PATTERNS = [
+  {
+    pattern: /openai|gpt-4|gpt-3|chatgpt|dall-e/i,
+    capability: { key: "openai", name: "OpenAI Text Generation", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] }
+  },
+  {
+    pattern: /elevenlabs|eleven.?labs/i,
+    capability: { key: "elevenlabs", name: "ElevenLabs TTS", category: "TTS", credits_per_call: 5, tags: ["tts", "audio", "voice"] }
+  },
+  {
+    pattern: /anthropic|claude/i,
+    capability: { key: "anthropic", name: "Anthropic Claude", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] }
+  },
+  {
+    pattern: /recraft/i,
+    capability: { key: "recraft", name: "Recraft V4 Image Gen", category: "Image Gen", credits_per_call: 8, tags: ["image", "generation", "design"] }
+  },
+  {
+    pattern: /kling/i,
+    capability: { key: "kling", name: "Kling AI Video Gen", category: "Video Gen", credits_per_call: 10, tags: ["video", "generation"] }
+  },
+  {
+    pattern: /stable.?diffusion|sdxl|comfyui/i,
+    capability: { key: "stable-diffusion", name: "Stable Diffusion Image Gen", category: "Image Gen", credits_per_call: 6, tags: ["image", "generation", "diffusion"] }
+  },
+  {
+    pattern: /whisper|speech.?to.?text|stt/i,
+    capability: { key: "whisper", name: "Whisper Speech-to-Text", category: "STT", credits_per_call: 3, tags: ["stt", "audio", "transcription"] }
+  },
+  {
+    pattern: /puppeteer|playwright|selenium/i,
+    capability: { key: "puppeteer", name: "Web Scraping & Automation", category: "Web Scraping", credits_per_call: 2, tags: ["scraping", "automation", "browser"] }
+  },
+  {
+    pattern: /ffmpeg/i,
+    capability: { key: "ffmpeg", name: "FFmpeg Media Processing", category: "Media Processing", credits_per_call: 3, tags: ["media", "audio", "video", "processing"] }
+  },
+  {
+    pattern: /tesseract|ocr/i,
+    capability: { key: "tesseract", name: "OCR Text Extraction", category: "OCR", credits_per_call: 4, tags: ["ocr", "text", "extraction"] }
+  }
+];
+var INTERACTIVE_TEMPLATES = [
+  { key: "openai", name: "Text Generation (GPT-4o / Claude / Gemini)", category: "Text Gen", credits_per_call: 3, tags: ["llm", "text", "generation"] },
+  { key: "image-gen", name: "Image Generation (DALL-E / Recraft / Stable Diffusion)", category: "Image Gen", credits_per_call: 8, tags: ["image", "generation"] },
+  { key: "tts", name: "TTS / Voice (ElevenLabs / Google TTS)", category: "TTS", credits_per_call: 5, tags: ["tts", "audio", "voice"] },
+  { key: "video-gen", name: "Video Generation (Kling / Runway)", category: "Video Gen", credits_per_call: 10, tags: ["video", "generation"] },
+  { key: "code-review", name: "Code Review / Analysis", category: "Code", credits_per_call: 3, tags: ["code", "review", "analysis"] },
+  { key: "scraping", name: "Web Scraping / Data Extraction", category: "Web Scraping", credits_per_call: 2, tags: ["scraping", "data", "extraction"] },
+  { key: "translation", name: "Translation", category: "Translation", credits_per_call: 3, tags: ["translation", "language", "text"] },
+  { key: "custom", name: "Custom (describe it)", category: "Custom", credits_per_call: 5, tags: ["custom"] }
+];
+
+// src/onboarding/detect-from-docs.ts
+function detectFromDocs(content) {
+  if (!content || content.trim().length === 0) {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const entry of API_PATTERNS) {
+    if (entry.pattern.test(content) && !seen.has(entry.capability.key)) {
+      seen.add(entry.capability.key);
+      results.push({ ...entry.capability });
+    }
+  }
+  return results;
+}
+
+// src/onboarding/interactive.ts
+import { createInterface } from "readline";
+async function interactiveTemplateMenu() {
+  console.log("\nNo capabilities auto-detected.\n");
+  console.log("What can your agent do? Pick from templates:\n");
+  for (let i = 0; i < INTERACTIVE_TEMPLATES.length; i++) {
+    console.log(`  ${i + 1}. ${INTERACTIVE_TEMPLATES[i].name}`);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question("\nSelect [1-8, comma-separated]: ", (ans) => {
+      rl.close();
+      resolve(ans);
+    });
+  });
+  return parseSelection(answer);
+}
+function parseSelection(input) {
+  if (!input || input.trim().length === 0) {
+    return [];
+  }
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  const parts = input.split(",").map((s) => s.trim());
+  for (const part of parts) {
+    const num = parseInt(part, 10);
+    if (isNaN(num) || num < 1 || num > INTERACTIVE_TEMPLATES.length) {
+      continue;
+    }
+    const template = INTERACTIVE_TEMPLATES[num - 1];
+    if (!seen.has(template.key)) {
+      seen.add(template.key);
+      selected.push({ ...template });
+    }
+  }
+  return selected;
+}
+
+// src/onboarding/index.ts
+var DOC_FILES = ["SOUL.md", "CLAUDE.md", "AGENTS.md", "README.md"];
+function detectCapabilities(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  if (opts.fromFile) {
+    const filePath = opts.fromFile.startsWith("/") ? opts.fromFile : join2(cwd, opts.fromFile);
+    if (existsSync2(filePath)) {
+      const content = readFileSync2(filePath, "utf-8");
+      const capabilities = detectFromDocs(content);
+      if (capabilities.length > 0) {
+        return { source: "docs", capabilities, sourceFile: filePath };
+      }
+    }
+    return { source: "none", capabilities: [] };
+  }
+  for (const fileName of DOC_FILES) {
+    const filePath = join2(cwd, fileName);
+    if (!existsSync2(filePath)) continue;
+    const content = readFileSync2(filePath, "utf-8");
+    if (fileName === "SOUL.md") {
+      return { source: "soul", capabilities: [], soulContent: content, sourceFile: filePath };
+    }
+    const capabilities = detectFromDocs(content);
+    if (capabilities.length > 0) {
+      return { source: "docs", capabilities, sourceFile: filePath };
+    }
+  }
+  const envKeys = detectApiKeys(KNOWN_API_KEYS);
+  if (envKeys.length > 0) {
+    return { source: "env", capabilities: [], envKeys };
+  }
+  return { source: "none", capabilities: [] };
+}
+function capabilitiesToV2Card(capabilities, owner, agentName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const skills = capabilities.map((cap) => ({
+    id: cap.key,
+    name: cap.name,
+    description: `${cap.name} capability \u2014 ${cap.category}`,
+    level: 1,
+    category: cap.category.toLowerCase().replace(/\s+/g, "_"),
+    inputs: [{ name: "input", type: "text", required: true }],
+    outputs: [{ name: "output", type: "text", required: true }],
+    pricing: { credits_per_call: cap.credits_per_call },
+    availability: { online: true },
+    metadata: {
+      tags: cap.tags
+    }
+  }));
+  const card = {
+    spec_version: "2.0",
+    id: randomUUID3(),
+    owner,
+    agent_name: agentName ?? owner,
+    skills,
+    availability: { online: true },
+    created_at: now,
+    updated_at: now
+  };
+  return CapabilityCardV2Schema.parse(card);
+}
+
 // src/runtime/agent-runtime.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 
 // src/skills/executor.ts
 var SkillExecutor = class {
@@ -591,98 +786,98 @@ function createSkillExecutor(configs, modes) {
 }
 
 // src/skills/skill-config.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 import yaml from "js-yaml";
-var PricingSchema = z2.object({
-  credits_per_call: z2.number().nonnegative(),
-  credits_per_minute: z2.number().nonnegative().optional(),
-  free_tier: z2.number().nonnegative().optional()
+var PricingSchema = z3.object({
+  credits_per_call: z3.number().nonnegative(),
+  credits_per_minute: z3.number().nonnegative().optional(),
+  free_tier: z3.number().nonnegative().optional()
 });
-var ApiAuthSchema = z2.discriminatedUnion("type", [
-  z2.object({
-    type: z2.literal("bearer"),
-    token: z2.string()
+var ApiAuthSchema = z3.discriminatedUnion("type", [
+  z3.object({
+    type: z3.literal("bearer"),
+    token: z3.string()
   }),
-  z2.object({
-    type: z2.literal("apikey"),
-    header: z2.string().default("X-API-Key"),
-    key: z2.string()
+  z3.object({
+    type: z3.literal("apikey"),
+    header: z3.string().default("X-API-Key"),
+    key: z3.string()
   }),
-  z2.object({
-    type: z2.literal("basic"),
-    username: z2.string(),
-    password: z2.string()
+  z3.object({
+    type: z3.literal("basic"),
+    username: z3.string(),
+    password: z3.string()
   })
 ]);
-var ApiSkillConfigSchema = z2.object({
-  id: z2.string().min(1),
-  type: z2.literal("api"),
-  name: z2.string().min(1),
-  endpoint: z2.string().min(1),
-  method: z2.enum(["GET", "POST", "PUT", "DELETE"]),
+var ApiSkillConfigSchema = z3.object({
+  id: z3.string().min(1),
+  type: z3.literal("api"),
+  name: z3.string().min(1),
+  endpoint: z3.string().min(1),
+  method: z3.enum(["GET", "POST", "PUT", "DELETE"]),
   auth: ApiAuthSchema.optional(),
-  input_mapping: z2.record(z2.string()).default({}),
-  output_mapping: z2.record(z2.string()).default({}),
+  input_mapping: z3.record(z3.string()).default({}),
+  output_mapping: z3.record(z3.string()).default({}),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().default(3e4),
-  retries: z2.number().nonnegative().int().default(0),
-  provider: z2.string().optional()
+  timeout_ms: z3.number().positive().default(3e4),
+  retries: z3.number().nonnegative().int().default(0),
+  provider: z3.string().optional()
 });
-var PipelineStepSchema = z2.union([
-  z2.object({
-    skill_id: z2.string().min(1),
-    input_mapping: z2.record(z2.string()).default({})
+var PipelineStepSchema = z3.union([
+  z3.object({
+    skill_id: z3.string().min(1),
+    input_mapping: z3.record(z3.string()).default({})
   }),
-  z2.object({
-    command: z2.string().min(1),
-    input_mapping: z2.record(z2.string()).default({})
+  z3.object({
+    command: z3.string().min(1),
+    input_mapping: z3.record(z3.string()).default({})
   })
 ]);
-var PipelineSkillConfigSchema = z2.object({
-  id: z2.string().min(1),
-  type: z2.literal("pipeline"),
-  name: z2.string().min(1),
-  steps: z2.array(PipelineStepSchema).min(1),
+var PipelineSkillConfigSchema = z3.object({
+  id: z3.string().min(1),
+  type: z3.literal("pipeline"),
+  name: z3.string().min(1),
+  steps: z3.array(PipelineStepSchema).min(1),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z3.number().positive().optional()
 });
-var OpenClawSkillConfigSchema = z2.object({
-  id: z2.string().min(1),
-  type: z2.literal("openclaw"),
-  name: z2.string().min(1),
-  agent_name: z2.string().min(1),
-  channel: z2.enum(["telegram", "webhook", "process"]),
+var OpenClawSkillConfigSchema = z3.object({
+  id: z3.string().min(1),
+  type: z3.literal("openclaw"),
+  name: z3.string().min(1),
+  agent_name: z3.string().min(1),
+  channel: z3.enum(["telegram", "webhook", "process"]),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z3.number().positive().optional()
 });
-var CommandSkillConfigSchema = z2.object({
-  id: z2.string().min(1),
-  type: z2.literal("command"),
-  name: z2.string().min(1),
-  command: z2.string().min(1),
-  output_type: z2.enum(["json", "text", "file"]),
-  allowed_commands: z2.array(z2.string()).optional(),
-  working_dir: z2.string().optional(),
-  timeout_ms: z2.number().positive().default(3e4),
+var CommandSkillConfigSchema = z3.object({
+  id: z3.string().min(1),
+  type: z3.literal("command"),
+  name: z3.string().min(1),
+  command: z3.string().min(1),
+  output_type: z3.enum(["json", "text", "file"]),
+  allowed_commands: z3.array(z3.string()).optional(),
+  working_dir: z3.string().optional(),
+  timeout_ms: z3.number().positive().default(3e4),
   pricing: PricingSchema
 });
-var ConductorSkillConfigSchema = z2.object({
-  id: z2.string().min(1),
-  type: z2.literal("conductor"),
-  name: z2.string().min(1),
-  conductor_skill: z2.enum(["orchestrate", "plan"]),
+var ConductorSkillConfigSchema = z3.object({
+  id: z3.string().min(1),
+  type: z3.literal("conductor"),
+  name: z3.string().min(1),
+  conductor_skill: z3.enum(["orchestrate", "plan"]),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z3.number().positive().optional()
 });
-var SkillConfigSchema = z2.discriminatedUnion("type", [
+var SkillConfigSchema = z3.discriminatedUnion("type", [
   ApiSkillConfigSchema,
   PipelineSkillConfigSchema,
   OpenClawSkillConfigSchema,
   CommandSkillConfigSchema,
   ConductorSkillConfigSchema
 ]);
-var SkillsFileSchema = z2.object({
-  skills: z2.array(SkillConfigSchema)
+var SkillsFileSchema = z3.object({
+  skills: z3.array(SkillConfigSchema)
 });
 function expandEnvVars(value) {
   return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
@@ -1319,19 +1514,19 @@ var AgentRuntime = class {
    * 3. Populate the Map with all 4 modes — SkillExecutor sees them via reference.
    */
   async initSkillExecutor() {
-    const hasSkillsYaml = this.skillsYamlPath && existsSync2(this.skillsYamlPath);
+    const hasSkillsYaml = this.skillsYamlPath && existsSync3(this.skillsYamlPath);
     if (!hasSkillsYaml && !this.conductorEnabled) {
       return;
     }
     let configs = [];
     if (hasSkillsYaml) {
-      const yamlContent = readFileSync2(this.skillsYamlPath, "utf8");
+      const yamlContent = readFileSync3(this.skillsYamlPath, "utf8");
       configs = parseSkillsFile(yamlContent);
     }
     const modes = /* @__PURE__ */ new Map();
     if (this.conductorEnabled) {
-      const { ConductorMode } = await import("../conductor-mode-DJ3RIJ5T.js");
-      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../card-P5C36VBD.js");
+      const { ConductorMode } = await import("../conductor-mode-GPLAM2XO.js");
+      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../card-EWIXC377.js");
       const { loadPeers: loadPeers2 } = await import("../peers-G36URZYB.js");
       registerConductorCard(this.registryDb);
       const resolveAgentUrl = (owner) => {
@@ -1437,7 +1632,6 @@ var AgentRuntime = class {
 
 // src/gateway/server.ts
 import Fastify from "fastify";
-import { randomUUID as randomUUID3 } from "crypto";
 var VERSION = "0.0.1";
 function createGatewayServer(opts) {
   const {
@@ -1501,270 +1695,402 @@ function createGatewayServer(opts) {
         error: { code: -32602, message: "Invalid params: card_id required" }
       });
     }
-    const card = getCard(registryDb, cardId);
-    if (!card) {
-      return reply.send({
-        jsonrpc: "2.0",
-        id,
-        error: { code: -32602, message: `Card not found: ${cardId}` }
-      });
-    }
     const requester = params.requester ?? "unknown";
-    let creditsNeeded;
-    let cardName;
-    let resolvedSkillId;
-    const rawCard = card;
-    if (Array.isArray(rawCard["skills"])) {
-      const v2card = card;
-      const skill = skillId ? v2card.skills.find((s) => s.id === skillId) : v2card.skills[0];
-      if (!skill) {
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32602, message: `Skill not found: ${skillId}` }
-        });
-      }
-      creditsNeeded = skill.pricing.credits_per_call;
-      cardName = skill.name;
-      resolvedSkillId = skill.id;
-    } else {
-      creditsNeeded = card.pricing.credits_per_call;
-      cardName = card.name;
-    }
     const receipt = params.escrow_receipt;
-    let escrowId = null;
-    let isRemoteEscrow = false;
-    if (receipt) {
-      const { signature, ...receiptData } = receipt;
-      const publicKeyBuf = Buffer.from(receipt.requester_public_key, "hex");
-      const valid = verifyEscrowReceipt(receiptData, signature, publicKeyBuf);
-      if (!valid) {
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32603, message: "Invalid escrow receipt signature" }
-        });
-      }
-      if (receipt.amount < creditsNeeded) {
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32603, message: "Insufficient escrow amount" }
-        });
-      }
-      const receiptAge = Date.now() - new Date(receipt.timestamp).getTime();
-      if (receiptAge > 5 * 60 * 1e3) {
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32603, message: "Escrow receipt expired" }
-        });
-      }
-      isRemoteEscrow = true;
+    const result = await executeCapabilityRequest({
+      registryDb,
+      creditDb,
+      cardId,
+      skillId,
+      params,
+      requester,
+      escrowReceipt: receipt,
+      skillExecutor,
+      handlerUrl,
+      timeoutMs
+    });
+    if (result.success) {
+      return reply.send({ jsonrpc: "2.0", id, result: result.result });
     } else {
-      try {
-        const balance = getBalance(creditDb, requester);
-        if (balance < creditsNeeded) {
-          return reply.send({
-            jsonrpc: "2.0",
-            id,
-            error: { code: -32603, message: "Insufficient credits" }
-          });
-        }
-        escrowId = holdEscrow(creditDb, requester, creditsNeeded, cardId);
-      } catch (err) {
-        const msg = err instanceof AgentBnBError ? err.message : "Failed to hold escrow";
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32603, message: msg }
-        });
-      }
+      return reply.send({ jsonrpc: "2.0", id, error: result.error });
     }
-    const startMs = Date.now();
-    if (skillExecutor) {
-      const targetSkillId = resolvedSkillId ?? skillId ?? cardId;
-      let execResult;
-      try {
-        execResult = await skillExecutor.execute(targetSkillId, params);
-      } catch (err) {
-        if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
-        updateReputation(registryDb, cardId, false, Date.now() - startMs);
+  });
+  return fastify;
+}
+
+// src/registry/server.ts
+import Fastify2 from "fastify";
+import cors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import fastifyWebsocket from "@fastify/websocket";
+import { join as join3, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4 } from "fs";
+
+// src/relay/websocket-relay.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var RATE_LIMIT_MAX = 60;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RELAY_TIMEOUT_MS = 3e4;
+function registerWebSocketRelay(server, db) {
+  const connections = /* @__PURE__ */ new Map();
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const rateLimits = /* @__PURE__ */ new Map();
+  function checkRateLimit(owner) {
+    const now = Date.now();
+    const entry = rateLimits.get(owner);
+    if (!entry || now >= entry.resetTime) {
+      rateLimits.set(owner, { count: 1, resetTime: now + RATE_LIMIT_WINDOW_MS });
+      return true;
+    }
+    if (entry.count >= RATE_LIMIT_MAX) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  function markOwnerOffline(owner) {
+    try {
+      const stmt = db.prepare("SELECT id, data FROM capability_cards WHERE owner = ?");
+      const rows = stmt.all(owner);
+      for (const row of rows) {
         try {
-          insertRequestLog(registryDb, {
-            id: randomUUID3(),
-            card_id: cardId,
-            card_name: cardName,
-            skill_id: resolvedSkillId,
-            requester,
-            status: "failure",
-            latency_ms: Date.now() - startMs,
-            credits_charged: 0,
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
+          const card = JSON.parse(row.data);
+          if (card.availability?.online) {
+            card.availability.online = false;
+            card.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+            const updateStmt = db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?");
+            updateStmt.run(JSON.stringify(card), card.updated_at, row.id);
+          }
         } catch {
         }
-        const message = err instanceof Error ? err.message : "Execution error";
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32603,
-            message,
-            ...isRemoteEscrow ? { data: { receipt_released: true } } : {}
-          }
-        });
       }
-      if (!execResult.success) {
-        if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
-        updateReputation(registryDb, cardId, false, execResult.latency_ms);
+    } catch {
+    }
+  }
+  function markOwnerOnline(owner) {
+    try {
+      const stmt = db.prepare("SELECT id, data FROM capability_cards WHERE owner = ?");
+      const rows = stmt.all(owner);
+      for (const row of rows) {
         try {
-          insertRequestLog(registryDb, {
-            id: randomUUID3(),
-            card_id: cardId,
-            card_name: cardName,
-            skill_id: resolvedSkillId,
-            requester,
-            status: "failure",
-            latency_ms: execResult.latency_ms,
-            credits_charged: 0,
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
+          const card = JSON.parse(row.data);
+          card.availability = { ...card.availability, online: true };
+          card.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+          const updateStmt = db.prepare("UPDATE capability_cards SET data = ?, updated_at = ? WHERE id = ?");
+          updateStmt.run(JSON.stringify(card), card.updated_at, row.id);
         } catch {
         }
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32603,
-            message: execResult.error ?? "Execution failed",
-            ...isRemoteEscrow ? { data: { receipt_released: true } } : {}
-          }
-        });
       }
-      if (isRemoteEscrow && receipt) {
-        settleProviderEarning(creditDb, card.owner, receipt);
-      } else if (escrowId) {
-        settleEscrow(creditDb, escrowId, card.owner);
-      }
-      updateReputation(registryDb, cardId, true, execResult.latency_ms);
+    } catch {
+    }
+  }
+  function upsertCard(cardData, owner) {
+    const cardId = cardData.id;
+    const existing = getCard(db, cardId);
+    if (existing) {
+      const updates = { ...cardData, availability: { ...cardData.availability ?? {}, online: true } };
+      updateCard(db, cardId, owner, updates);
+    } else {
+      const card = { ...cardData, availability: { ...cardData.availability ?? {}, online: true } };
+      insertCard(db, card);
+    }
+    return cardId;
+  }
+  function logAgentJoined(owner, cardName, cardId) {
+    try {
+      insertRequestLog(db, {
+        id: randomUUID4(),
+        card_id: cardId,
+        card_name: cardName,
+        requester: owner,
+        status: "success",
+        latency_ms: 0,
+        credits_charged: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        action_type: "agent_joined"
+      });
+    } catch {
+    }
+  }
+  function sendMessage(ws, msg) {
+    if (ws.readyState === 1) {
+      ws.send(JSON.stringify(msg));
+    }
+  }
+  function handleRegister(ws, msg) {
+    const { owner, card } = msg;
+    const existing = connections.get(owner);
+    if (existing && existing !== ws) {
       try {
-        insertRequestLog(registryDb, {
-          id: randomUUID3(),
-          card_id: cardId,
-          card_name: cardName,
-          skill_id: resolvedSkillId,
-          requester,
-          status: "success",
-          latency_ms: execResult.latency_ms,
-          credits_charged: creditsNeeded,
-          created_at: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        existing.close(1e3, "Replaced by new connection");
       } catch {
       }
-      const successResult = isRemoteEscrow ? { ...typeof execResult.result === "object" && execResult.result !== null ? execResult.result : { data: execResult.result }, receipt_settled: true, receipt_nonce: receipt.nonce } : execResult.result;
-      return reply.send({ jsonrpc: "2.0", id, result: successResult });
     }
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await fetch(handlerUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ card_id: cardId, skill_id: resolvedSkillId, params }),
-        signal: controller.signal
+    connections.set(owner, ws);
+    const cardId = upsertCard(card, owner);
+    const cardName = card.name ?? card.agent_name ?? owner;
+    logAgentJoined(owner, cardName, cardId);
+    markOwnerOnline(owner);
+    sendMessage(ws, { type: "registered", agent_id: cardId });
+  }
+  function handleRelayRequest(ws, msg, fromOwner) {
+    if (!checkRateLimit(fromOwner)) {
+      sendMessage(ws, {
+        type: "error",
+        code: "rate_limited",
+        message: `Rate limit exceeded: max ${RATE_LIMIT_MAX} requests per minute`,
+        request_id: msg.id
       });
-      clearTimeout(timer);
-      if (!response.ok) {
-        if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
-        updateReputation(registryDb, cardId, false, Date.now() - startMs);
-        try {
-          insertRequestLog(registryDb, {
-            id: randomUUID3(),
-            card_id: cardId,
-            card_name: cardName,
-            skill_id: resolvedSkillId,
-            requester,
-            status: "failure",
-            latency_ms: Date.now() - startMs,
-            credits_charged: 0,
-            created_at: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        } catch {
-        }
-        return reply.send({
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32603,
-            message: `Handler returned ${response.status}`,
-            ...isRemoteEscrow ? { data: { receipt_released: true } } : {}
-          }
-        });
-      }
-      const result = await response.json();
-      if (isRemoteEscrow && receipt) {
-        settleProviderEarning(creditDb, card.owner, receipt);
-      } else if (escrowId) {
-        settleEscrow(creditDb, escrowId, card.owner);
+      return;
+    }
+    const targetWs = connections.get(msg.target_owner);
+    if (!targetWs || targetWs.readyState !== 1) {
+      sendMessage(ws, {
+        type: "response",
+        id: msg.id,
+        error: { code: -32603, message: `Agent offline: ${msg.target_owner}` }
+      });
+      return;
+    }
+    const timeout = setTimeout(() => {
+      pendingRequests.delete(msg.id);
+      sendMessage(ws, {
+        type: "response",
+        id: msg.id,
+        error: { code: -32603, message: "Relay request timeout" }
+      });
+    }, RELAY_TIMEOUT_MS);
+    pendingRequests.set(msg.id, { originOwner: fromOwner, timeout });
+    sendMessage(targetWs, {
+      type: "incoming_request",
+      id: msg.id,
+      from_owner: fromOwner,
+      card_id: msg.card_id,
+      skill_id: msg.skill_id,
+      params: msg.params,
+      requester: msg.requester ?? fromOwner,
+      escrow_receipt: msg.escrow_receipt
+    });
+  }
+  function handleRelayResponse(msg) {
+    const pending = pendingRequests.get(msg.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    pendingRequests.delete(msg.id);
+    const originWs = connections.get(pending.originOwner);
+    if (originWs && originWs.readyState === 1) {
+      sendMessage(originWs, {
+        type: "response",
+        id: msg.id,
+        result: msg.result,
+        error: msg.error
+      });
+    }
+  }
+  function handleDisconnect(owner) {
+    if (!owner) return;
+    connections.delete(owner);
+    rateLimits.delete(owner);
+    markOwnerOffline(owner);
+    for (const [reqId, pending] of pendingRequests) {
+      if (pending.originOwner === owner) {
+        clearTimeout(pending.timeout);
+        pendingRequests.delete(reqId);
       }
-      updateReputation(registryDb, cardId, true, Date.now() - startMs);
+    }
+  }
+  server.get("/ws", { websocket: true }, (rawSocket, _request) => {
+    const socket = rawSocket;
+    let registeredOwner;
+    socket.on("message", (raw) => {
+      let data;
       try {
-        insertRequestLog(registryDb, {
-          id: randomUUID3(),
-          card_id: cardId,
-          card_name: cardName,
-          skill_id: resolvedSkillId,
-          requester,
-          status: "success",
-          latency_ms: Date.now() - startMs,
-          credits_charged: creditsNeeded,
-          created_at: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        data = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf-8"));
       } catch {
+        sendMessage(socket, { type: "error", code: "invalid_json", message: "Invalid JSON" });
+        return;
       }
-      const successResult = isRemoteEscrow ? { ...typeof result === "object" && result !== null ? result : { data: result }, receipt_settled: true, receipt_nonce: receipt.nonce } : result;
-      return reply.send({ jsonrpc: "2.0", id, result: successResult });
-    } catch (err) {
-      clearTimeout(timer);
-      if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
-      updateReputation(registryDb, cardId, false, Date.now() - startMs);
-      const isTimeout = err instanceof Error && err.name === "AbortError";
-      try {
-        insertRequestLog(registryDb, {
-          id: randomUUID3(),
-          card_id: cardId,
-          card_name: cardName,
-          skill_id: resolvedSkillId,
-          requester,
-          status: isTimeout ? "timeout" : "failure",
-          latency_ms: Date.now() - startMs,
-          credits_charged: 0,
-          created_at: (/* @__PURE__ */ new Date()).toISOString()
+      const parsed = RelayMessageSchema.safeParse(data);
+      if (!parsed.success) {
+        sendMessage(socket, {
+          type: "error",
+          code: "invalid_message",
+          message: `Invalid message: ${parsed.error.issues[0]?.message ?? "unknown error"}`
         });
-      } catch {
+        return;
       }
-      return reply.send({
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32603,
-          message: isTimeout ? "Execution timeout" : "Handler error",
-          ...isRemoteEscrow ? { data: { receipt_released: true } } : {}
+      const msg = parsed.data;
+      switch (msg.type) {
+        case "register":
+          registeredOwner = msg.owner;
+          handleRegister(socket, msg);
+          break;
+        case "relay_request":
+          if (!registeredOwner) {
+            sendMessage(socket, {
+              type: "error",
+              code: "not_registered",
+              message: "Must send register message before relay requests"
+            });
+            return;
+          }
+          handleRelayRequest(socket, msg, registeredOwner);
+          break;
+        case "relay_response":
+          handleRelayResponse(msg);
+          break;
+        default:
+          break;
+      }
+    });
+    socket.on("close", () => {
+      handleDisconnect(registeredOwner);
+    });
+    socket.on("error", () => {
+      handleDisconnect(registeredOwner);
+    });
+  });
+  return {
+    getOnlineCount: () => connections.size,
+    getOnlineOwners: () => Array.from(connections.keys()),
+    shutdown: () => {
+      for (const [, ws] of connections) {
+        try {
+          ws.close(1001, "Server shutting down");
+        } catch {
         }
-      });
+      }
+      connections.clear();
+      for (const [, pending] of pendingRequests) {
+        clearTimeout(pending.timeout);
+      }
+      pendingRequests.clear();
+      rateLimits.clear();
     }
-  });
-  return fastify;
+  };
+}
+
+// src/identity/guarantor.ts
+import { z as z4 } from "zod";
+import { randomUUID as randomUUID5 } from "crypto";
+var MAX_AGENTS_PER_GUARANTOR = 10;
+var GUARANTOR_CREDIT_POOL = 50;
+var GuarantorRecordSchema = z4.object({
+  id: z4.string().uuid(),
+  github_login: z4.string().min(1),
+  agent_count: z4.number().int().nonnegative(),
+  credit_pool: z4.number().int().nonnegative(),
+  created_at: z4.string().datetime()
+});
+var GUARANTOR_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS guarantors (
+    id TEXT PRIMARY KEY,
+    github_login TEXT UNIQUE NOT NULL,
+    agent_count INTEGER NOT NULL DEFAULT 0,
+    credit_pool INTEGER NOT NULL DEFAULT ${GUARANTOR_CREDIT_POOL},
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_guarantors (
+    agent_id TEXT PRIMARY KEY,
+    guarantor_id TEXT NOT NULL,
+    linked_at TEXT NOT NULL,
+    FOREIGN KEY (guarantor_id) REFERENCES guarantors(id)
+  );
+`;
+function ensureGuarantorTables(db) {
+  db.exec(GUARANTOR_SCHEMA);
+}
+function registerGuarantor(db, githubLogin) {
+  ensureGuarantorTables(db);
+  const existing = db.prepare("SELECT * FROM guarantors WHERE github_login = ?").get(githubLogin);
+  if (existing) {
+    throw new AgentBnBError(
+      `Guarantor already registered: ${githubLogin}`,
+      "GUARANTOR_EXISTS"
+    );
+  }
+  const record = {
+    id: randomUUID5(),
+    github_login: githubLogin,
+    agent_count: 0,
+    credit_pool: GUARANTOR_CREDIT_POOL,
+    created_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  db.prepare(
+    "INSERT INTO guarantors (id, github_login, agent_count, credit_pool, created_at) VALUES (?, ?, ?, ?, ?)"
+  ).run(record.id, record.github_login, record.agent_count, record.credit_pool, record.created_at);
+  return record;
+}
+function linkAgentToGuarantor(db, agentId, githubLogin) {
+  ensureGuarantorTables(db);
+  const guarantor = db.prepare("SELECT * FROM guarantors WHERE github_login = ?").get(githubLogin);
+  if (!guarantor) {
+    throw new AgentBnBError(
+      `Guarantor not found: ${githubLogin}`,
+      "GUARANTOR_NOT_FOUND"
+    );
+  }
+  if (guarantor["agent_count"] >= MAX_AGENTS_PER_GUARANTOR) {
+    throw new AgentBnBError(
+      `Maximum agents per guarantor reached (${MAX_AGENTS_PER_GUARANTOR})`,
+      "MAX_AGENTS_EXCEEDED"
+    );
+  }
+  const existingLink = db.prepare("SELECT * FROM agent_guarantors WHERE agent_id = ?").get(agentId);
+  if (existingLink) {
+    throw new AgentBnBError(
+      `Agent ${agentId} is already linked to a guarantor`,
+      "AGENT_ALREADY_LINKED"
+    );
+  }
+  db.transaction(() => {
+    db.prepare("INSERT INTO agent_guarantors (agent_id, guarantor_id, linked_at) VALUES (?, ?, ?)").run(
+      agentId,
+      guarantor["id"],
+      (/* @__PURE__ */ new Date()).toISOString()
+    );
+    db.prepare("UPDATE guarantors SET agent_count = agent_count + 1 WHERE id = ?").run(guarantor["id"]);
+  })();
+  return getGuarantor(db, githubLogin);
+}
+function getGuarantor(db, githubLogin) {
+  ensureGuarantorTables(db);
+  const row = db.prepare("SELECT * FROM guarantors WHERE github_login = ?").get(githubLogin);
+  if (!row) return null;
+  return {
+    id: row["id"],
+    github_login: row["github_login"],
+    agent_count: row["agent_count"],
+    credit_pool: row["credit_pool"],
+    created_at: row["created_at"]
+  };
+}
+function getAgentGuarantor(db, agentId) {
+  ensureGuarantorTables(db);
+  const link = db.prepare(
+    `SELECT g.* FROM guarantors g
+       JOIN agent_guarantors ag ON ag.guarantor_id = g.id
+       WHERE ag.agent_id = ?`
+  ).get(agentId);
+  if (!link) return null;
+  return {
+    id: link["id"],
+    github_login: link["github_login"],
+    agent_count: link["agent_count"],
+    credit_pool: link["credit_pool"],
+    created_at: link["created_at"]
+  };
+}
+function initiateGithubAuth() {
+  return {
+    auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
+    state: randomUUID5()
+  };
 }
 
 // src/registry/server.ts
-import Fastify2 from "fastify";
-import cors from "@fastify/cors";
-import fastifyStatic from "@fastify/static";
-import { join as join2, dirname } from "path";
-import { fileURLToPath } from "url";
-import { existsSync as existsSync3 } from "fs";
 function stripInternal(card) {
   const { _internal: _, ...publicCard } = card;
   return publicCard;
@@ -1777,20 +2103,28 @@ function createRegistryServer(opts) {
     methods: ["GET", "POST", "PATCH", "OPTIONS"],
     allowedHeaders: ["Content-Type", "Authorization"]
   });
+  void server.register(fastifyWebsocket);
+  let relayState = null;
+  if (opts.creditDb) {
+    relayState = registerWebSocketRelay(server, db);
+  }
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
   const hubDistCandidates = [
-    join2(__dirname, "../../hub/dist"),
+    join3(__dirname, "../../hub/dist"),
     // When running from dist/registry/server.js
-    join2(__dirname, "../../../hub/dist")
+    join3(__dirname, "../../../hub/dist")
     // Fallback for alternative layouts
   ];
-  const hubDistDir = hubDistCandidates.find((p) => existsSync3(p));
+  const hubDistDir = hubDistCandidates.find((p) => existsSync4(p));
   if (hubDistDir) {
     void server.register(fastifyStatic, {
       root: hubDistDir,
       prefix: "/hub/"
     });
+    server.get("/", async (_request, reply) => {
+      return reply.redirect("/hub/");
+    });
     server.get("/hub", async (_request, reply) => {
       return reply.redirect("/hub/");
     });
@@ -1838,12 +2172,47 @@ function createRegistryServer(opts) {
         (c) => (c.metadata?.avg_latency_ms ?? Infinity) <= maxLatencyMs
       );
     }
-    if (sort === "success_rate") {
+    const usesStmt = db.prepare(`
+      SELECT card_id, skill_id, COUNT(*) as cnt
+      FROM request_log
+      WHERE status = 'success'
+        AND created_at > datetime('now', '-7 days')
+        AND (action_type IS NULL OR action_type = 'auto_share')
+      GROUP BY card_id, skill_id
+    `);
+    const usesRows = usesStmt.all();
+    const usesMap = /* @__PURE__ */ new Map();
+    for (const row of usesRows) {
+      usesMap.set(row.card_id, (usesMap.get(row.card_id) ?? 0) + row.cnt);
+      if (row.skill_id) {
+        usesMap.set(row.skill_id, (usesMap.get(row.skill_id) ?? 0) + row.cnt);
+      }
+    }
+    if (sort === "popular") {
+      cards = [...cards].sort((a, b) => {
+        const aUses = usesMap.get(a.id) ?? 0;
+        const bUses = usesMap.get(b.id) ?? 0;
+        return bUses - aUses;
+      });
+    } else if (sort === "rated" || sort === "success_rate") {
       cards = [...cards].sort((a, b) => {
         const aRate = a.metadata?.success_rate ?? -1;
         const bRate = b.metadata?.success_rate ?? -1;
         return bRate - aRate;
       });
+    } else if (sort === "cheapest") {
+      cards = [...cards].sort((a, b) => {
+        return a.pricing.credits_per_call - b.pricing.credits_per_call;
+      });
+    } else if (sort === "newest") {
+      const createdStmt = db.prepare("SELECT id, created_at FROM capability_cards");
+      const createdRows = createdStmt.all();
+      const createdMap = new Map(createdRows.map((r) => [r.id, r.created_at]));
+      cards = [...cards].sort((a, b) => {
+        const aDate = createdMap.get(a.id) ?? "";
+        const bDate = createdMap.get(b.id) ?? "";
+        return bDate.localeCompare(aDate);
+      });
     } else if (sort === "latency") {
       cards = [...cards].sort((a, b) => {
         const aLatency = a.metadata?.avg_latency_ms ?? Infinity;
@@ -1853,9 +2222,32 @@ function createRegistryServer(opts) {
     }
     const total = cards.length;
     const items = cards.slice(offset, offset + limit).map(stripInternal);
-    const result = { total, limit, offset, items };
+    const usesThisWeek = {};
+    for (const [key, count] of usesMap) {
+      if (count > 0) usesThisWeek[key] = count;
+    }
+    const result = { total, limit, offset, items, uses_this_week: usesThisWeek };
     return reply.send(result);
   });
+  server.get("/api/cards/trending", async (_request, reply) => {
+    const trendingStmt = db.prepare(`
+      SELECT rl.card_id, COUNT(*) as recent_requests
+      FROM request_log rl
+      WHERE rl.status = 'success'
+        AND rl.created_at > datetime('now', '-7 days')
+        AND (rl.action_type IS NULL OR rl.action_type = 'auto_share')
+      GROUP BY rl.card_id
+      ORDER BY recent_requests DESC
+      LIMIT 10
+    `);
+    const trendingRows = trendingStmt.all();
+    const items = trendingRows.map((row) => {
+      const card = getCard(db, row.card_id);
+      if (!card) return null;
+      return { ...stripInternal(card), uses_this_week: row.recent_requests };
+    }).filter((item) => item !== null);
+    return reply.send({ items });
+  });
   server.get("/cards/:id", async (request, reply) => {
     const { id } = request.params;
     const card = getCard(db, id);
@@ -1864,6 +2256,57 @@ function createRegistryServer(opts) {
     }
     return reply.send(stripInternal(card));
   });
+  server.post("/cards", async (request, reply) => {
+    const body = request.body;
+    if (!body.spec_version) {
+      body.spec_version = "1.0";
+    }
+    const result = AnyCardSchema.safeParse(body);
+    if (!result.success) {
+      return reply.code(400).send({
+        error: "Card validation failed",
+        issues: result.error.issues
+      });
+    }
+    const card = result.data;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (card.spec_version === "2.0") {
+      const cardWithTimestamps = {
+        ...card,
+        created_at: card.created_at ?? now,
+        updated_at: now
+      };
+      db.prepare(
+        `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)`
+      ).run(
+        cardWithTimestamps.id,
+        cardWithTimestamps.owner,
+        JSON.stringify(cardWithTimestamps),
+        cardWithTimestamps.created_at,
+        cardWithTimestamps.updated_at
+      );
+    } else {
+      try {
+        insertCard(db, card);
+      } catch (err) {
+        if (err instanceof AgentBnBError && err.code === "VALIDATION_ERROR") {
+          return reply.code(400).send({ error: err.message });
+        }
+        throw err;
+      }
+    }
+    return reply.code(201).send({ ok: true, id: card.id });
+  });
+  server.delete("/cards/:id", async (request, reply) => {
+    const { id } = request.params;
+    const card = getCard(db, id);
+    if (!card) {
+      return reply.code(404).send({ error: "Not found" });
+    }
+    db.prepare("DELETE FROM capability_cards WHERE id = ?").run(id);
+    return reply.send({ ok: true, id });
+  });
   server.get("/api/agents", async (_request, reply) => {
     const allCards = listCards(db);
     const ownerMap = /* @__PURE__ */ new Map();
@@ -1955,6 +2398,86 @@ function createRegistryServer(opts) {
     const items = getActivityFeed(db, limit, since);
     return reply.send({ items, total: items.length, limit });
   });
+  server.get("/api/stats", async (_request, reply) => {
+    const allCards = listCards(db);
+    const onlineOwners = /* @__PURE__ */ new Set();
+    if (relayState) {
+      for (const owner of relayState.getOnlineOwners()) {
+        onlineOwners.add(owner);
+      }
+    }
+    for (const card of allCards) {
+      if (card.availability.online) {
+        onlineOwners.add(card.owner);
+      }
+    }
+    const exchangeStmt = db.prepare(
+      "SELECT COUNT(*) as count FROM request_log WHERE status = 'success' AND (action_type IS NULL OR action_type = 'auto_share')"
+    );
+    const exchangeRow = exchangeStmt.get();
+    return reply.send({
+      agents_online: onlineOwners.size,
+      total_capabilities: allCards.reduce((sum, card) => {
+        const v2 = card;
+        return sum + (v2.skills?.length ?? 1);
+      }, 0),
+      total_exchanges: exchangeRow.count
+    });
+  });
+  server.post("/api/identity/register", async (request, reply) => {
+    if (!opts.creditDb) {
+      return reply.code(503).send({ error: "Credit database not configured" });
+    }
+    const body = request.body;
+    const githubLogin = typeof body.github_login === "string" ? body.github_login.trim() : "";
+    if (!githubLogin) {
+      return reply.code(400).send({ error: "github_login is required" });
+    }
+    try {
+      const record = registerGuarantor(opts.creditDb, githubLogin);
+      const auth = initiateGithubAuth();
+      return reply.code(201).send({ guarantor: record, oauth: auth });
+    } catch (err) {
+      if (err instanceof AgentBnBError && err.code === "GUARANTOR_EXISTS") {
+        return reply.code(409).send({ error: err.message });
+      }
+      throw err;
+    }
+  });
+  server.post("/api/identity/link", async (request, reply) => {
+    if (!opts.creditDb) {
+      return reply.code(503).send({ error: "Credit database not configured" });
+    }
+    const body = request.body;
+    const agentId = typeof body.agent_id === "string" ? body.agent_id.trim() : "";
+    const githubLogin = typeof body.github_login === "string" ? body.github_login.trim() : "";
+    if (!agentId || !githubLogin) {
+      return reply.code(400).send({ error: "agent_id and github_login are required" });
+    }
+    try {
+      const record = linkAgentToGuarantor(opts.creditDb, agentId, githubLogin);
+      return reply.send({ guarantor: record });
+    } catch (err) {
+      if (err instanceof AgentBnBError) {
+        const statusMap = {
+          GUARANTOR_NOT_FOUND: 404,
+          MAX_AGENTS_EXCEEDED: 409,
+          AGENT_ALREADY_LINKED: 409
+        };
+        const status = statusMap[err.code] ?? 400;
+        return reply.code(status).send({ error: err.message });
+      }
+      throw err;
+    }
+  });
+  server.get("/api/identity/:agent_id", async (request, reply) => {
+    if (!opts.creditDb) {
+      return reply.code(503).send({ error: "Credit database not configured" });
+    }
+    const { agent_id } = request.params;
+    const guarantor = getAgentGuarantor(opts.creditDb, agent_id);
+    return reply.send({ agent_id, guarantor });
+  });
   if (opts.ownerApiKey && opts.ownerName) {
     const ownerApiKey = opts.ownerApiKey;
     const ownerName = opts.ownerName;
@@ -2061,7 +2584,7 @@ function createRegistryServer(opts) {
       });
     });
   }
-  return server;
+  return { server, relayState };
 }
 
 // src/discovery/mdns.ts
@@ -2135,10 +2658,10 @@ async function stopAnnouncement() {
 }
 
 // src/openclaw/soul-sync.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/skills/publish-capability.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function parseSoulMd(content) {
   const lines = content.split("\n");
   let name = "";
@@ -2209,7 +2732,7 @@ function parseSoulMdV2(content) {
   const parsed = parseSoulMd(content);
   const skills = parsed.capabilities.map((cap) => {
     const sanitizedId = cap.name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
-    const id = sanitizedId.length > 0 ? sanitizedId : randomUUID5();
+    const id = sanitizedId.length > 0 ? sanitizedId : randomUUID7();
     return {
       id,
       name: cap.name,
@@ -2251,7 +2774,7 @@ function publishFromSoulV2(db, soulContent, owner) {
     (c) => c.spec_version === "2.0"
   );
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const cardId = existingV2?.id ?? randomUUID5();
+  const cardId = existingV2?.id ?? randomUUID7();
   const card = {
     spec_version: "2.0",
     id: cardId,
@@ -2276,7 +2799,7 @@ function publishFromSoulV2(db, soulContent, owner) {
 }
 
 // src/openclaw/heartbeat-writer.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
 var HEARTBEAT_MARKER_START = "<!-- agentbnb:start -->";
 var HEARTBEAT_MARKER_END = "<!-- agentbnb:end -->";
 function generateHeartbeatSection(autonomy, budget) {
@@ -2312,11 +2835,11 @@ function generateHeartbeatSection(autonomy, budget) {
   ].join("\n");
 }
 function injectHeartbeatSection(heartbeatPath, section) {
-  if (!existsSync4(heartbeatPath)) {
+  if (!existsSync5(heartbeatPath)) {
     writeFileSync2(heartbeatPath, section + "\n", "utf-8");
     return;
   }
-  let content = readFileSync3(heartbeatPath, "utf-8");
+  let content = readFileSync4(heartbeatPath, "utf-8");
   const startIdx = content.indexOf(HEARTBEAT_MARKER_START);
   const endIdx = content.indexOf(HEARTBEAT_MARKER_END);
   if (startIdx !== -1 && endIdx !== -1) {
@@ -2365,7 +2888,7 @@ function getOpenClawStatus(config, db, creditDb) {
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../../package.json");
 async function confirm(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     return await new Promise((resolve) => {
       rl.question(question, (answer) => {
@@ -2387,12 +2910,12 @@ function getLanIp() {
 }
 var program = new Command();
 program.name("agentbnb").description("P2P Agent Capability Sharing Protocol \u2014 Airbnb for AI agent pipelines").version(pkg.version);
-program.command("init").description("Initialize AgentBnB config and create agent identity").option("--owner <name>", "Agent owner name").option("--port <port>", "Gateway port", "7700").option("--host <ip>", "Override gateway host IP (default: auto-detected LAN IP)").option("--yes", "Auto-confirm all draft cards (non-interactive)").option("--no-detect", "Skip API key detection").option("--json", "Output as JSON").action(async (opts) => {
+program.command("init").description("Initialize AgentBnB config and create agent identity").option("--owner <name>", "Agent owner name").option("--port <port>", "Gateway port", "7700").option("--host <ip>", "Override gateway host IP (default: auto-detected LAN IP)").option("--yes", "Auto-confirm all draft cards (non-interactive)").option("--no-detect", "Skip API key detection").option("--from <file>", "Parse a specific file for capability detection").option("--json", "Output as JSON").action(async (opts) => {
   const owner = opts.owner ?? `agent-${randomBytes(4).toString("hex")}`;
   const token = randomBytes(32).toString("hex");
   const configDir = getConfigDir();
-  const dbPath = join3(configDir, "registry.db");
-  const creditDbPath = join3(configDir, "credit.db");
+  const dbPath = join4(configDir, "registry.db");
+  const creditDbPath = join4(configDir, "credit.db");
   const port = parseInt(opts.port, 10);
   const ip = opts.host ?? getLanIp();
   const existingConfig = loadConfig();
@@ -2415,23 +2938,86 @@ program.command("init").description("Initialize AgentBnB config and create agent
     saveKeyPair(configDir, keys);
     keypairStatus = "generated";
   }
+  const identity = ensureIdentity(configDir, owner);
   const creditDb = openCreditDb(creditDbPath);
   bootstrapAgent(creditDb, owner, 100);
   creditDb.close();
   const skipDetect = opts.detect === false;
-  let detectedKeys = [];
-  let detectedPorts = [];
   const publishedCards = [];
+  let detectedSource = "none";
   if (!skipDetect) {
-    detectedKeys = detectApiKeys(KNOWN_API_KEYS);
-    detectedPorts = await detectOpenPorts([7700, 7701, 8080, 3e3, 8e3, 11434]);
-    if (detectedKeys.length > 0) {
+    if (!opts.json) {
+      console.log("\nDetecting capabilities...");
+    }
+    const result = detectCapabilities({ fromFile: opts.from, cwd: process.cwd() });
+    detectedSource = result.source;
+    if (result.source === "soul") {
+      if (!opts.json) {
+        console.log(`  Found SOUL.md \u2014 extracting capabilities...`);
+      }
+      const db = openDatabase(dbPath);
+      try {
+        const card = publishFromSoulV2(db, result.soulContent, owner);
+        publishedCards.push({ id: card.id, name: card.agent_name });
+        if (!opts.json) {
+          console.log(`  Published v2.0 card: ${card.agent_name} (${card.skills.length} skills)`);
+        }
+      } finally {
+        db.close();
+      }
+    } else if (result.source === "docs") {
       if (!opts.json) {
-        console.log(`
-Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${detectedKeys.join(", ")}`);
+        console.log(`  Found ${result.sourceFile ?? "docs"} \u2014 detected ${result.capabilities.length} capabilities:`);
+        for (const cap of result.capabilities) {
+          console.log(`    ${cap.name} (${cap.category}, cr ${cap.credits_per_call}/call)`);
+        }
       }
+      const card = capabilitiesToV2Card(result.capabilities, owner);
+      if (opts.yes) {
+        const db = openDatabase(dbPath);
+        try {
+          db.prepare(
+            `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?)`
+          ).run(card.id, card.owner, JSON.stringify(card), card.created_at, card.updated_at);
+          publishedCards.push({ id: card.id, name: card.agent_name });
+          if (!opts.json) {
+            console.log(`  Published v2.0 card: ${card.agent_name} (${card.skills.length} skills)`);
+          }
+        } finally {
+          db.close();
+        }
+      } else if (process.stdout.isTTY) {
+        const yes = await confirm(`
+Publish these ${card.skills.length} capabilities? [y/N] `);
+        if (yes) {
+          const db = openDatabase(dbPath);
+          try {
+            db.prepare(
+              `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+                 VALUES (?, ?, ?, ?, ?)`
+            ).run(card.id, card.owner, JSON.stringify(card), card.created_at, card.updated_at);
+            publishedCards.push({ id: card.id, name: card.agent_name });
+            console.log(`  Published v2.0 card: ${card.agent_name} (${card.skills.length} skills)`);
+          } finally {
+            db.close();
+          }
+        } else {
+          console.log("  Skipped publishing.");
+        }
+      } else {
+        if (!opts.json) {
+          console.log("  Non-interactive environment. Re-run with --yes to auto-publish.");
+        }
+      }
+    } else if (result.source === "env") {
+      const detectedKeys = result.envKeys ?? [];
+      if (!opts.json) {
+        console.log(`  Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${detectedKeys.join(", ")}`);
+      }
+      const detectedPorts = await detectOpenPorts([7700, 7701, 8080, 3e3, 8e3, 11434]);
       if (detectedPorts.length > 0 && !opts.json) {
-        console.log(`Found services on ports: ${detectedPorts.join(", ")}`);
+        console.log(`  Found services on ports: ${detectedPorts.join(", ")}`);
       }
       const drafts = detectedKeys.map((key) => buildDraftCard(key, owner)).filter((card) => card !== null);
       if (opts.yes) {
@@ -2441,7 +3027,7 @@ Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${
             insertCard(db, card);
             publishedCards.push({ id: card.id, name: card.name });
             if (!opts.json) {
-              console.log(`Published: ${card.name} (${card.id})`);
+              console.log(`  Published: ${card.name} (${card.id})`);
             }
           }
         } finally {
@@ -2455,9 +3041,9 @@ Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${
             if (yes) {
               insertCard(db, card);
               publishedCards.push({ id: card.id, name: card.name });
-              console.log(`Published: ${card.name} (${card.id})`);
+              console.log(`  Published: ${card.name} (${card.id})`);
             } else {
-              console.log(`Skipped: ${card.name}`);
+              console.log(`  Skipped: ${card.name}`);
             }
           }
         } finally {
@@ -2465,12 +3051,29 @@ Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${
         }
       } else {
         if (!opts.json) {
-          console.log("Non-interactive environment detected. Re-run with --yes to auto-publish draft cards.");
+          console.log("  Non-interactive environment. Re-run with --yes to auto-publish.");
         }
       }
     } else {
-      if (!opts.json) {
-        console.log("\nNo API keys detected. You can manually publish cards with `agentbnb publish`.");
+      if (process.stdout.isTTY && !opts.yes && !opts.json) {
+        const selected = await interactiveTemplateMenu();
+        if (selected.length > 0) {
+          const card = capabilitiesToV2Card(selected, owner);
+          const db = openDatabase(dbPath);
+          try {
+            db.prepare(
+              `INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at)
+                 VALUES (?, ?, ?, ?, ?)`
+            ).run(card.id, card.owner, JSON.stringify(card), card.created_at, card.updated_at);
+            publishedCards.push({ id: card.id, name: card.agent_name });
+            console.log(`
+  Published v2.0 card: ${card.agent_name} (${card.skills.length} skills)`);
+          } finally {
+            db.close();
+          }
+        }
+      } else if (!opts.json) {
+        console.log("  No capabilities detected. You can manually publish with `agentbnb publish`.");
       }
     }
   }
@@ -2481,10 +3084,11 @@ Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${
       config_dir: configDir,
       token,
       gateway_url: config.gateway_url,
-      keypair: keypairStatus
+      keypair: keypairStatus,
+      agent_id: identity.agent_id
     };
     if (!skipDetect) {
-      jsonOutput.detected_keys = detectedKeys;
+      jsonOutput.detected_source = detectedSource;
       jsonOutput.published_cards = publishedCards;
     }
     console.log(JSON.stringify(jsonOutput, null, 2));
@@ -2495,10 +3099,11 @@ Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${
     console.log(`  Config:  ${configDir}/config.json`);
     console.log(`  Credits: 100 (starter grant)`);
     console.log(`  Keypair: ${keypairStatus === "generated" ? "generated (Ed25519)" : "preserved (existing)"}`);
+    console.log(`  Agent ID: ${identity.agent_id}`);
     console.log(`  Gateway: http://${ip}:${port}`);
   }
 });
-program.command("publish <card.json>").description("Publish a Capability Card to the registry").option("--json", "Output as JSON").action(async (cardPath, opts) => {
+program.command("publish <card.json>").description("Publish a Capability Card to the registry (v1.0 or v2.0)").option("--json", "Output as JSON").option("--registry <url>", "POST card to a remote registry URL instead of local DB").action(async (cardPath, opts) => {
   const config = loadConfig();
   if (!config) {
     console.error("Error: not initialized. Run `agentbnb init` first.");
@@ -2506,7 +3111,7 @@ program.command("publish <card.json>").description("Publish a Capability Card to
   }
   let raw;
   try {
-    raw = readFileSync4(cardPath, "utf-8");
+    raw = readFileSync5(cardPath, "utf-8");
   } catch {
     console.error(`Error: cannot read file: ${cardPath}`);
     process.exit(1);
@@ -2518,7 +3123,10 @@ program.command("publish <card.json>").description("Publish a Capability Card to
     console.error("Error: invalid JSON in card file.");
     process.exit(1);
   }
-  const result = CapabilityCardSchema.safeParse(parsed);
+  if (typeof parsed === "object" && parsed !== null && !("spec_version" in parsed)) {
+    parsed.spec_version = "1.0";
+  }
+  const result = AnyCardSchema.safeParse(parsed);
   if (!result.success) {
     if (opts.json) {
       console.log(JSON.stringify({ success: false, errors: result.error.issues }, null, 2));
@@ -2530,16 +3138,56 @@ program.command("publish <card.json>").description("Publish a Capability Card to
     }
     process.exit(1);
   }
+  const card = result.data;
+  const cardName = card.spec_version === "2.0" ? card.agent_name : card.name;
   const db = openDatabase(config.db_path);
   try {
-    insertCard(db, result.data);
+    if (card.spec_version === "2.0") {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const cardWithTimestamps = { ...card, created_at: card.created_at ?? now, updated_at: now };
+      db.prepare(
+        "INSERT OR REPLACE INTO capability_cards (id, owner, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)"
+      ).run(cardWithTimestamps.id, cardWithTimestamps.owner, JSON.stringify(cardWithTimestamps), cardWithTimestamps.created_at, cardWithTimestamps.updated_at);
+    } else {
+      insertCard(db, card);
+    }
   } finally {
     db.close();
   }
+  if (!opts.json) {
+    console.log(`Published locally: ${cardName} (${card.id})`);
+  }
+  const registryUrl = opts.registry ?? config.registry;
+  let remoteSuccess = false;
+  if (registryUrl) {
+    const url = `${registryUrl.replace(/\/$/, "")}/cards`;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(card)
+      });
+      if (!response.ok) {
+        const body = await response.text();
+        console.error(`Warning: remote registry returned ${response.status}: ${body}`);
+      } else {
+        remoteSuccess = true;
+        if (!opts.json) {
+          console.log(`Published to registry: ${url}`);
+        }
+      }
+    } catch (err) {
+      console.error(`Warning: cannot reach registry at ${url}: ${err.message}`);
+    }
+  }
   if (opts.json) {
-    console.log(JSON.stringify({ success: true, id: result.data.id, name: result.data.name }, null, 2));
-  } else {
-    console.log(`Published: ${result.data.name} (${result.data.id})`);
+    console.log(JSON.stringify({
+      success: true,
+      id: card.id,
+      name: cardName,
+      ...registryUrl ? { registry: registryUrl, remote_published: remoteSuccess } : {}
+    }, null, 2));
+  } else if (!registryUrl) {
   }
 });
 program.command("discover [query]").description("Search available capabilities in the registry").option("--level <level>", "Filter by level (1, 2, or 3)").option("--online", "Only show online capabilities").option("--local", "Browse for agents on the local network via mDNS").option("--registry <url>", "Remote registry URL to query (e.g., http://host:7701)").option("--tag <tag>", "Filter by metadata tag").option("--json", "Output as JSON").action(async (query, opts) => {
@@ -2558,7 +3206,7 @@ program.command("discover [query]").description("Search available capabilities i
       console.log("No agents found on local network.");
       return;
     }
-    const col2 = (s, w) => s.slice(0, w).padEnd(w);
+    const col2 = (s, w) => (s ?? "").slice(0, w).padEnd(w);
     console.log(col2("Name", 24) + "  " + col2("URL", 32) + "  " + col2("Owner", 20));
     console.log("-".repeat(80));
     for (const agent of discovered) {
@@ -2628,7 +3276,7 @@ ${discovered.length} agent(s) found on local network`);
     console.log("No capabilities found.");
     return;
   }
-  const col = (s, w) => s.slice(0, w).padEnd(w);
+  const col = (s, w) => (s ?? "").slice(0, w).padEnd(w);
   if (hasRemote) {
     console.log(
       col("ID", 16) + "  " + col("Name", 28) + "  " + col("Lvl", 3) + "  " + col("Credits", 7) + "  " + col("Online", 6) + "  " + col("Source", 8)
@@ -2636,10 +3284,11 @@ ${discovered.length} agent(s) found on local network`);
     console.log("-".repeat(80));
     for (const card of outputCards) {
       const shortId = card.id.slice(0, 8) + "...";
+      const displayName = card.name ?? card.agent_name ?? "";
       const source = "source" in card ? card.source : "local";
       const sourceTag = source === "remote" ? "[remote]" : "[local]";
       console.log(
-        col(shortId, 16) + "  " + col(card.name, 28) + "  " + col(String(card.level), 3) + "  " + col(String(card.pricing.credits_per_call), 7) + "  " + col(card.availability.online ? "yes" : "no", 6) + "  " + col(sourceTag, 8)
+        col(shortId, 16) + "  " + col(displayName, 28) + "  " + col(String(card.level ?? ""), 3) + "  " + col(String(card.pricing?.credits_per_call ?? ""), 7) + "  " + col(card.availability?.online ? "yes" : "no", 6) + "  " + col(sourceTag, 8)
       );
     }
   } else {
@@ -2649,8 +3298,9 @@ ${discovered.length} agent(s) found on local network`);
     console.log("-".repeat(72));
     for (const card of outputCards) {
       const shortId = card.id.slice(0, 8) + "...";
+      const displayName = card.name ?? card.agent_name ?? "";
       console.log(
-        col(shortId, 16) + "  " + col(card.name, 32) + "  " + col(String(card.level), 3) + "  " + col(String(card.pricing.credits_per_call), 7) + "  " + col(card.availability.online ? "yes" : "no", 6)
+        col(shortId, 16) + "  " + col(displayName, 32) + "  " + col(String(card.level ?? ""), 3) + "  " + col(String(card.pricing?.credits_per_call ?? ""), 7) + "  " + col(card.availability?.online ? "yes" : "no", 6)
       );
     }
   }
@@ -2673,8 +3323,8 @@ program.command("request [card-id]").description("Request a capability from anot
         process.exit(1);
       }
     }
-    const registryDb = openDatabase(join3(getConfigDir(), "registry.db"));
-    const creditDb = openCreditDb(join3(getConfigDir(), "credit.db"));
+    const registryDb = openDatabase(join4(getConfigDir(), "registry.db"));
+    const creditDb = openCreditDb(join4(getConfigDir(), "credit.db"));
     registryDb.pragma("busy_timeout = 5000");
     creditDb.pragma("busy_timeout = 5000");
     try {
@@ -2733,7 +3383,7 @@ program.command("request [card-id]").description("Request a capability from anot
   let escrowReceipt;
   if (useReceipt) {
     const configDir = getConfigDir();
-    const creditDb = openCreditDb(join3(configDir, "credit.db"));
+    const creditDb = openCreditDb(join4(configDir, "credit.db"));
     creditDb.pragma("busy_timeout = 5000");
     try {
       const keys = loadKeyPair(configDir);
@@ -2774,7 +3424,7 @@ program.command("request [card-id]").description("Request a capability from anot
     });
     if (useReceipt && escrowId) {
       const configDir = getConfigDir();
-      const creditDb = openCreditDb(join3(configDir, "credit.db"));
+      const creditDb = openCreditDb(join4(configDir, "credit.db"));
       creditDb.pragma("busy_timeout = 5000");
       try {
         settleRequesterEscrow(creditDb, escrowId);
@@ -2794,7 +3444,7 @@ program.command("request [card-id]").description("Request a capability from anot
   } catch (err) {
     if (useReceipt && escrowId) {
       const configDir = getConfigDir();
-      const creditDb = openCreditDb(join3(configDir, "credit.db"));
+      const creditDb = openCreditDb(join4(configDir, "credit.db"));
       creditDb.pragma("busy_timeout = 5000");
       try {
         releaseRequesterEscrow(creditDb, escrowId);
@@ -2849,12 +3499,12 @@ Active Escrows (${heldEscrows.length}):`);
   if (transactions.length > 0) {
     console.log("\nRecent Transactions:");
     for (const tx of transactions) {
-      const sign2 = tx.amount > 0 ? "+" : "";
-      console.log(`  ${tx.created_at.slice(0, 19)}  ${sign2}${tx.amount}  ${tx.reason}`);
+      const sign = tx.amount > 0 ? "+" : "";
+      console.log(`  ${tx.created_at.slice(0, 19)}  ${sign}${tx.amount}  ${tx.reason}`);
     }
   }
 });
-program.command("serve").description("Start the AgentBnB gateway server").option("--port <port>", "Port to listen on (overrides config)").option("--handler-url <url>", "Local capability handler URL", "http://localhost:8080").option("--skills-yaml <path>", "Path to skills.yaml (default: ~/.agentbnb/skills.yaml)").option("--registry-port <port>", "Public registry API port (0 to disable)", "7701").option("--conductor", "Enable Conductor orchestration mode").option("--announce", "Announce this gateway on the local network via mDNS").action(async (opts) => {
+program.command("serve").description("Start the AgentBnB gateway server").option("--port <port>", "Port to listen on (overrides config)").option("--handler-url <url>", "Local capability handler URL", "http://localhost:8080").option("--skills-yaml <path>", "Path to skills.yaml (default: ~/.agentbnb/skills.yaml)").option("--registry-port <port>", "Public registry API port (0 to disable)", "7701").option("--registry <url>", "Connect to remote registry via WebSocket relay (e.g., hub.agentbnb.dev)").option("--conductor", "Enable Conductor orchestration mode").option("--announce", "Announce this gateway on the local network via mDNS").action(async (opts) => {
   const config = loadConfig();
   if (!config) {
     console.error("Error: not initialized. Run `agentbnb init` first.");
@@ -2862,7 +3512,7 @@ program.command("serve").description("Start the AgentBnB gateway server").option
   }
   const port = opts.port ? parseInt(opts.port, 10) : config.gateway_port;
   const registryPort = parseInt(opts.registryPort, 10);
-  const skillsYamlPath = opts.skillsYaml ?? join3(homedir(), ".agentbnb", "skills.yaml");
+  const skillsYamlPath = opts.skillsYaml ?? join4(homedir(), ".agentbnb", "skills.yaml");
   const runtime = new AgentRuntime({
     registryDbPath: config.db_path,
     creditDbPath: config.credit_db_path,
@@ -2895,14 +3545,18 @@ program.command("serve").description("Start the AgentBnB gateway server").option
     handlerUrl: opts.handlerUrl,
     skillExecutor: runtime.skillExecutor
   });
-  let registryServer = null;
+  let registryFastify = null;
+  let relayClient = null;
   const gracefulShutdown = async () => {
     console.log("\nShutting down...");
+    if (relayClient) {
+      relayClient.disconnect();
+    }
     if (opts.announce) {
       await stopAnnouncement();
     }
-    if (registryServer) {
-      await registryServer.close();
+    if (registryFastify) {
+      await registryFastify.close();
     }
     await server.close();
     await runtime.shutdown();
@@ -2921,15 +3575,66 @@ program.command("serve").description("Start the AgentBnB gateway server").option
       if (!config.api_key) {
         console.warn("No API key found. Run `agentbnb init` to enable dashboard features.");
       }
-      registryServer = createRegistryServer({
+      const { server: regServer, relayState } = createRegistryServer({
         registryDb: runtime.registryDb,
         silent: false,
         ownerName: config.owner,
         ownerApiKey: config.api_key,
         creditDb: runtime.creditDb
       });
-      await registryServer.listen({ port: registryPort, host: "0.0.0.0" });
+      registryFastify = regServer;
+      await registryFastify.listen({ port: registryPort, host: "0.0.0.0" });
       console.log(`Registry API: http://0.0.0.0:${registryPort}/cards`);
+      if (relayState) {
+        console.log(`WebSocket relay active on /ws`);
+      }
+    }
+    if (opts.registry) {
+      const { RelayClient } = await import("../websocket-client-5TIQDYQ4.js");
+      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("../execute-NZXTSSVV.js");
+      const cards = listCards(runtime.registryDb, config.owner);
+      const card = cards[0] ?? {
+        id: config.owner,
+        owner: config.owner,
+        name: config.owner,
+        description: "Agent registered via CLI",
+        spec_version: "1.0",
+        level: 1,
+        inputs: [],
+        outputs: [],
+        pricing: { credits_per_call: 0 },
+        availability: { online: true }
+      };
+      relayClient = new RelayClient({
+        registryUrl: opts.registry,
+        owner: config.owner,
+        token: config.token,
+        card,
+        onRequest: async (req) => {
+          const result = await executeCapabilityRequest2({
+            registryDb: runtime.registryDb,
+            creditDb: runtime.creditDb,
+            cardId: req.card_id,
+            skillId: req.skill_id,
+            params: req.params,
+            requester: req.requester ?? req.from_owner,
+            escrowReceipt: req.escrow_receipt,
+            skillExecutor: runtime.skillExecutor,
+            handlerUrl: opts.handlerUrl
+          });
+          if (result.success) {
+            return { result: result.result };
+          }
+          return { error: { code: result.error.code, message: result.error.message } };
+        }
+      });
+      try {
+        await relayClient.connect();
+        console.log(`Connected to registry: ${opts.registry}`);
+      } catch (err) {
+        console.warn(`Warning: could not connect to registry ${opts.registry}: ${err instanceof Error ? err.message : err}`);
+        console.warn("Will auto-reconnect in background...");
+      }
     }
     if (opts.announce) {
       announceGateway(config.owner, port);
@@ -2937,8 +3642,9 @@ program.command("serve").description("Start the AgentBnB gateway server").option
     }
   } catch (err) {
     console.error("Failed to start:", err);
-    if (registryServer) {
-      await registryServer.close().catch(() => {
+    if (relayClient) relayClient.disconnect();
+    if (registryFastify) {
+      await registryFastify.close().catch(() => {
       });
     }
     await runtime.shutdown();
@@ -2969,7 +3675,7 @@ peersCommand.option("--json", "Output as JSON").action(async (opts) => {
     console.log("No peers registered. Use `agentbnb connect` to add one.");
     return;
   }
-  const col = (s, w) => s.slice(0, w).padEnd(w);
+  const col = (s, w) => (s ?? "").slice(0, w).padEnd(w);
   console.log(col("Name", 20) + "  " + col("URL", 36) + "  " + col("Added", 20));
   console.log("-".repeat(80));
   for (const peer of peers) {
@@ -3093,7 +3799,7 @@ openclaw.command("sync").description("Read SOUL.md and publish/update a v2.0 cap
   }
   let content;
   try {
-    content = readFileSync4(opts.soulPath, "utf-8");
+    content = readFileSync5(opts.soulPath, "utf-8");
   } catch {
     console.error(`Error: cannot read SOUL.md at ${opts.soulPath}`);
     process.exit(1);
@@ -3154,7 +3860,7 @@ openclaw.command("rules").description("Print HEARTBEAT.md rules block (or inject
   }
 });
 program.command("conduct <task>").description("Orchestrate a complex task across the AgentBnB network").option("--plan-only", "Show execution plan without executing").option("--max-budget <credits>", "Maximum credits to spend", "100").option("--json", "Output as JSON").action(async (task, opts) => {
-  const { conductAction } = await import("../conduct-JZJS2ZHA.js");
+  const { conductAction } = await import("../conduct-5T3LGXMF.js");
   const result = await conductAction(task, opts);
   if (opts.json) {
     console.log(JSON.stringify(result, null, 2));