agentbnb 3.1.0 → 3.1.2

package/dist/cli/index.js

@@ -7,7 +7,7 @@ import {
   saveKeyPair,
   settleRequesterEscrow,
   signEscrowReceipt
-} from "../chunk-4Q7D24DP.js";
+} from "../chunk-SVEZBIGE.js";
 import {
   RelayMessageSchema
 } from "../chunk-3Y36WQDV.js";
@@ -24,7 +24,7 @@ import {
   requestCapability,
   resolvePendingRequest,
   searchCards
-} from "../chunk-QVIGMCHA.js";
+} from "../chunk-KTHJ5F3X.js";
 import {
   findPeer,
   getConfigDir,
@@ -46,7 +46,7 @@ import {
   updateCard,
   updateSkillAvailability,
   updateSkillIdleRate
-} from "../chunk-2LLXUKMY.js";
+} from "../chunk-UOGDK2S2.js";
 import {
   bootstrapAgent,
   getBalance,
@@ -54,35 +54,115 @@ import {
   holdEscrow,
   openCreditDb,
   releaseEscrow
-} from "../chunk-ZJCIBK6O.js";
+} from "../chunk-QVV2P3FN.js";
 import {
   AgentBnBError,
-  CapabilityCardSchema,
+  AnyCardSchema,
   CapabilityCardV2Schema
-} from "../chunk-TQMI73LL.js";
+} from "../chunk-XA63SD4T.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { createRequire } from "module";
 import { randomBytes } from "crypto";
-import { join as join2 } 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/escrow-receipt.ts
+// src/identity/identity.ts
 import { z } 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(),
+import { createHash } from "crypto";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+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 createIdentity(configDir, owner) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  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 loadIdentity(configDir) {
+  const filePath = join(configDir, IDENTITY_FILENAME);
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return AgentIdentitySchema.parse(JSON.parse(raw));
+  } catch {
+    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 as z2 } from "zod";
+import { randomUUID } from "crypto";
+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);
   const receiptData = {
@@ -447,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, existsSync } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 
 // src/skills/executor.ts
 var SkillExecutor = class {
@@ -531,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) => {
@@ -1259,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 && existsSync(this.skillsYamlPath);
+    const hasSkillsYaml = this.skillsYamlPath && existsSync3(this.skillsYamlPath);
     if (!hasSkillsYaml && !this.conductorEnabled) {
       return;
     }
     let configs = [];
     if (hasSkillsYaml) {
-      const yamlContent = readFileSync(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-CF6PSRRA.js");
-      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../card-P5C36VBD.js");
+      const { ConductorMode } = await import("../conductor-mode-6MIVMFBC.js");
+      const { registerConductorCard, CONDUCTOR_OWNER } = await import("../card-IE5UV5QX.js");
       const { loadPeers: loadPeers2 } = await import("../peers-G36URZYB.js");
       registerConductorCard(this.registryDb);
       const resolveAgentUrl = (owner) => {
@@ -1468,12 +1723,12 @@ import Fastify2 from "fastify";
 import cors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
 import fastifyWebsocket from "@fastify/websocket";
-import { join, dirname } from "path";
+import { join as join3, dirname } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var RATE_LIMIT_MAX = 60;
 var RATE_LIMIT_WINDOW_MS = 6e4;
 var RELAY_TIMEOUT_MS = 3e4;
@@ -1545,7 +1800,7 @@ function registerWebSocketRelay(server, db) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID3(),
+        id: randomUUID4(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -1645,7 +1900,8 @@ function registerWebSocketRelay(server, db) {
       }
     }
   }
-  server.get("/ws", { websocket: true }, (socket) => {
+  server.get("/ws", { websocket: true }, (rawSocket, _request) => {
+    const socket = rawSocket;
     let registeredOwner;
     socket.on("message", (raw) => {
       let data;
@@ -1715,6 +1971,125 @@ function registerWebSocketRelay(server, db) {
   };
 }
 
+// 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
 function stripInternal(card) {
   const { _internal: _, ...publicCard } = card;
@@ -1736,17 +2111,20 @@ function createRegistryServer(opts) {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
   const hubDistCandidates = [
-    join(__dirname, "../../hub/dist"),
+    join3(__dirname, "../../hub/dist"),
     // When running from dist/registry/server.js
-    join(__dirname, "../../../hub/dist")
+    join3(__dirname, "../../../hub/dist")
     // Fallback for alternative layouts
   ];
-  const hubDistDir = hubDistCandidates.find((p) => existsSync2(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/");
     });
@@ -1794,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;
@@ -1809,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);
@@ -1820,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();
@@ -1930,10 +2417,67 @@ function createRegistryServer(opts) {
     const exchangeRow = exchangeStmt.get();
     return reply.send({
       agents_online: onlineOwners.size,
-      total_capabilities: allCards.length,
+      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;
@@ -2114,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 = "";
@@ -2188,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,
@@ -2230,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,
@@ -2255,7 +2799,7 @@ function publishFromSoulV2(db, soulContent, owner) {
 }
 
 // src/openclaw/heartbeat-writer.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3 } 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) {
@@ -2291,11 +2835,11 @@ function generateHeartbeatSection(autonomy, budget) {
   ].join("\n");
 }
 function injectHeartbeatSection(heartbeatPath, section) {
-  if (!existsSync3(heartbeatPath)) {
-    writeFileSync(heartbeatPath, section + "\n", "utf-8");
+  if (!existsSync5(heartbeatPath)) {
+    writeFileSync2(heartbeatPath, section + "\n", "utf-8");
     return;
   }
-  let content = readFileSync2(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) {
@@ -2303,7 +2847,7 @@ function injectHeartbeatSection(heartbeatPath, section) {
   } else {
     content = content + "\n" + section + "\n";
   }
-  writeFileSync(heartbeatPath, content, "utf-8");
+  writeFileSync2(heartbeatPath, content, "utf-8");
 }
 
 // src/openclaw/skill.ts
@@ -2344,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) => {
@@ -2366,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 = join2(configDir, "registry.db");
-  const creditDbPath = join2(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();
@@ -2394,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(`
-Detected ${detectedKeys.length} API key${detectedKeys.length > 1 ? "s" : ""}: ${detectedKeys.join(", ")}`);
+        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(`  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) {
@@ -2420,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 {
@@ -2434,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 {
@@ -2444,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`.");
       }
     }
   }
@@ -2460,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));
@@ -2474,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.");
@@ -2485,7 +3111,7 @@ program.command("publish <card.json>").description("Publish a Capability Card to
   }
   let raw;
   try {
-    raw = readFileSync3(cardPath, "utf-8");
+    raw = readFileSync5(cardPath, "utf-8");
   } catch {
     console.error(`Error: cannot read file: ${cardPath}`);
     process.exit(1);
@@ -2497,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));
@@ -2509,16 +3138,128 @@ 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 {
+    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`;
+    const remoteCard = { ...card, gateway_url: config.gateway_url };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(remoteCard)
+      });
+      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: card.id,
+      name: cardName,
+      ...registryUrl ? { registry: registryUrl, remote_published: remoteSuccess } : {}
+    }, null, 2));
+  } else if (!registryUrl) {
+  }
+});
+program.command("sync").description("Push all local capability cards to the configured remote registry").option("--registry <url>", "Remote registry URL (overrides config.registry)").option("--json", "Output as JSON").action(async (opts) => {
+  const config = loadConfig();
+  if (!config) {
+    console.error("Error: not initialized. Run `agentbnb init` first.");
+    process.exit(1);
+  }
+  const registryUrl = opts.registry ?? config.registry;
+  if (!registryUrl) {
+    console.error("Error: no remote registry configured.");
+    console.error("Set one with: agentbnb config set registry <url>");
+    process.exit(1);
+  }
   const db = openDatabase(config.db_path);
+  let localCards;
   try {
-    insertCard(db, result.data);
+    localCards = listCards(db);
   } finally {
     db.close();
   }
+  if (localCards.length === 0) {
+    if (opts.json) {
+      console.log(JSON.stringify({ synced: 0, failed: 0, registry: registryUrl }));
+    } else {
+      console.log("No local cards to sync.");
+    }
+    return;
+  }
+  const url = `${registryUrl.replace(/\/$/, "")}/cards`;
+  let synced = 0;
+  let failed = 0;
+  const results = [];
+  for (const card of localCards) {
+    const { _internal: _, ...publicCard } = card;
+    const remoteCard = { ...publicCard, gateway_url: config.gateway_url };
+    const displayName = card.name ?? card.agent_name ?? card.id;
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(remoteCard)
+      });
+      if (response.ok) {
+        synced++;
+        results.push({ id: card.id, name: displayName, ok: true });
+        if (!opts.json) {
+          console.log(`  Synced: ${displayName} (${card.id.slice(0, 8)}...)`);
+        }
+      } else {
+        const body = await response.text();
+        failed++;
+        results.push({ id: card.id, name: displayName, ok: false, error: `${response.status}: ${body}` });
+        if (!opts.json) {
+          console.error(`  Failed: ${displayName} \u2014 ${response.status}`);
+        }
+      }
+    } catch (err) {
+      failed++;
+      const msg = err instanceof Error ? err.message : String(err);
+      results.push({ id: card.id, name: displayName, ok: false, error: msg });
+      if (!opts.json) {
+        console.error(`  Failed: ${displayName} \u2014 ${msg}`);
+      }
+    }
+  }
   if (opts.json) {
-    console.log(JSON.stringify({ success: true, id: result.data.id, name: result.data.name }, null, 2));
+    console.log(JSON.stringify({ synced, failed, registry: registryUrl, results }, null, 2));
   } else {
-    console.log(`Published: ${result.data.name} (${result.data.id})`);
+    console.log(`
+Synced ${synced}/${localCards.length} cards to ${registryUrl}${failed > 0 ? ` (${failed} failed)` : ""}`);
   }
 });
 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) => {
@@ -2537,7 +3278,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) {
@@ -2607,7 +3348,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)
@@ -2615,10 +3356,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 {
@@ -2628,8 +3370,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)
       );
     }
   }
@@ -2652,8 +3395,8 @@ program.command("request [card-id]").description("Request a capability from anot
         process.exit(1);
       }
     }
-    const registryDb = openDatabase(join2(getConfigDir(), "registry.db"));
-    const creditDb = openCreditDb(join2(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 {
@@ -2690,7 +3433,7 @@ program.command("request [card-id]").description("Request a capability from anot
   }
   let gatewayUrl;
   let token;
-  const isPeerRequest = !!opts.peer;
+  let isRemoteRequest = false;
   if (opts.peer) {
     const peer = findPeer(opts.peer);
     if (!peer) {
@@ -2699,20 +3442,61 @@ program.command("request [card-id]").description("Request a capability from anot
     }
     gatewayUrl = peer.url;
     token = peer.token;
+    isRemoteRequest = true;
   } else {
-    gatewayUrl = config.gateway_url;
-    token = config.token;
+    const db = openDatabase(config.db_path);
+    let localCard;
+    try {
+      localCard = db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId) ? JSON.parse(db.prepare("SELECT data FROM capability_cards WHERE id = ?").get(cardId).data) : void 0;
+    } finally {
+      db.close();
+    }
+    if (localCard) {
+      gatewayUrl = config.gateway_url;
+      token = config.token;
+    } else {
+      const registryUrl = config.registry;
+      if (!registryUrl) {
+        console.error("Error: card not found locally and no remote registry configured.");
+        console.error("Set one with: agentbnb config set registry <url>");
+        process.exit(1);
+      }
+      const cardUrl = `${registryUrl.replace(/\/$/, "")}/cards/${cardId}`;
+      let remoteCard;
+      try {
+        const resp = await fetch(cardUrl);
+        if (!resp.ok) {
+          console.error(`Error: card ${cardId} not found on remote registry (${resp.status}).`);
+          process.exit(1);
+        }
+        remoteCard = await resp.json();
+      } catch (err) {
+        console.error(`Error: cannot reach registry: ${err.message}`);
+        process.exit(1);
+      }
+      if (!remoteCard.gateway_url || typeof remoteCard.gateway_url !== "string") {
+        console.error("Error: remote card has no gateway_url. The provider needs to re-publish with `agentbnb sync`.");
+        process.exit(1);
+      }
+      gatewayUrl = remoteCard.gateway_url;
+      token = "";
+      isRemoteRequest = true;
+      if (!opts.json) {
+        const displayName = remoteCard.name ?? remoteCard.agent_name ?? cardId;
+        console.log(`Found remote card: ${displayName} @ ${gatewayUrl}`);
+      }
+    }
   }
-  const useReceipt = isPeerRequest && opts.receipt !== false;
+  const useReceipt = isRemoteRequest && opts.receipt !== false;
   if (useReceipt && !opts.cost) {
-    console.error("Error: --cost <credits> is required for peer requests. Specify the credits to commit.");
+    console.error("Error: --cost <credits> is required for remote requests. Specify the credits to commit.");
     process.exit(1);
   }
   let escrowId;
   let escrowReceipt;
   if (useReceipt) {
     const configDir = getConfigDir();
-    const creditDb = openCreditDb(join2(configDir, "credit.db"));
+    const creditDb = openCreditDb(join4(configDir, "credit.db"));
     creditDb.pragma("busy_timeout = 5000");
     try {
       const keys = loadKeyPair(configDir);
@@ -2753,7 +3537,7 @@ program.command("request [card-id]").description("Request a capability from anot
     });
     if (useReceipt && escrowId) {
       const configDir = getConfigDir();
-      const creditDb = openCreditDb(join2(configDir, "credit.db"));
+      const creditDb = openCreditDb(join4(configDir, "credit.db"));
       creditDb.pragma("busy_timeout = 5000");
       try {
         settleRequesterEscrow(creditDb, escrowId);
@@ -2773,7 +3557,7 @@ program.command("request [card-id]").description("Request a capability from anot
   } catch (err) {
     if (useReceipt && escrowId) {
       const configDir = getConfigDir();
-      const creditDb = openCreditDb(join2(configDir, "credit.db"));
+      const creditDb = openCreditDb(join4(configDir, "credit.db"));
       creditDb.pragma("busy_timeout = 5000");
       try {
         releaseRequesterEscrow(creditDb, escrowId);
@@ -2841,7 +3625,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 ?? join2(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,
@@ -2920,7 +3704,7 @@ program.command("serve").description("Start the AgentBnB gateway server").option
     }
     if (opts.registry) {
       const { RelayClient } = await import("../websocket-client-5TIQDYQ4.js");
-      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("../execute-3T5RF3DP.js");
+      const { executeCapabilityRequest: executeCapabilityRequest2 } = await import("../execute-HM25IOG7.js");
       const cards = listCards(runtime.registryDb, config.owner);
       const card = cards[0] ?? {
         id: config.owner,
@@ -3004,7 +3788,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) {
@@ -3128,7 +3912,7 @@ openclaw.command("sync").description("Read SOUL.md and publish/update a v2.0 cap
   }
   let content;
   try {
-    content = readFileSync3(opts.soulPath, "utf-8");
+    content = readFileSync5(opts.soulPath, "utf-8");
   } catch {
     console.error(`Error: cannot read SOUL.md at ${opts.soulPath}`);
     process.exit(1);
@@ -3189,7 +3973,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-M57F72RK.js");
+  const { conductAction } = await import("../conduct-5XKKALNX.js");
   const result = await conductAction(task, opts);
   if (opts.json) {
     console.log(JSON.stringify(result, null, 2));