agentbnb 5.1.11 → 7.0.0-beta.1

package/dist/index.js

@@ -48,7 +48,9 @@ var CapabilityCardSchema = z.object({
     tags: z.array(z.string()).optional()
   }).optional(),
   created_at: z.string().datetime().optional(),
-  updated_at: z.string().datetime().optional()
+  updated_at: z.string().datetime().optional(),
+  /** Exact-match capability type key for network routing (e.g. 'task_decomposition'). Optional — backward-compatible. */
+  capability_type: z.string().optional()
 });
 var SkillSchema = z.object({
   /** Stable skill identifier, e.g. 'tts-elevenlabs'. Used for gateway routing and idle tracking. */
@@ -58,6 +60,25 @@ var SkillSchema = z.object({
   level: z.union([z.literal(1), z.literal(2), z.literal(3)]),
   /** Optional grouping category, e.g. 'tts' | 'video_gen' | 'code_review'. */
   category: z.string().optional(),
+  /** Exact-match capability type key for network routing (e.g. 'task_decomposition'). Optional — per-skill routing hint. */
+  capability_type: z.string().optional(),
+  /**
+   * Multi-value capability routing tags — what this skill IS / offers to the outside.
+   * Used by Conductor for precise skill-level matching.
+   * Example: ["audio_generation", "audio_editing", "content_production"]
+   */
+  capability_types: z.array(z.string()).optional(),
+  /**
+   * Capabilities this skill internally depends on when executing.
+   * Used by Conductor for decomposition planning and cost estimation.
+   * Example: ["tts", "sound_effects", "audio_mixing"]
+   */
+  requires_capabilities: z.array(z.string()).optional(),
+  /**
+   * Publishing visibility. 'private' skills are excluded from published CapabilityCards.
+   * Defaults to 'public' when omitted.
+   */
+  visibility: z.enum(["public", "private"]).optional(),
   inputs: z.array(IOSchemaSchema),
   outputs: z.array(IOSchemaSchema),
   pricing: z.object({
@@ -144,6 +165,8 @@ var CapabilityCardV2Schema = z.object({
   _internal: z.record(z.unknown()).optional(),
   /** Public gateway URL where this agent accepts requests. Populated on remote publish. */
   gateway_url: z.string().url().optional(),
+  /** Exact-match capability type key for network routing (e.g. 'task_decomposition'). Optional — backward-compatible. */
+  capability_type: z.string().optional(),
   created_at: z.string().datetime().optional(),
   updated_at: z.string().datetime().optional()
 });
@@ -191,11 +214,27 @@ function createRequestLogTable(db) {
     db.exec("ALTER TABLE request_log ADD COLUMN tier_invoked INTEGER");
   } catch {
   }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN failure_reason TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN team_id TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN role TEXT");
+  } catch {
+  }
+  try {
+    db.exec("ALTER TABLE request_log ADD COLUMN capability_type TEXT");
+  } catch {
+  }
 }
 function insertRequestLog(db, entry) {
   const stmt = db.prepare(`
-    INSERT INTO request_log (id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT INTO request_log (id, card_id, card_name, requester, status, latency_ms, credits_charged, created_at, skill_id, action_type, tier_invoked, failure_reason, team_id, role, capability_type)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   stmt.run(
     entry.id,
@@ -208,7 +247,11 @@ function insertRequestLog(db, entry) {
     entry.created_at,
     entry.skill_id ?? null,
     entry.action_type ?? null,
-    entry.tier_invoked ?? null
+    entry.tier_invoked ?? null,
+    entry.failure_reason ?? null,
+    entry.team_id ?? null,
+    entry.role ?? null,
+    entry.capability_type ?? null
   );
 }
 
@@ -322,6 +365,17 @@ var V2_FTS_TRIGGERS = `
          FROM json_each(json_extract(new.data, '$.metadata.tags'))),
         ''
       )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
     );
   END;
 
@@ -351,6 +405,17 @@ var V2_FTS_TRIGGERS = `
          FROM json_each(json_extract(old.data, '$.metadata.tags'))),
         ''
       )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
     );
     INSERT INTO cards_fts(rowid, id, owner, name, description, tags)
     VALUES (
@@ -376,6 +441,17 @@ var V2_FTS_TRIGGERS = `
          FROM json_each(json_extract(new.data, '$.metadata.tags'))),
         ''
       )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(new.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
     );
   END;
 
@@ -405,6 +481,17 @@ var V2_FTS_TRIGGERS = `
          FROM json_each(json_extract(old.data, '$.metadata.tags'))),
         ''
       )
+      || ' ' || COALESCE(
+        (SELECT group_concat(json_extract(skill.value, '$.capability_type'), ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill),
+        ''
+      )
+      || ' ' || COALESCE(
+        (SELECT group_concat(cap_type.value, ' ')
+         FROM json_each(json_extract(old.data, '$.skills')) AS skill,
+              json_each(json_extract(skill.value, '$.capability_types')) AS cap_type),
+        ''
+      )
     );
   END;
 `;
@@ -509,10 +596,17 @@ function migrateV1toV2(db) {
       if (skills.length > 0) {
         name = skills.map((s) => String(s["name"] ?? "")).join(" ");
         description = skills.map((s) => String(s["description"] ?? "")).join(" ");
-        tags = skills.flatMap((s) => {
-          const meta = s["metadata"];
-          return meta?.["tags"] ?? [];
-        }).join(" ");
+        tags = [
+          // tags from metadata.tags[]
+          ...skills.flatMap((s) => {
+            const meta = s["metadata"];
+            return meta?.["tags"] ?? [];
+          }),
+          // capability_type (singular)
+          ...skills.map((s) => s["capability_type"]).filter((v) => typeof v === "string" && v.length > 0),
+          // capability_types[] (plural)
+          ...skills.flatMap((s) => s["capability_types"] ?? [])
+        ].join(" ");
       } else {
         name = String(data["name"] ?? "");
         description = String(data["description"] ?? "");
@@ -589,6 +683,24 @@ function listCards(db, owner) {
   }
   return rows.map((row) => JSON.parse(row.data));
 }
+function getCardsByCapabilityType(db, capabilityType) {
+  const rows = db.prepare(
+    "SELECT data FROM capability_cards WHERE json_extract(data, '$.capability_type') = ?"
+  ).all(capabilityType);
+  return rows.map((row) => JSON.parse(row.data));
+}
+function getCardsBySkillCapability(db, capabilityType) {
+  const rows = db.prepare("SELECT data FROM capability_cards").all();
+  return rows.map((row) => JSON.parse(row.data)).filter((card) => {
+    const skills = card["skills"];
+    if (!skills) return false;
+    return skills.some((skill) => {
+      if (skill["capability_type"] === capabilityType) return true;
+      const types = skill["capability_types"];
+      return Array.isArray(types) && types.includes(capabilityType);
+    });
+  });
+}
 
 // src/feedback/reputation.ts
 var QUALITY_SCORES = {
@@ -692,6 +804,59 @@ function applyReputationFilter(db, cards, minReputation) {
 // src/credit/ledger.ts
 import Database2 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
+
+// src/credit/reliability-metrics.ts
+var RELIABILITY_METRICS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS provider_reliability_metrics (
+    owner TEXT PRIMARY KEY,
+    current_streak INTEGER NOT NULL DEFAULT 0,
+    longest_streak INTEGER NOT NULL DEFAULT 0,
+    total_hires INTEGER NOT NULL DEFAULT 0,
+    repeat_hires INTEGER NOT NULL DEFAULT 0,
+    feedback_count INTEGER NOT NULL DEFAULT 0,
+    feedback_sum REAL NOT NULL DEFAULT 0,
+    availability_checks INTEGER NOT NULL DEFAULT 0,
+    availability_hits INTEGER NOT NULL DEFAULT 0,
+    cycle_start TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+`;
+function ensureReliabilityTable(db) {
+  db.exec(RELIABILITY_METRICS_SCHEMA);
+}
+function ensureRow(db, owner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT OR IGNORE INTO provider_reliability_metrics
+     (owner, current_streak, longest_streak, total_hires, repeat_hires,
+      feedback_count, feedback_sum, availability_checks, availability_hits,
+      cycle_start, updated_at)
+     VALUES (?, 0, 0, 0, 0, 0, 0, 0, 0, ?, ?)`
+  ).run(owner, now, now);
+}
+function recordSuccessfulHire(db, providerOwner, consumerOwner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  ensureRow(db, providerOwner);
+  const isRepeat = db.prepare(
+    `SELECT COUNT(*) as cnt FROM credit_transactions
+     WHERE owner = ? AND reason = 'settlement'
+     AND reference_id IN (
+       SELECT id FROM credit_escrow WHERE owner = ?
+     )`
+  ).get(providerOwner, consumerOwner);
+  const repeatIncrement = (isRepeat?.cnt ?? 0) > 0 ? 1 : 0;
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET current_streak = current_streak + 1,
+         longest_streak = MAX(longest_streak, current_streak + 1),
+         total_hires = total_hires + 1,
+         repeat_hires = repeat_hires + ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(repeatIncrement, now, providerOwner);
+}
+
+// src/credit/ledger.ts
 var CREDIT_SCHEMA = `
   CREATE TABLE IF NOT EXISTS credit_balances (
     owner TEXT PRIMARY KEY,
@@ -718,6 +883,22 @@ var CREDIT_SCHEMA = `
     settled_at TEXT
   );
 
+  CREATE TABLE IF NOT EXISTS provider_registry (
+    owner TEXT PRIMARY KEY,
+    provider_number INTEGER NOT NULL,
+    registered_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS demand_vouchers (
+    id TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    amount INTEGER NOT NULL,
+    remaining INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL,
+    is_active INTEGER NOT NULL DEFAULT 1
+  );
+
   CREATE INDEX IF NOT EXISTS idx_transactions_owner ON credit_transactions(owner, created_at);
   CREATE INDEX IF NOT EXISTS idx_escrow_owner ON credit_escrow(owner);
 `;
@@ -726,12 +907,46 @@ function openCreditDb(path = ":memory:") {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   db.exec(CREDIT_SCHEMA);
+  try {
+    db.exec("ALTER TABLE credit_escrow ADD COLUMN funding_source TEXT NOT NULL DEFAULT 'balance'");
+  } catch {
+  }
+  ensureReliabilityTable(db);
   return db;
 }
 function getBalance(db, owner) {
   const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
   return row?.balance ?? 0;
 }
+function registerProvider(db, owner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const maxRow = db.prepare("SELECT MAX(provider_number) as maxNum FROM provider_registry").get();
+  const nextNum = (maxRow?.maxNum ?? 0) + 1;
+  db.prepare("INSERT OR IGNORE INTO provider_registry (owner, provider_number, registered_at) VALUES (?, ?, ?)").run(owner, nextNum, now);
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(owner);
+  return row.provider_number;
+}
+function getProviderNumber(db, owner) {
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(owner);
+  return row?.provider_number ?? null;
+}
+function getProviderBonus(providerNumber) {
+  if (providerNumber <= 50) return 2;
+  if (providerNumber <= 200) return 1.5;
+  return 1;
+}
+function getActiveVoucher(db, owner) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const row = db.prepare(
+    "SELECT id, remaining, expires_at FROM demand_vouchers WHERE owner = ? AND is_active = 1 AND remaining > 0 AND expires_at > ? ORDER BY created_at ASC LIMIT 1"
+  ).get(owner, now);
+  return row ?? null;
+}
+function consumeVoucher(db, voucherId, amount) {
+  db.prepare(
+    "UPDATE demand_vouchers SET remaining = remaining - ? WHERE id = ? AND remaining >= ?"
+  ).run(amount, voucherId, amount);
+}
 function recordEarning(db, owner, amount, _cardId, receiptNonce) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.transaction(() => {
@@ -753,29 +968,42 @@ function recordEarning(db, owner, amount, _cardId, receiptNonce) {
 
 // src/gateway/server.ts
 import Fastify from "fastify";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/gateway/execute.ts
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/credit/escrow.ts
 import { randomUUID as randomUUID4 } from "crypto";
+var NETWORK_FEE_RATE = 0.05;
 function holdEscrow(db, owner, amount, cardId) {
   const escrowId = randomUUID4();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const hold = db.transaction(() => {
-    const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
-    if (!row || row.balance < amount) {
-      throw new AgentBnBError("Insufficient credits", "INSUFFICIENT_CREDITS");
+    const voucher = getActiveVoucher(db, owner);
+    if (voucher && voucher.remaining >= amount) {
+      consumeVoucher(db, voucher.id, amount);
+      db.prepare(
+        "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      ).run(escrowId, owner, amount, cardId, "held", now, "voucher");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID4(), owner, -amount, "voucher_hold", escrowId, now);
+    } else {
+      const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+      if (!row || row.balance < amount) {
+        throw new AgentBnBError("Insufficient credits", "INSUFFICIENT_CREDITS");
+      }
+      db.prepare(
+        "UPDATE credit_balances SET balance = balance - ?, updated_at = ? WHERE owner = ? AND balance >= ?"
+      ).run(amount, now, owner, amount);
+      db.prepare(
+        "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
+      ).run(escrowId, owner, amount, cardId, "held", now, "balance");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID4(), owner, -amount, "escrow_hold", escrowId, now);
     }
-    db.prepare(
-      "UPDATE credit_balances SET balance = balance - ?, updated_at = ? WHERE owner = ? AND balance >= ?"
-    ).run(amount, now, owner, amount);
-    db.prepare(
-      "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(escrowId, owner, amount, cardId, "held", now);
-    db.prepare(
-      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID4(), owner, -amount, "escrow_hold", escrowId, now);
   });
   hold();
   return escrowId;
@@ -783,7 +1011,7 @@ function holdEscrow(db, owner, amount, cardId) {
 function settleEscrow(db, escrowId, recipientOwner) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const settle = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
     if (!escrow) {
       throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
     }
@@ -793,25 +1021,61 @@ function settleEscrow(db, escrowId, recipientOwner) {
         "ESCROW_ALREADY_SETTLED"
       );
     }
+    const feeAmount = Math.floor(escrow.amount * NETWORK_FEE_RATE);
+    const providerAmount = escrow.amount - feeAmount;
     db.prepare(
       "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
     ).run(recipientOwner, now);
     db.prepare(
       "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-    ).run(escrow.amount, now, recipientOwner);
+    ).run(providerAmount, now, recipientOwner);
+    if (feeAmount > 0) {
+      db.prepare(
+        "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+      ).run("platform_treasury", now);
+      db.prepare(
+        "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+      ).run(feeAmount, now, "platform_treasury");
+      db.prepare(
+        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+      ).run(randomUUID4(), "platform_treasury", feeAmount, "network_fee", escrowId, now);
+    }
     db.prepare(
       "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
     ).run("settled", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID4(), recipientOwner, escrow.amount, "settlement", escrowId, now);
+    ).run(randomUUID4(), recipientOwner, providerAmount, "settlement", escrowId, now);
+    let providerNum = getProviderNumber(db, recipientOwner);
+    if (providerNum === null) {
+      providerNum = registerProvider(db, recipientOwner);
+    }
+    const bonus = getProviderBonus(providerNum);
+    if (bonus > 1) {
+      const bonusAmount = Math.floor(providerAmount * (bonus - 1));
+      if (bonusAmount > 0) {
+        db.prepare(
+          "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
+        ).run("platform_treasury", now);
+        db.prepare(
+          "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+        ).run(bonusAmount, now, recipientOwner);
+        db.prepare(
+          "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+        ).run(randomUUID4(), recipientOwner, bonusAmount, "provider_bonus", escrowId, now);
+      }
+    }
+    try {
+      recordSuccessfulHire(db, recipientOwner, escrow.owner);
+    } catch {
+    }
   });
   settle();
 }
 function releaseEscrow(db, escrowId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const release = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
     if (!escrow) {
       throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
     }
@@ -836,7 +1100,7 @@ function releaseEscrow(db, escrowId) {
 function confirmEscrowDebit(db, escrowId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const confirm = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status FROM credit_escrow WHERE id = ?").get(escrowId);
+    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
     if (!escrow) {
       throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
     }
@@ -910,10 +1174,12 @@ function verifyEscrowReceipt(data, signature, publicKey) {
 
 // src/credit/settlement.ts
 function settleProviderEarning(providerDb, providerOwner, receipt) {
+  const feeAmount = Math.floor(receipt.amount * NETWORK_FEE_RATE);
+  const providerAmount = receipt.amount - feeAmount;
   recordEarning(
     providerDb,
     providerOwner,
-    receipt.amount,
+    providerAmount,
     receipt.card_id,
     receipt.nonce
   );
@@ -926,7 +1192,50 @@ function releaseRequesterEscrow(requesterDb, escrowId) {
   releaseEscrow(requesterDb, escrowId);
 }
 
+// src/cli/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function getConfigDir() {
+  return process.env["AGENTBNB_DIR"] ?? join2(homedir(), ".agentbnb");
+}
+function getConfigPath() {
+  return join2(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) return null;
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
 // src/gateway/execute.ts
+async function notifyTelegramSkillExecuted(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 executed",
+    `Skill: ${skillLabel}`,
+    `Requester: ${opts.requester}`,
+    `Earned: +${opts.creditsEarned} credits`,
+    `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,
@@ -958,7 +1267,8 @@ async function executeCapabilityRequest(opts) {
         status: "failure",
         latency_ms: 0,
         credits_charged: 0,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        failure_reason: "auth_error"
       });
     } catch {
     }
@@ -1013,9 +1323,11 @@ async function executeCapabilityRequest(opts) {
   }
   const startMs = Date.now();
   const receiptData = isRemoteEscrow ? { receipt_released: true } : void 0;
-  const handleFailure = (status, latencyMs, message) => {
+  const handleFailure = (status, latencyMs, message, failureReason = "bad_execution") => {
     if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
-    updateReputation(registryDb, cardId, false, latencyMs);
+    if (failureReason === "bad_execution" || failureReason === "auth_error") {
+      updateReputation(registryDb, cardId, false, latencyMs);
+    }
     try {
       insertRequestLog(registryDb, {
         id: randomUUID5(),
@@ -1026,7 +1338,8 @@ async function executeCapabilityRequest(opts) {
         status,
         latency_ms: latencyMs,
         credits_charged: 0,
-        created_at: (/* @__PURE__ */ new Date()).toISOString()
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        failure_reason: failureReason
       });
     } catch {
     }
@@ -1056,6 +1369,16 @@ async function executeCapabilityRequest(opts) {
       });
     } catch {
     }
+    notifyTelegramSkillExecuted({
+      creditDb,
+      owner: card.owner,
+      skillName: cardName,
+      skillId: resolvedSkillId ?? null,
+      requester,
+      creditsEarned: creditsNeeded,
+      latencyMs
+    }).catch(() => {
+    });
     const successResult = isRemoteEscrow ? {
       ...typeof result === "object" && result !== null ? result : { data: result },
       receipt_settled: true,
@@ -1073,23 +1396,24 @@ async function executeCapabilityRequest(opts) {
         return handleFailure(
           "failure",
           Date.now() - startMs,
-          "No skill_id specified and no skills registered on this provider."
+          "No skill_id specified and no skills registered on this provider.",
+          "not_found"
         );
       }
     }
     try {
       const execResult = await skillExecutor.execute(targetSkillId, params, onProgress);
       if (!execResult.success) {
-        return handleFailure("failure", execResult.latency_ms, execResult.error ?? "Execution failed");
+        return handleFailure("failure", execResult.latency_ms, execResult.error ?? "Execution failed", "bad_execution");
       }
       return handleSuccess(execResult.result, execResult.latency_ms);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Execution error";
-      return handleFailure("failure", Date.now() - startMs, message);
+      return handleFailure("failure", Date.now() - startMs, message, "bad_execution");
     }
   }
   if (!handlerUrl) {
-    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured");
+    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured", "bad_execution");
   }
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1102,7 +1426,7 @@ async function executeCapabilityRequest(opts) {
     });
     clearTimeout(timer);
     if (!response.ok) {
-      return handleFailure("failure", Date.now() - startMs, `Handler returned ${response.status}`);
+      return handleFailure("failure", Date.now() - startMs, `Handler returned ${response.status}`, "bad_execution");
     }
     const result = await response.json();
     return handleSuccess(result, Date.now() - startMs);
@@ -1112,7 +1436,8 @@ async function executeCapabilityRequest(opts) {
     return handleFailure(
       isTimeout ? "timeout" : "failure",
       Date.now() - startMs,
-      isTimeout ? "Execution timeout" : "Handler error"
+      isTimeout ? "Execution timeout" : "Handler error",
+      isTimeout ? "timeout" : "bad_execution"
     );
   }
 }
@@ -1131,6 +1456,8 @@ function createGatewayServer(opts) {
   } = opts;
   const fastify = Fastify({ logger: !silent });
   const tokenSet = new Set(tokens);
+  const inFlight = /* @__PURE__ */ new Map();
+  const OVERLOAD_RETRY_MS = 5e3;
   fastify.addHook("onRequest", async (request) => {
     if (request.method === "GET" && request.url === "/health") return;
     const auth = request.headers.authorization;
@@ -1196,18 +1523,63 @@ function createGatewayServer(opts) {
     }
     const requester = params.requester ?? "unknown";
     const receipt = params.escrow_receipt;
-    const result = await executeCapabilityRequest({
-      registryDb,
-      creditDb,
-      cardId,
-      skillId,
-      params,
-      requester,
-      escrowReceipt: receipt,
-      skillExecutor,
-      handlerUrl,
-      timeoutMs
-    });
+    if (skillExecutor && skillId && typeof skillExecutor.getSkillConfig === "function") {
+      const skillConfig = skillExecutor.getSkillConfig(skillId);
+      const maxConcurrent = skillConfig?.capacity?.max_concurrent;
+      if (maxConcurrent !== void 0) {
+        const current = inFlight.get(skillId) ?? 0;
+        if (current >= maxConcurrent) {
+          try {
+            insertRequestLog(registryDb, {
+              id: randomUUID6(),
+              card_id: cardId,
+              card_name: "<overload>",
+              requester,
+              status: "failure",
+              latency_ms: 0,
+              credits_charged: 0,
+              created_at: (/* @__PURE__ */ new Date()).toISOString(),
+              skill_id: skillId,
+              failure_reason: "overload"
+            });
+          } catch {
+          }
+          return reply.status(200).send({
+            jsonrpc: "2.0",
+            id,
+            error: {
+              code: -32e3,
+              message: "overload",
+              data: { error: "overload", retry_after_ms: OVERLOAD_RETRY_MS }
+            }
+          });
+        }
+      }
+    }
+    const trackKey = skillId ?? cardId;
+    inFlight.set(trackKey, (inFlight.get(trackKey) ?? 0) + 1);
+    let result;
+    try {
+      result = await executeCapabilityRequest({
+        registryDb,
+        creditDb,
+        cardId,
+        skillId,
+        params,
+        requester,
+        escrowReceipt: receipt,
+        skillExecutor,
+        handlerUrl,
+        timeoutMs
+      });
+    } finally {
+      const next = (inFlight.get(trackKey) ?? 1) - 1;
+      if (next <= 0) {
+        inFlight.delete(trackKey);
+      } else {
+        inFlight.set(trackKey, next);
+      }
+    }
     if (result.success) {
       return reply.send({ jsonrpc: "2.0", id, result: result.result });
     } else {
@@ -1221,13 +1593,16 @@ function createGatewayServer(opts) {
 var SkillExecutor = class {
   skillMap;
   modeMap;
+  concurrencyGuard;
   /**
    * @param configs - Parsed SkillConfig array (from parseSkillsFile).
    * @param modes - Map from skill type string to its executor implementation.
+   * @param concurrencyGuard - Optional ConcurrencyGuard to enforce max_concurrent limits.
    */
-  constructor(configs, modes) {
+  constructor(configs, modes, concurrencyGuard) {
     this.skillMap = new Map(configs.map((c) => [c.id, c]));
     this.modeMap = modes;
+    this.concurrencyGuard = concurrencyGuard;
   }
   /**
    * Execute a skill by ID with the given input parameters.
@@ -1260,6 +1635,18 @@ var SkillExecutor = class {
         latency_ms: Date.now() - startTime
       };
     }
+    const maxConcurrent = config.capacity?.max_concurrent ?? Infinity;
+    if (this.concurrencyGuard && maxConcurrent !== Infinity) {
+      if (!this.concurrencyGuard.canAccept(skillId, maxConcurrent)) {
+        return {
+          success: false,
+          error: `Skill ${skillId} at capacity (${maxConcurrent} concurrent max)`,
+          latency_ms: Date.now() - startTime,
+          failure_reason: "overload"
+        };
+      }
+      this.concurrencyGuard.acquire(skillId);
+    }
     try {
       const modeResult = await mode.execute(config, params, onProgress);
       return {
@@ -1273,6 +1660,10 @@ var SkillExecutor = class {
         error: message,
         latency_ms: Date.now() - startTime
       };
+    } finally {
+      if (this.concurrencyGuard && maxConcurrent !== Infinity) {
+        this.concurrencyGuard.release(skillId);
+      }
     }
   }
   /**
@@ -1293,13 +1684,16 @@ var SkillExecutor = class {
     return this.skillMap.get(skillId);
   }
 };
-function createSkillExecutor(configs, modes) {
-  return new SkillExecutor(configs, modes);
+function createSkillExecutor(configs, modes, concurrencyGuard) {
+  return new SkillExecutor(configs, modes, concurrencyGuard);
 }
 
 // src/skills/skill-config.ts
 import { z as z2 } from "zod";
 import yaml from "js-yaml";
+var CapacitySchema = z2.object({
+  max_concurrent: z2.number().positive().int().optional()
+}).optional();
 var PricingSchema = z2.object({
   credits_per_call: z2.number().nonnegative(),
   credits_per_minute: z2.number().nonnegative().optional(),
@@ -1321,6 +1715,12 @@ var ApiAuthSchema = z2.discriminatedUnion("type", [
     password: z2.string()
   })
 ]);
+var CapabilityDeclarationSchema = {
+  description: z2.string().optional(),
+  capability_types: z2.array(z2.string()).optional(),
+  requires_capabilities: z2.array(z2.string()).optional(),
+  visibility: z2.enum(["public", "private"]).optional()
+};
 var ApiSkillConfigSchema = z2.object({
   id: z2.string().min(1),
   type: z2.literal("api"),
@@ -1333,7 +1733,9 @@ var ApiSkillConfigSchema = z2.object({
   pricing: PricingSchema,
   timeout_ms: z2.number().positive().default(3e4),
   retries: z2.number().nonnegative().int().default(0),
-  provider: z2.string().optional()
+  provider: z2.string().optional(),
+  capacity: CapacitySchema,
+  ...CapabilityDeclarationSchema
 });
 var PipelineStepSchema = z2.union([
   z2.object({
@@ -1351,7 +1753,9 @@ var PipelineSkillConfigSchema = z2.object({
   name: z2.string().min(1),
   steps: z2.array(PipelineStepSchema).min(1),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z2.number().positive().optional(),
+  capacity: CapacitySchema,
+  ...CapabilityDeclarationSchema
 });
 var OpenClawSkillConfigSchema = z2.object({
   id: z2.string().min(1),
@@ -1360,7 +1764,17 @@ var OpenClawSkillConfigSchema = z2.object({
   agent_name: z2.string().min(1),
   channel: z2.enum(["telegram", "webhook", "process"]),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z2.number().positive().optional(),
+  capacity: CapacitySchema,
+  ...CapabilityDeclarationSchema
+});
+var ClaudeCodeConfigSchema = z2.object({
+  /** Optional system prompt passed via `-p` flag. */
+  system_prompt: z2.string().optional(),
+  /** Model to use (e.g. 'claude-opus-4-6', 'claude-sonnet-4-6'). */
+  model: z2.string().optional(),
+  /** When true, passes `--dangerously-skip-permissions` to claude CLI. */
+  auto_mode: z2.boolean().default(false)
 });
 var CommandSkillConfigSchema = z2.object({
   id: z2.string().min(1),
@@ -1370,8 +1784,11 @@ var CommandSkillConfigSchema = z2.object({
   output_type: z2.enum(["json", "text", "file"]),
   allowed_commands: z2.array(z2.string()).optional(),
   working_dir: z2.string().optional(),
+  claude_code: ClaudeCodeConfigSchema.optional(),
   timeout_ms: z2.number().positive().default(3e4),
-  pricing: PricingSchema
+  pricing: PricingSchema,
+  capacity: CapacitySchema,
+  ...CapabilityDeclarationSchema
 });
 var ConductorSkillConfigSchema = z2.object({
   id: z2.string().min(1),
@@ -1379,7 +1796,9 @@ var ConductorSkillConfigSchema = z2.object({
   name: z2.string().min(1),
   conductor_skill: z2.enum(["orchestrate", "plan"]),
   pricing: PricingSchema,
-  timeout_ms: z2.number().positive().optional()
+  timeout_ms: z2.number().positive().optional(),
+  capacity: CapacitySchema,
+  ...CapabilityDeclarationSchema
 });
 var SkillConfigSchema = z2.discriminatedUnion("type", [
   ApiSkillConfigSchema,
@@ -1948,14 +2367,32 @@ var CommandExecutor = class {
     const cmdConfig = config;
     const baseCommand = cmdConfig.command.trim().split(/\s+/)[0] ?? "";
     if (cmdConfig.allowed_commands && cmdConfig.allowed_commands.length > 0) {
-      if (!cmdConfig.allowed_commands.includes(baseCommand)) {
+      const effectiveAllowed = cmdConfig.claude_code ? [.../* @__PURE__ */ new Set([...cmdConfig.allowed_commands, "claude"])] : cmdConfig.allowed_commands;
+      const commandToCheck = cmdConfig.claude_code ? "claude" : baseCommand;
+      if (!effectiveAllowed.includes(commandToCheck)) {
         return {
           success: false,
-          error: `Command not allowed: "${baseCommand}". Allowed: ${cmdConfig.allowed_commands.join(", ")}`
+          error: `Command not allowed: "${commandToCheck}". Allowed: ${effectiveAllowed.join(", ")}`
         };
       }
     }
-    const interpolatedCommand = safeInterpolateCommand2(cmdConfig.command, { params });
+    let interpolatedCommand;
+    if (cmdConfig.claude_code) {
+      const parts = ["claude", "--print"];
+      if (cmdConfig.claude_code.auto_mode) {
+        parts.push("--dangerously-skip-permissions");
+      }
+      if (cmdConfig.claude_code.model) {
+        parts.push("--model", cmdConfig.claude_code.model);
+      }
+      if (cmdConfig.claude_code.system_prompt) {
+        parts.push("-p", shellEscape2(cmdConfig.claude_code.system_prompt));
+      }
+      const interpolatedPrompt = safeInterpolateCommand2(cmdConfig.command, { params });
+      interpolatedCommand = parts.join(" ") + " " + interpolatedPrompt;
+    } else {
+      interpolatedCommand = safeInterpolateCommand2(cmdConfig.command, { params });
+    }
     const timeout = cmdConfig.timeout_ms ?? 3e4;
     const cwd = cmdConfig.working_dir ?? process.cwd();
     let stdout;
@@ -2017,7 +2454,143 @@ var CommandExecutor = class {
 };
 
 // src/conductor/task-decomposer.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
+
+// src/conductor/decomposition-validator.ts
+function validateAndNormalizeSubtasks(raw, context) {
+  try {
+    return _validate(raw, context);
+  } catch {
+    return { valid: [], errors: ["internal validation error"] };
+  }
+}
+function _validate(raw, context) {
+  if (!Array.isArray(raw)) {
+    return { valid: [], errors: ["decomposition output must be an array"] };
+  }
+  if (raw.length === 0) {
+    return { valid: [], errors: [] };
+  }
+  const errors = [];
+  const validItems = [];
+  const validIds = [];
+  for (let i = 0; i < raw.length; i++) {
+    const item = raw[i];
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      errors.push(`subtask[${i}]: must be an object`);
+      continue;
+    }
+    const obj = item;
+    let itemValid = true;
+    const id = obj["id"];
+    if (typeof id !== "string" || id.length === 0) {
+      errors.push(`subtask[${i}]: id must be a non-empty string`);
+      itemValid = false;
+    }
+    const description = obj["description"];
+    if (typeof description !== "string" || description.length === 0) {
+      errors.push(`subtask[${i}]: description must be a non-empty string`);
+      itemValid = false;
+    }
+    const required_capability = obj["required_capability"];
+    if (typeof required_capability !== "string" || required_capability.length === 0) {
+      errors.push(`subtask[${i}]: required_capability must be a non-empty string`);
+      itemValid = false;
+    }
+    const estimated_credits = obj["estimated_credits"];
+    if (estimated_credits !== void 0) {
+      if (typeof estimated_credits !== "number" || estimated_credits <= 0) {
+        errors.push(`subtask[${i}]: estimated_credits must be a positive number`);
+        itemValid = false;
+      } else if (estimated_credits > context.max_credits) {
+        errors.push(
+          `subtask[${i}]: estimated_credits ${estimated_credits} exceeds max_credits ${context.max_credits}`
+        );
+        itemValid = false;
+      }
+    }
+    if (itemValid) {
+      validItems.push(obj);
+      validIds.push(id);
+    }
+  }
+  const idSet = /* @__PURE__ */ new Set();
+  for (const id of validIds) {
+    if (idSet.has(id)) {
+      errors.push(`duplicate subtask id: ${id}`);
+    } else {
+      idSet.add(id);
+    }
+  }
+  for (let i = 0; i < validItems.length; i++) {
+    const item = validItems[i];
+    const depends_on = item["depends_on"];
+    if (!Array.isArray(depends_on)) continue;
+    for (const dep of depends_on) {
+      if (typeof dep === "string" && !idSet.has(dep)) {
+        errors.push(`subtask[${i}]: depends_on references unknown id '${dep}'`);
+      }
+    }
+  }
+  if (errors.length === 0 && validItems.length > 0) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const adjList = /* @__PURE__ */ new Map();
+    for (const id of validIds) {
+      inDegree.set(id, 0);
+      adjList.set(id, []);
+    }
+    for (const item of validItems) {
+      const depends_on = item["depends_on"];
+      if (!Array.isArray(depends_on)) continue;
+      for (const dep of depends_on) {
+        if (typeof dep !== "string" || !idSet.has(dep)) continue;
+        adjList.get(dep)?.push(item["id"]);
+        inDegree.set(item["id"], (inDegree.get(item["id"]) ?? 0) + 1);
+      }
+    }
+    const queue = [];
+    for (const [id, deg] of inDegree) {
+      if (deg === 0) queue.push(id);
+    }
+    let processed = 0;
+    while (queue.length > 0) {
+      const current = queue.shift();
+      processed++;
+      for (const neighbor of adjList.get(current) ?? []) {
+        const newDeg = (inDegree.get(neighbor) ?? 0) - 1;
+        inDegree.set(neighbor, newDeg);
+        if (newDeg === 0) queue.push(neighbor);
+      }
+    }
+    if (processed < validItems.length) {
+      for (const [id, deg] of inDegree) {
+        if (deg > 0) {
+          errors.push(`circular dependency detected involving subtask id: ${id}`);
+          break;
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { valid: [], errors };
+  }
+  const normalized = validItems.map((item) => {
+    const depends_on = Array.isArray(item["depends_on"]) ? item["depends_on"].filter((x) => typeof x === "string") : [];
+    const params = typeof item["params"] === "object" && item["params"] !== null && !Array.isArray(item["params"]) ? item["params"] : {};
+    const estimated_credits = typeof item["estimated_credits"] === "number" ? item["estimated_credits"] : 0;
+    return {
+      id: item["id"],
+      description: item["description"],
+      required_capability: item["required_capability"],
+      params,
+      depends_on,
+      estimated_credits
+    };
+  });
+  return { valid: normalized, errors: [] };
+}
+
+// src/conductor/task-decomposer.ts
 var TEMPLATES = {
   "video-production": {
     keywords: ["video", "demo", "clip", "animation"],
@@ -2112,7 +2685,7 @@ function decompose(task, _availableCapabilities) {
   for (const template of Object.values(TEMPLATES)) {
     const matched = template.keywords.some((kw) => lower.includes(kw));
     if (!matched) continue;
-    const ids = template.steps.map(() => randomUUID6());
+    const ids = template.steps.map(() => randomUUID7());
     return template.steps.map((step, i) => ({
       id: ids[i],
       description: step.description,
@@ -2126,10 +2699,10 @@ function decompose(task, _availableCapabilities) {
 }
 
 // src/gateway/client.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 async function requestCapability(opts) {
   const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
-  const id = randomUUID7();
+  const id = randomUUID8();
   const payload = {
     jsonrpc: "2.0",
     id,
@@ -2199,36 +2772,15 @@ async function requestViaRelay(relay, opts) {
 }
 
 // src/autonomy/tiers.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 
 // src/cli/peers.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join3 } from "path";
 
-// src/cli/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
-function getConfigDir() {
-  return process.env["AGENTBNB_DIR"] ?? join2(homedir(), ".agentbnb");
-}
-function getConfigPath() {
-  return join2(getConfigDir(), "config.json");
-}
-function loadConfig() {
-  const configPath = getConfigPath();
-  if (!existsSync2(configPath)) return null;
-  try {
-    const raw = readFileSync2(configPath, "utf-8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-
 // src/cli/remote-registry.ts
 var RegistryTimeoutError = class extends AgentBnBError {
   constructor(url) {
@@ -2326,12 +2878,14 @@ function scorePeers(candidates, selfOwner) {
     const idleRate = internal?.["idle_rate"];
     return typeof idleRate === "number" ? idleRate : 1;
   });
+  const loadFactors = eligible.map((c) => c.loadFactor ?? 1);
   const normSuccess = minMaxNormalize(successRates);
   const normCost = minMaxNormalize(costEfficiencies);
   const normIdle = minMaxNormalize(idleRates);
+  const normLoad = minMaxNormalize(loadFactors);
   const scored = eligible.map((c, i) => ({
     ...c,
-    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0)
+    rawScore: (normSuccess[i] ?? 0) * (normCost[i] ?? 0) * (normIdle[i] ?? 0) * (normLoad[i] ?? 0)
   }));
   scored.sort((a, b) => b.rawScore - a.rawScore);
   return scored;
@@ -2573,6 +3127,12 @@ function computeWaves(subtasks) {
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
+  const teamMemberMap = /* @__PURE__ */ new Map();
+  if (opts.team) {
+    for (const member of opts.team.matched) {
+      teamMemberMap.set(member.subtask.id, member);
+    }
+  }
   if (subtasks.length === 0) {
     return {
       success: true,
@@ -2584,6 +3144,7 @@ async function orchestrate(opts) {
   const results = /* @__PURE__ */ new Map();
   const errors = [];
   let totalCredits = 0;
+  const traceContext = /* @__PURE__ */ new Map();
   const waves = computeWaves(subtasks);
   const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
   for (const wave of waves) {
@@ -2620,7 +3181,11 @@ async function orchestrate(opts) {
           subtask.params,
           interpContext
         );
-        const primary = resolveAgentUrl(m.selected_agent);
+        const teamMember = teamMemberMap.get(taskId);
+        const teamId = opts.team?.team_id ?? null;
+        const taskCapabilityType = teamMember?.capability_type ?? null;
+        const agentOwner = teamMember?.agent ?? m.selected_agent;
+        const primary = resolveAgentUrl(agentOwner);
         try {
           let res;
           if (primary.url.startsWith("relay://") && relayClient) {
@@ -2641,7 +3206,7 @@ async function orchestrate(opts) {
               timeoutMs
             });
           }
-          return { taskId, result: res, credits: m.credits };
+          return { taskId, result: res, credits: m.credits, team_id: teamId, capability_type: taskCapabilityType };
         } catch (primaryErr) {
           if (m.alternatives.length > 0) {
             const alt = m.alternatives[0];
@@ -2666,7 +3231,7 @@ async function orchestrate(opts) {
                   timeoutMs
                 });
               }
-              return { taskId, result: altRes, credits: alt.credits };
+              return { taskId, result: altRes, credits: alt.credits, team_id: teamId, capability_type: taskCapabilityType };
             } catch (altErr) {
               throw new Error(
                 `Task ${taskId}: primary (${m.selected_agent}) failed: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}; alternative (${alt.agent}) failed: ${altErr instanceof Error ? altErr.message : String(altErr)}`
@@ -2681,9 +3246,10 @@ async function orchestrate(opts) {
     );
     for (const settlement of waveResults) {
       if (settlement.status === "fulfilled") {
-        const { taskId, result, credits } = settlement.value;
+        const { taskId, result, credits, team_id, capability_type } = settlement.value;
         results.set(taskId, result);
         totalCredits += credits;
+        traceContext.set(taskId, { team_id: team_id ?? null, capability_type: capability_type ?? null });
       } else {
         errors.push(settlement.reason instanceof Error ? settlement.reason.message : String(settlement.reason));
       }
@@ -2694,7 +3260,8 @@ async function orchestrate(opts) {
     results,
     total_credits: totalCredits,
     latency_ms: Date.now() - startTime,
-    errors: errors.length > 0 ? errors : void 0
+    errors: errors.length > 0 ? errors : void 0,
+    trace: traceContext.size > 0 ? traceContext : void 0
   };
 }
 
@@ -2743,6 +3310,96 @@ var BudgetManager = class {
   }
 };
 
+// src/conductor/team-formation.ts
+import { randomUUID as randomUUID11 } from "crypto";
+function selectByStrategy(matches, strategy) {
+  if (matches.length === 0) return void 0;
+  if (strategy === "balanced") {
+    return matches[0];
+  }
+  if (strategy === "quality_optimized") {
+    return matches.reduce((best, m) => m.score > best.score ? m : best, matches[0]);
+  }
+  return matches.reduce((best, m) => {
+    if (m.credits < best.credits) return m;
+    if (m.credits === best.credits && m.score > best.score) return m;
+    return best;
+  }, matches[0]);
+}
+async function formTeam(opts) {
+  const { subtasks, strategy, db, conductorOwner, registryUrl } = opts;
+  const team_id = randomUUID11();
+  if (subtasks.length === 0) {
+    return { team_id, strategy, matched: [], unrouted: [] };
+  }
+  const matched = [];
+  const unrouted = [];
+  for (const subtask of subtasks) {
+    const skillCards = getCardsBySkillCapability(db, subtask.required_capability).filter((c) => c.owner !== conductorOwner);
+    if (skillCards.length > 0) {
+      const candidates = skillCards.map((card) => {
+        const skills = card.skills ?? [];
+        const matchingSkill = skills.find(
+          (s) => s.capability_type === subtask.required_capability || (s.capability_types ?? []).includes(subtask.required_capability)
+        );
+        return {
+          subtask_id: subtask.id,
+          selected_agent: card.owner,
+          selected_skill: matchingSkill?.id ?? "",
+          selected_card_id: card.id,
+          score: 1,
+          credits: matchingSkill?.pricing.credits_per_call ?? 0,
+          alternatives: []
+        };
+      });
+      const selected2 = selectByStrategy(candidates, strategy);
+      matched.push({
+        subtask,
+        capability_type: subtask.required_capability,
+        agent: selected2.selected_agent,
+        skill: selected2.selected_skill,
+        card_id: selected2.selected_card_id,
+        credits: selected2.credits,
+        score: selected2.score
+      });
+      continue;
+    }
+    const matchResults = await matchSubTasks({
+      db,
+      subtasks: [subtask],
+      conductorOwner,
+      registryUrl
+    });
+    const m = matchResults[0];
+    if (!m || m.selected_agent === "") {
+      unrouted.push(subtask);
+      continue;
+    }
+    const allCandidates = [
+      m,
+      ...m.alternatives.map((alt) => ({
+        subtask_id: m.subtask_id,
+        selected_agent: alt.agent,
+        selected_skill: alt.skill,
+        score: alt.score,
+        credits: alt.credits,
+        alternatives: []
+      }))
+    ];
+    const selected = selectByStrategy(allCandidates, strategy);
+    matched.push({
+      subtask,
+      capability_type: subtask.required_capability,
+      agent: selected.selected_agent,
+      skill: selected.selected_skill,
+      card_id: selected === m ? m.selected_card_id : void 0,
+      credits: selected.credits,
+      score: selected.score
+    });
+  }
+  return { team_id, strategy, matched, unrouted };
+}
+
 // src/conductor/conductor-mode.ts
 var ConductorMode = class {
   db;
@@ -2781,7 +3438,48 @@ var ConductorMode = class {
         error: 'Missing or empty "task" parameter'
       };
     }
-    const subtasks = decompose(task);
+    const orchestrationDepth = typeof params.orchestration_depth === "number" ? params.orchestration_depth : 0;
+    const decompositionDepth = typeof params.decomposition_depth === "number" ? params.decomposition_depth : 0;
+    if (orchestrationDepth >= 2) {
+      return {
+        success: false,
+        error: "orchestration_depth limit exceeded: max 1 nested orchestration"
+      };
+    }
+    let subtasks = [];
+    if (decompositionDepth === 0) {
+      const allDecomposers = getCardsByCapabilityType(this.db, "task_decomposition");
+      const externalDecomposers = allDecomposers.filter((c) => c.owner !== this.conductorOwner);
+      if (externalDecomposers.length > 0) {
+        const provider = externalDecomposers[0];
+        try {
+          const providerUrl = this.resolveAgentUrl(provider.owner);
+          const response = await requestCapability({
+            gatewayUrl: providerUrl.url,
+            token: this.gatewayToken,
+            cardId: provider.id,
+            params: {
+              task,
+              decomposition_depth: decompositionDepth + 1,
+              orchestration_depth: orchestrationDepth + 1
+            },
+            timeoutMs: 3e4
+          });
+          if (Array.isArray(response)) {
+            const validation = validateAndNormalizeSubtasks(response, {
+              max_credits: this.maxBudget
+            });
+            if (validation.errors.length === 0) {
+              subtasks = validation.valid;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (subtasks.length === 0) {
+      subtasks = decompose(task);
+    }
     if (subtasks.length === 0) {
       return {
         success: false,
@@ -2795,6 +3493,17 @@ var ConductorMode = class {
       conductorOwner: this.conductorOwner
     });
     onProgress?.({ step: 2, total: 5, message: `Matched ${matchResults.length} sub-tasks to agents` });
+    let team;
+    if (conductorSkill === "orchestrate") {
+      const strategy = typeof params.formation_strategy === "string" && ["cost_optimized", "quality_optimized", "balanced"].includes(params.formation_strategy) ? params.formation_strategy : "balanced";
+      team = await formTeam({
+        subtasks,
+        strategy,
+        db: this.db,
+        conductorOwner: this.conductorOwner
+      });
+      onProgress?.({ step: 2, total: 5, message: `Formed team: ${team.matched.length} members, ${team.unrouted.length} unrouted` });
+    }
     const budgetManager = new BudgetManager(this.creditDb, this.conductorOwner);
     const budgetController = new BudgetController(budgetManager, this.maxBudget);
     const executionBudget = budgetController.calculateBudget(matchResults);
@@ -2811,7 +3520,9 @@ var ConductorMode = class {
         result: {
           subtasks,
           matches: matchResults,
-          budget: executionBudget
+          budget: executionBudget,
+          team
+          // undefined when no role hints
         }
       };
     }
@@ -2823,7 +3534,8 @@ var ConductorMode = class {
       matches: matchMap,
       gatewayToken: this.gatewayToken,
       resolveAgentUrl: this.resolveAgentUrl,
-      maxBudget: this.maxBudget
+      maxBudget: this.maxBudget,
+      team
     });
     onProgress?.({ step: 4, total: 5, message: "Pipeline execution complete" });
     const resultObj = {};
@@ -2846,7 +3558,7 @@ var ConductorMode = class {
 
 // src/credit/escrow-receipt.ts
 import { z as z3 } from "zod";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 var EscrowReceiptSchema = z3.object({
   requester_owner: z3.string().min(1),
   requester_public_key: z3.string().min(1),
@@ -2866,7 +3578,7 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
     card_id: opts.cardId,
     ...opts.skillId ? { skill_id: opts.skillId } : {},
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nonce: randomUUID10()
+    nonce: randomUUID12()
   };
   const signature = signEscrowReceipt(receiptData, privateKey);
   const receipt = {
@@ -3237,7 +3949,7 @@ var AgentBnBProvider = class {
 
 // src/identity/guarantor.ts
 import { z as z5 } from "zod";
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var MAX_AGENTS_PER_GUARANTOR = 10;
 var GUARANTOR_CREDIT_POOL = 50;
 var GuarantorRecordSchema = z5.object({
@@ -3276,7 +3988,7 @@ function registerGuarantor(db, githubLogin) {
     );
   }
   const record = {
-    id: randomUUID11(),
+    id: randomUUID13(),
     github_login: githubLogin,
     agent_count: 0,
     credit_pool: GUARANTOR_CREDIT_POOL,
@@ -3350,7 +4062,7 @@ function getAgentGuarantor(db, agentId) {
 function initiateGithubAuth() {
   return {
     auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
-    state: randomUUID11()
+    state: randomUUID13()
   };
 }
 
@@ -3422,6 +4134,27 @@ var RelayProgressMessageSchema = z6.object({
   message: z6.string().optional()
   // optional status message
 });
+var HeartbeatMessageSchema = z6.object({
+  type: z6.literal("heartbeat"),
+  owner: z6.string().min(1),
+  capacity: z6.object({
+    current_load: z6.number(),
+    max_concurrent: z6.number(),
+    queue_depth: z6.number()
+  }),
+  self_summary: z6.object({
+    capabilities: z6.array(z6.string()),
+    success_rate: z6.number(),
+    credit_balance: z6.number(),
+    total_completed: z6.number(),
+    provider_number: z6.number(),
+    reliability: z6.object({
+      current_streak: z6.number(),
+      repeat_hire_rate: z6.number(),
+      avg_feedback: z6.number()
+    })
+  })
+});
 var RelayMessageSchema = z6.discriminatedUnion("type", [
   RegisterMessageSchema,
   RegisteredMessageSchema,
@@ -3430,11 +4163,12 @@ var RelayMessageSchema = z6.discriminatedUnion("type", [
   RelayResponseMessageSchema,
   ResponseMessageSchema,
   ErrorMessageSchema,
-  RelayProgressMessageSchema
+  RelayProgressMessageSchema,
+  HeartbeatMessageSchema
 ]);
 
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // src/relay/relay-credit.ts
 function lookupCardPrice(registryDb, cardId, skillId) {
@@ -3492,10 +4226,10 @@ function releaseForRelay(creditDb, escrowId) {
 }
 
 // src/hub-agent/relay-bridge.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 
 // src/hub-agent/job-queue.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 function updateJobStatus(db, jobId, status, result) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (result !== void 0) {
@@ -3540,6 +4274,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   const connections = /* @__PURE__ */ new Map();
   const pendingRequests = /* @__PURE__ */ new Map();
   const rateLimits = /* @__PURE__ */ new Map();
+  const agentCapacities = /* @__PURE__ */ new Map();
   let onAgentOnlineCallback;
   function checkRateLimit(owner) {
     const now = Date.now();
@@ -3616,7 +4351,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID14(),
+        id: randomUUID16(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -3843,6 +4578,7 @@ function registerWebSocketRelay(server, db, creditDb) {
     if (!owner) return;
     connections.delete(owner);
     rateLimits.delete(owner);
+    agentCapacities.delete(owner);
     markOwnerOffline(owner);
     for (const [reqId, pending] of pendingRequests) {
       if (pending.targetOwner === owner) {
@@ -3876,6 +4612,9 @@ function registerWebSocketRelay(server, db, creditDb) {
       }
     }
   }
+  function handleHeartbeat(msg) {
+    agentCapacities.set(msg.owner, msg.capacity);
+  }
   void server.register(async (app) => {
     app.get("/ws", { websocket: true }, (rawSocket, _request) => {
       const socket = rawSocket;
@@ -3921,15 +4660,23 @@ function registerWebSocketRelay(server, db, creditDb) {
             case "relay_progress":
               handleRelayProgress(msg);
               break;
+            case "heartbeat":
+              handleHeartbeat(msg);
+              break;
             default:
               break;
           }
         })();
       });
+      const pingInterval = setInterval(() => {
+        if (socket.readyState === 1) socket.ping();
+      }, 3e4);
       socket.on("close", () => {
+        clearInterval(pingInterval);
         handleDisconnect(registeredOwner);
       });
       socket.on("error", () => {
+        clearInterval(pingInterval);
         handleDisconnect(registeredOwner);
       });
     });
@@ -3950,6 +4697,7 @@ function registerWebSocketRelay(server, db, creditDb) {
       }
       pendingRequests.clear();
       rateLimits.clear();
+      agentCapacities.clear();
     },
     setOnAgentOnline: (cb) => {
       onAgentOnlineCallback = cb;
@@ -3958,13 +4706,15 @@ function registerWebSocketRelay(server, db, creditDb) {
     getPendingRequests: () => pendingRequests,
     sendMessage: (ws, msg) => {
       sendMessage(ws, msg);
-    }
+    },
+    getAgentCapacity: (owner) => agentCapacities.get(owner),
+    getAllCapacities: () => new Map(agentCapacities)
   };
 }
 
 // src/relay/websocket-client.ts
 import WebSocket from "ws";
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 var RelayClient = class {
   ws = null;
   opts;
@@ -4061,7 +4811,7 @@ var RelayClient = class {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registered) {
       throw new Error("Not connected to registry relay");
     }
-    const id = randomUUID15();
+    const id = randomUUID17();
     const timeoutMs = opts.timeoutMs ?? 3e5;
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -4265,12 +5015,12 @@ var RelayClient = class {
 };
 
 // src/onboarding/index.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join5 } from "path";
 
 // src/cli/onboarding.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import { createConnection } from "net";
 var KNOWN_API_KEYS = [
   "OPENAI_API_KEY",
@@ -4412,7 +5162,7 @@ function capabilitiesToV2Card(capabilities, owner, agentName) {
   }));
   const card = {
     spec_version: "2.0",
-    id: randomUUID17(),
+    id: randomUUID19(),
     owner,
     agent_name: agentName ?? owner,
     skills,