agentbnb 8.3.2 → 8.4.1

package/dist/chunk-PIPCGRCR.js

@@ -0,0 +1,91 @@
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/cli/remote-registry.ts
+var RegistryTimeoutError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Registry at ${url} did not respond within 5s. Showing local results only.`,
+      "REGISTRY_TIMEOUT"
+    );
+    this.name = "RegistryTimeoutError";
+  }
+};
+var RegistryConnectionError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Cannot reach ${url}. Is the registry running? Showing local results only.`,
+      "REGISTRY_CONNECTION"
+    );
+    this.name = "RegistryConnectionError";
+  }
+};
+var RegistryAuthError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Authentication failed for ${url}. Run \`agentbnb config set token <your-token>\`.`,
+      "REGISTRY_AUTH"
+    );
+    this.name = "RegistryAuthError";
+  }
+};
+async function fetchRemoteCards(registryUrl, params, timeoutMs = 5e3) {
+  let cardsUrl;
+  try {
+    cardsUrl = new URL("/cards", registryUrl);
+  } catch {
+    throw new AgentBnBError(`Invalid registry URL: ${registryUrl}`, "INVALID_REGISTRY_URL");
+  }
+  const searchParams = new URLSearchParams();
+  if (params.q !== void 0) searchParams.set("q", params.q);
+  if (params.level !== void 0) searchParams.set("level", String(params.level));
+  if (params.online !== void 0) searchParams.set("online", String(params.online));
+  if (params.tag !== void 0) searchParams.set("tag", params.tag);
+  searchParams.set("limit", "100");
+  cardsUrl.search = searchParams.toString();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(cardsUrl.toString(), { signal: controller.signal });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    if (isTimeout) {
+      throw new RegistryTimeoutError(registryUrl);
+    }
+    throw new RegistryConnectionError(registryUrl);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new RegistryAuthError(registryUrl);
+  }
+  if (!response.ok) {
+    throw new RegistryConnectionError(registryUrl);
+  }
+  const body = await response.json();
+  return body.items;
+}
+function mergeResults(localCards, remoteCards, hasQuery) {
+  const taggedLocal = localCards.map((c) => ({ ...c, source: "local" }));
+  const taggedRemote = remoteCards.map((c) => ({ ...c, source: "remote" }));
+  const localIds = new Set(localCards.map((c) => c.id));
+  const dedupedRemote = taggedRemote.filter((c) => !localIds.has(c.id));
+  if (!hasQuery) {
+    return [...taggedLocal, ...dedupedRemote];
+  }
+  const result = [];
+  const maxLen = Math.max(taggedLocal.length, dedupedRemote.length);
+  for (let i = 0; i < maxLen; i++) {
+    if (i < taggedLocal.length) result.push(taggedLocal[i]);
+    if (i < dedupedRemote.length) result.push(dedupedRemote[i]);
+  }
+  return result;
+}
+
+export {
+  fetchRemoteCards,
+  mergeResults
+};

package/dist/{chunk-QFPXZITP.js → chunk-PMRTQ2RL.js}

@@ -41,6 +41,29 @@ async function notifyTelegramSkillExecuted(opts) {
     body: JSON.stringify({ chat_id: chatId, text })
   });
 }
+async function notifyTelegramSkillFailed(opts) {
+  const cfg = loadConfig();
+  if (!cfg?.telegram_notifications) return;
+  const token = cfg.telegram_bot_token ?? process.env["TELEGRAM_BOT_TOKEN"];
+  const chatId = cfg.telegram_chat_id ?? process.env["TELEGRAM_CHAT_ID"];
+  if (!token || !chatId) return;
+  const balance = getBalance(opts.creditDb, opts.owner);
+  const skillLabel = opts.skillId ? `${opts.skillName} (${opts.skillId})` : opts.skillName;
+  const text = [
+    "[AgentBnB] Skill failed",
+    `Skill: ${skillLabel}`,
+    `Requester: ${opts.requester}`,
+    `Reason: ${opts.failureReason}`,
+    `Error: ${opts.message}`,
+    `Balance: ${balance} credits`,
+    `Latency: ${opts.latencyMs}ms`
+  ].join("\n");
+  await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text })
+  });
+}
 async function executeCapabilityRequest(opts) {
   const {
     registryDb,
@@ -141,6 +164,17 @@ async function executeCapabilityRequest(opts) {
       });
     } catch {
     }
+    notifyTelegramSkillFailed({
+      creditDb,
+      owner: card.owner,
+      skillName: cardName,
+      skillId: resolvedSkillId ?? null,
+      requester,
+      latencyMs,
+      failureReason,
+      message
+    }).catch(() => {
+    });
     return { success: false, error: { code: -32603, message } };
   };
   const handleSuccess = (result, latencyMs) => {

package/dist/{chunk-7IQE34QK.js → chunk-UF6R2RVN.js}

@@ -3,11 +3,13 @@ import {
 } from "./chunk-3MJT4PZG.js";
 import {
   scorePeers
-} from "./chunk-D242QZCR.js";
+} from "./chunk-6XCN62YU.js";
+import {
+  fetchRemoteCards
+} from "./chunk-PIPCGRCR.js";
 import {
-  fetchRemoteCards,
   searchCards
-} from "./chunk-F3KIEVJ2.js";
+} from "./chunk-HU46M4JA.js";
 import {
   requestCapability,
   requestCapabilityBatch

package/dist/{chunk-IGQNP3ZO.js → chunk-VAAEBCMU.js}

@@ -1,6 +1,6 @@
 import {
   insertCard
-} from "./chunk-5AIYALBX.js";
+} from "./chunk-COA2D7QM.js";
 import {
   CapabilityCardSchema
 } from "./chunk-I7KWA7OB.js";

package/dist/chunk-VRPLSK34.js

@@ -0,0 +1,214 @@
+import {
+  AgentBnBError
+} from "./chunk-I7KWA7OB.js";
+
+// src/discovery/mdns.ts
+import { Bonjour } from "bonjour-service";
+var bonjourInstance = null;
+function getBonjour() {
+  if (bonjourInstance === null) {
+    bonjourInstance = new Bonjour();
+  }
+  return bonjourInstance;
+}
+function announceGateway(owner, port, metadata) {
+  const bonjour = getBonjour();
+  const txt = {
+    owner,
+    version: "1.0",
+    ...metadata
+  };
+  bonjour.publish({
+    name: owner,
+    type: "agentbnb",
+    port,
+    txt
+  });
+}
+function discoverLocalAgents(onFound, onDown) {
+  const bonjour = getBonjour();
+  const browser = bonjour.find({ type: "agentbnb" });
+  browser.on("up", (service) => {
+    const addresses = service.addresses ?? [];
+    const ipv4Addresses = addresses.filter((addr) => !addr.includes(":"));
+    const host = ipv4Addresses.length > 0 ? ipv4Addresses[0] : service.host;
+    const url = `http://${host}:${service.port}`;
+    const owner = service.txt?.owner ?? service.name;
+    onFound({
+      name: service.name,
+      url,
+      owner
+    });
+  });
+  if (onDown) {
+    browser.on("down", (service) => {
+      const addresses = service.addresses ?? [];
+      const ipv4Addresses = addresses.filter((addr) => !addr.includes(":"));
+      const host = ipv4Addresses.length > 0 ? ipv4Addresses[0] : service.host;
+      const url = `http://${host}:${service.port}`;
+      const owner = service.txt?.owner ?? service.name;
+      onDown({
+        name: service.name,
+        url,
+        owner
+      });
+    });
+  }
+  return {
+    stop: () => browser.stop()
+  };
+}
+async function stopAnnouncement() {
+  if (bonjourInstance === null) {
+    return;
+  }
+  const instance = bonjourInstance;
+  bonjourInstance = null;
+  await new Promise((resolve2) => {
+    instance.unpublishAll(() => {
+      instance.destroy();
+      resolve2();
+    });
+  });
+}
+
+// src/runtime/resolve-self-cli.ts
+import { execFileSync } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, resolve } from "path";
+function resolveSelfCli() {
+  const require2 = createRequire(import.meta.url);
+  return resolveSelfCliWithDeps({
+    argv1: process.argv[1],
+    cwd: process.cwd(),
+    platform: process.platform,
+    homeDir: homedir(),
+    envPath: process.env["PATH"],
+    nodeExecDir: dirname(process.execPath),
+    exists: existsSync,
+    realpath: realpathSync,
+    runWhich: (pathEnv) => execFileSync("which", ["agentbnb"], {
+      encoding: "utf8",
+      env: { ...process.env, PATH: pathEnv }
+    }).trim(),
+    requireResolve: (id) => require2.resolve(id)
+  });
+}
+function resolveSelfCliWithDeps(deps) {
+  const tried = [];
+  const tryCandidate = (rawPath, label, requireCliShape = false) => {
+    if (!rawPath || rawPath.trim().length === 0) {
+      tried.push(`${label}: <empty>`);
+      return null;
+    }
+    const maybeAbsolute = isAbsolute(rawPath) ? rawPath : resolve(deps.cwd, rawPath);
+    tried.push(`${label}: ${maybeAbsolute}`);
+    if (!deps.exists(maybeAbsolute)) return null;
+    const resolvedPath = safeRealpath(deps.realpath, maybeAbsolute);
+    if (requireCliShape && !looksLikeAgentbnbCli(resolvedPath)) return null;
+    return resolvedPath;
+  };
+  const argvPath = tryCandidate(deps.argv1, "process.argv[1]", true);
+  if (argvPath) return argvPath;
+  const fullPathEnv = buildFullPathEnv(deps.envPath, deps.homeDir, deps.nodeExecDir);
+  tried.push(`which agentbnb PATH=${fullPathEnv}`);
+  try {
+    const whichPath = tryCandidate(deps.runWhich(fullPathEnv), "which agentbnb");
+    if (whichPath) return whichPath;
+  } catch (err) {
+    tried.push(`which agentbnb failed: ${extractErrorMessage(err)}`);
+  }
+  const npmGlobalCandidates = ["/usr/local/bin/agentbnb", "/opt/homebrew/bin/agentbnb"];
+  for (const candidate of npmGlobalCandidates) {
+    const resolvedPath = tryCandidate(candidate, "npm-global");
+    if (resolvedPath) return resolvedPath;
+  }
+  const pnpmCandidates = getPnpmGlobalCandidates(deps.platform, deps.homeDir);
+  for (const candidate of pnpmCandidates) {
+    const resolvedPath = tryCandidate(candidate, "pnpm-global");
+    if (resolvedPath) return resolvedPath;
+  }
+  if (deps.nodeExecDir) {
+    const execDirCandidate = tryCandidate(
+      join(deps.nodeExecDir, "agentbnb"),
+      "node-execpath-dir"
+    );
+    if (execDirCandidate) return execDirCandidate;
+  }
+  try {
+    const requireResolved = deps.requireResolve("agentbnb/dist/cli/index.js");
+    const resolvedPath = tryCandidate(requireResolved, "require.resolve(agentbnb/dist/cli/index.js)");
+    if (resolvedPath) return resolvedPath;
+  } catch (err) {
+    tried.push(`require.resolve(agentbnb/dist/cli/index.js) failed: ${extractErrorMessage(err)}`);
+  }
+  throw new AgentBnBError(
+    `Unable to resolve absolute path to agentbnb CLI.
+Paths tried:
+${tried.map((item) => `- ${item}`).join("\n")}`,
+    "CLI_ENTRY_NOT_FOUND"
+  );
+}
+function buildFullPathEnv(pathEnv, homeDir, nodeExecDir) {
+  const values = /* @__PURE__ */ new Set();
+  for (const item of (pathEnv ?? "").split(":")) {
+    if (item.trim()) values.add(item.trim());
+  }
+  for (const extra of [
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+    join(homeDir, ".local", "bin"),
+    join(homeDir, "Library", "pnpm"),
+    join(homeDir, ".local", "share", "pnpm")
+  ]) {
+    values.add(extra);
+  }
+  if (nodeExecDir) {
+    values.add(nodeExecDir);
+  }
+  return [...values].join(":");
+}
+function safeRealpath(realpath, path) {
+  try {
+    return realpath(path);
+  } catch {
+    return path;
+  }
+}
+function getPnpmGlobalCandidates(platform, homeDir) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (platform === "darwin") {
+    candidates.add(join(homeDir, "Library", "pnpm", "agentbnb"));
+  }
+  if (platform === "linux") {
+    candidates.add(join(homeDir, ".local", "share", "pnpm", "agentbnb"));
+  }
+  candidates.add(join(homeDir, "Library", "pnpm", "agentbnb"));
+  candidates.add(join(homeDir, ".local", "share", "pnpm", "agentbnb"));
+  return [...candidates];
+}
+function looksLikeAgentbnbCli(path) {
+  const normalized = path.replace(/\\/g, "/").toLowerCase();
+  const fileName = basename(normalized);
+  if (fileName === "agentbnb" || fileName === "agentbnb.cmd" || fileName === "agentbnb.exe") {
+    return true;
+  }
+  return normalized.includes("/agentbnb/dist/cli/index.") || normalized.endsWith("/dist/cli/index.js") || normalized.endsWith("/dist/cli/index.mjs") || normalized.endsWith("/dist/cli/index.cjs");
+}
+function extractErrorMessage(err) {
+  if (err instanceof Error && err.message) return err.message;
+  return String(err);
+}
+
+export {
+  announceGateway,
+  discoverLocalAgents,
+  stopAnnouncement,
+  resolveSelfCli
+};

package/dist/{chunk-BARHNIKG.js → chunk-WK2QSO4E.js}

@@ -7,7 +7,7 @@ import {
   openCreditDb,
   releaseEscrow,
   settleEscrow
-} from "./chunk-F3KIEVJ2.js";
+} from "./chunk-HU46M4JA.js";
 import {
   generateKeyPair,
   loadKeyPair,

package/dist/chunk-WPB5LFGI.js

@@ -0,0 +1,132 @@
+// src/workspace/writer.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var SOUL_SECTION_HEADER = "## AgentBnB Network Trading";
+var HEARTBEAT_SECTION_HEADER = "<!-- agentbnb-trading-rules -->";
+var TOOLS_SECTION_HEADER = "<!-- agentbnb-cli -->";
+function renderSkillsTable(skills) {
+  const rows = skills.map((s) => {
+    const price = s.pricing?.credits_per_call ?? 3;
+    const desc = (s.description ?? "").split("\n")[0]?.trim().slice(0, 60) ?? "";
+    return `| ${s.id} | ${price} cr | ${desc} |`;
+  }).join("\n");
+  return ["| Skill | Price | Description |", "|-------|-------|-------------|", rows].join("\n");
+}
+function appendSoulMdTradingSection(soulPath, skills, agentbnbDir) {
+  const content = readFileSync(soulPath, "utf-8");
+  if (content.includes(SOUL_SECTION_HEADER)) return;
+  const skillsTable = renderSkillsTable(skills);
+  const section = [
+    "",
+    "---",
+    SOUL_SECTION_HEADER,
+    "",
+    `This agent is connected to the [AgentBnB](https://agentbnb.dev) P2P capability-sharing network.`,
+    "",
+    "### Shared Skills",
+    skillsTable,
+    "",
+    "### Trading Rules",
+    `- AGENTBNB_DIR: ${agentbnbDir}`,
+    "- Reserve floor: 20 credits (never auto-spend below this)",
+    "- Auto-trade limit: 10 credits per transaction (above \u2192 ask owner)",
+    `- Request capabilities: \`AGENTBNB_DIR=${agentbnbDir} agentbnb request <card_id> --skill <skill> --params '<json>'\``,
+    `- Check balance: \`AGENTBNB_DIR=${agentbnbDir} agentbnb status\``,
+    `- Browse network: \`AGENTBNB_DIR=${agentbnbDir} agentbnb discover\``,
+    "",
+    "### GEP Evolution",
+    "AgentBnB tracks capability evolution in the `gep/` directory:",
+    "- `gep/genes.json` \u2014 capability traits earned through successful executions",
+    "- `gep/capsules.json` \u2014 packaged skill bundles for sharing",
+    "- `gep/events.jsonl` \u2014 append-only evolution event log",
+    "",
+    "### How to Earn",
+    "Credits are escrowed when another agent hires your skill and settled on success (5% network fee applies)."
+  ].join("\n");
+  writeFileSync(soulPath, content + section, "utf-8");
+}
+function updateSoulMdSkillsTable(soulPath, skills) {
+  const content = readFileSync(soulPath, "utf-8");
+  if (!content.includes(SOUL_SECTION_HEADER)) return;
+  const newTable = renderSkillsTable(skills);
+  const updated = content.replace(
+    /(### Shared Skills\n)\|.*?\|[\s\S]*?(?=\n###|\n---|\n$)/,
+    `$1${newTable}
+`
+  );
+  if (updated !== content) {
+    writeFileSync(soulPath, updated, "utf-8");
+  }
+}
+function appendHeartbeatTradingSection(heartbeatPath, agentbnbDir) {
+  if (!existsSync(heartbeatPath)) return;
+  const content = readFileSync(heartbeatPath, "utf-8");
+  if (content.includes(HEARTBEAT_SECTION_HEADER)) return;
+  const section = [
+    "",
+    HEARTBEAT_SECTION_HEADER,
+    "## AgentBnB Trading Cycle",
+    "",
+    "- Every idle period (>10 min): check `AGENTBNB_DIR=" + agentbnbDir + " agentbnb status`",
+    "- If balance < 20 credits: pause auto-requests, notify owner",
+    "- If idle_rate > 70%: auto-share idle skills to network",
+    "- Settle completed escrows automatically (no action needed)",
+    "<!-- /agentbnb-trading-rules -->"
+  ].join("\n");
+  writeFileSync(heartbeatPath, content + section, "utf-8");
+}
+function appendToolsMdAgentBnB(toolsPath, agentbnbDir) {
+  if (!existsSync(toolsPath)) return;
+  const content = readFileSync(toolsPath, "utf-8");
+  if (content.includes(TOOLS_SECTION_HEADER)) return;
+  const envPrefix = `AGENTBNB_DIR=${agentbnbDir}`;
+  const section = [
+    "",
+    TOOLS_SECTION_HEADER,
+    "## AgentBnB CLI",
+    "",
+    "```bash",
+    `# Check status & balance`,
+    `${envPrefix} agentbnb status`,
+    "",
+    `# Discover agents on the network`,
+    `${envPrefix} agentbnb discover`,
+    "",
+    `# Request a capability`,
+    `${envPrefix} agentbnb request <card_id> --skill <skill_id> --params '{"key":"value"}'`,
+    "",
+    `# Manage shared skills`,
+    `${envPrefix} agentbnb openclaw skills list`,
+    `${envPrefix} agentbnb openclaw skills stats`,
+    "```",
+    "<!-- /agentbnb-cli -->"
+  ].join("\n");
+  writeFileSync(toolsPath, content + section, "utf-8");
+}
+function writeBootstrapMd(bootstrapPath, agentbnbDir) {
+  const content = [
+    "# AgentBnB First-Run Setup",
+    "",
+    "Run this command to connect to the AgentBnB network:",
+    "",
+    "```bash",
+    `AGENTBNB_DIR=${agentbnbDir} agentbnb openclaw setup`,
+    "```",
+    "",
+    "After setup completes, delete this file and tell your owner:",
+    `"AgentBnB setup complete! I'm now connected to the network."`,
+    "",
+    "---",
+    "_Generated by AgentBnB bootstrap on first install._"
+  ].join("\n");
+  writeFileSync(bootstrapPath, content, "utf-8");
+}
+
+export {
+  join,
+  appendSoulMdTradingSection,
+  updateSoulMdSkillsTable,
+  appendHeartbeatTradingSection,
+  appendToolsMdAgentBnB,
+  writeBootstrapMd
+};

package/dist/chunk-XGOA5J2K.js

@@ -0,0 +1,173 @@
+// src/workspace/scanner.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function heuristicPrice(skillName) {
+  const lower = skillName.toLowerCase();
+  if (/voice|tts|elevenlabs/.test(lower)) return 4;
+  if (/crawl|browser|cf/.test(lower)) return 3;
+  if (/scrape|stealth/.test(lower)) return 5;
+  if (/search|kb|knowledge/.test(lower)) return 2;
+  return 3;
+}
+function firstParagraph(md) {
+  const lines = md.split("\n");
+  const paragraphLines = [];
+  let inParagraph = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    if (/^---+$/.test(trimmed)) continue;
+    if (trimmed.length > 0) {
+      inParagraph = true;
+      paragraphLines.push(trimmed);
+    } else if (inParagraph) {
+      break;
+    }
+  }
+  return paragraphLines.join(" ");
+}
+function readChannel(agentsDir, agentName) {
+  const openclawJsonPath = join(agentsDir, agentName, "openclaw.json");
+  if (!existsSync(openclawJsonPath)) return "unknown";
+  try {
+    const raw = readFileSync(openclawJsonPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const channel = parsed["channel"] ?? parsed["type"] ?? "unknown";
+    return typeof channel === "string" ? channel : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function countSkills(brainDir) {
+  const skillsDir = join(brainDir, "skills");
+  if (!existsSync(skillsDir)) return 0;
+  try {
+    return readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isFile() || e.isDirectory()).length;
+  } catch {
+    return 0;
+  }
+}
+function scanAgents() {
+  const openclawDir = join(homedir(), ".openclaw");
+  const brainsDir = join(openclawDir, "workspace", "brains");
+  const agentsDir = join(openclawDir, "agents");
+  const results = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  if (existsSync(brainsDir)) {
+    const entries = readdirSync(brainsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    for (const name of entries) {
+      const brainDir = join(brainsDir, name);
+      const soulPath = join(brainDir, "SOUL.md");
+      const description = existsSync(soulPath) ? firstParagraph(readFileSync(soulPath, "utf-8")) : "";
+      results.push({
+        name,
+        description,
+        skillCount: countSkills(brainDir),
+        channel: readChannel(agentsDir, name),
+        brainDir,
+        agentbnbDir: join(agentsDir, name, ".agentbnb")
+      });
+      seenNames.add(name);
+    }
+  }
+  if (existsSync(agentsDir)) {
+    const entries = readdirSync(agentsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => !seenNames.has(name));
+    for (const name of entries) {
+      const agentDir = join(agentsDir, name);
+      const soulPath = join(agentDir, "SOUL.md");
+      const description = existsSync(soulPath) ? firstParagraph(readFileSync(soulPath, "utf-8")) : "";
+      results.push({
+        name,
+        description,
+        skillCount: 0,
+        channel: readChannel(agentsDir, name),
+        brainDir: "",
+        agentbnbDir: join(agentDir, ".agentbnb")
+      });
+      seenNames.add(name);
+    }
+  }
+  return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseCapabilitiesFromSoul(soulContent) {
+  const results = [];
+  const lines = soulContent.split("\n");
+  let currentName = null;
+  const descLines = [];
+  for (const line of lines) {
+    const h2Match = /^## (.+)$/.exec(line);
+    if (h2Match) {
+      if (currentName) {
+        results.push({ name: currentName, description: descLines.join(" ").trim() });
+      }
+      currentName = h2Match[1].trim();
+      if (currentName === "AgentBnB Network Trading" || currentName.startsWith("Trading") || currentName === "Overview" || currentName === "About") {
+        currentName = null;
+      }
+      descLines.length = 0;
+    } else if (currentName && descLines.length === 0 && line.trim().length > 0) {
+      descLines.push(line.trim());
+    }
+  }
+  if (currentName) {
+    results.push({ name: currentName, description: descLines.join(" ").trim() });
+  }
+  return results;
+}
+function scanCapabilities(brainDir) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const soulPath = join(brainDir, "SOUL.md");
+  if (existsSync(soulPath)) {
+    const soulContent = readFileSync(soulPath, "utf-8");
+    for (const { name, description } of parseCapabilitiesFromSoul(soulContent)) {
+      if (!seen.has(name)) {
+        seen.add(name);
+        results.push({
+          name,
+          description,
+          source: "soul_md",
+          suggestedPrice: heuristicPrice(name)
+        });
+      }
+    }
+  }
+  const skillsDir = join(brainDir, "skills");
+  if (existsSync(skillsDir)) {
+    const entries = readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    for (const skillDirName of entries) {
+      const skillMdPath = join(skillsDir, skillDirName, "SKILL.md");
+      if (!existsSync(skillMdPath)) continue;
+      try {
+        const content = readFileSync(skillMdPath, "utf-8");
+        const fmMatch = /^---\n([\s\S]*?)\n---/.exec(content);
+        let name = skillDirName;
+        let description = "";
+        if (fmMatch) {
+          const fm = fmMatch[1];
+          const nameMatch = /^name:\s*(.+)$/m.exec(fm);
+          const descMatch = /^description:\s*(.+)$/m.exec(fm);
+          if (nameMatch) name = nameMatch[1].trim();
+          if (descMatch) description = descMatch[1].trim();
+        }
+        if (!seen.has(name)) {
+          seen.add(name);
+          results.push({
+            name,
+            description,
+            source: "skill_md",
+            suggestedPrice: heuristicPrice(name)
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+
+export {
+  scanAgents,
+  scanCapabilities
+};