agentbnb 8.2.0 → 8.2.2

package/dist/index.js

@@ -1,3 +1,8 @@
+import {
+  RelayClient,
+  RelayMessageSchema
+} from "./chunk-3LWBH7P3.js";
+
 // src/types/index.ts
 import { z } from "zod";
 var IOSchemaSchema = z.object({
@@ -351,7 +356,10 @@ var V2_FTS_TRIGGERS = `
       new.id,
       new.owner,
       COALESCE(
-        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
          FROM json_each(json_extract(new.data, '$.skills'))),
         json_extract(new.data, '$.name'),
         ''
@@ -391,7 +399,10 @@ var V2_FTS_TRIGGERS = `
       old.id,
       old.owner,
       COALESCE(
-        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
          FROM json_each(json_extract(old.data, '$.skills'))),
         json_extract(old.data, '$.name'),
         ''
@@ -427,7 +438,10 @@ var V2_FTS_TRIGGERS = `
       new.id,
       new.owner,
       COALESCE(
-        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
          FROM json_each(json_extract(new.data, '$.skills'))),
         json_extract(new.data, '$.name'),
         ''
@@ -467,7 +481,10 @@ var V2_FTS_TRIGGERS = `
       old.id,
       old.owner,
       COALESCE(
-        (SELECT group_concat(json_extract(value, '$.name'), ' ')
+        (SELECT group_concat(
+            COALESCE(json_extract(value, '$.id'), '') || ' ' || COALESCE(json_extract(value, '$.name'), ''),
+            ' '
+         )
          FROM json_each(json_extract(old.data, '$.skills'))),
         json_extract(old.data, '$.name'),
         ''
@@ -534,6 +551,15 @@ function openDatabase(path = ":memory:") {
       tags,
       content=""
     );
+
+    -- Expression index for capability_type lookups (used by Conductor routing).
+    -- Turns json_extract full-table-scan into O(log n) B-tree lookup.
+    CREATE INDEX IF NOT EXISTS idx_cards_capability_type
+      ON capability_cards(json_extract(data, '$.capability_type'));
+
+    -- Owner index for listCards(owner) and other owner-scoped queries.
+    CREATE INDEX IF NOT EXISTS idx_cards_owner
+      ON capability_cards(owner);
   `);
   createRequestLogTable(db);
   initFeedbackTable(db);
@@ -545,6 +571,10 @@ function runMigrations(db) {
   const version = db.pragma("user_version")[0]?.user_version ?? 0;
   if (version < 2) {
     migrateV1toV2(db);
+    return;
+  }
+  if (version < 3) {
+    migrateV2toV3(db);
   }
 }
 function migrateV1toV2(db) {
@@ -586,44 +616,55 @@ function migrateV1toV2(db) {
       );
     }
     db.exec(V2_FTS_TRIGGERS);
-    db.exec(`INSERT INTO cards_fts(cards_fts) VALUES('delete-all')`);
-    const allRows = db.prepare("SELECT rowid, id, owner, data FROM capability_cards").all();
-    const ftsInsert = db.prepare(
-      "INSERT INTO cards_fts(rowid, id, owner, name, description, tags) VALUES (?, ?, ?, ?, ?, ?)"
-    );
-    for (const row of allRows) {
-      const data = JSON.parse(row.data);
-      const skills = data["skills"] ?? [];
-      let name;
-      let description;
-      let tags;
-      if (skills.length > 0) {
-        name = skills.map((s) => String(s["name"] ?? "")).join(" ");
-        description = skills.map((s) => String(s["description"] ?? "")).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"] ?? "");
-        const meta = data["metadata"];
-        const rawTags = meta?.["tags"] ?? [];
-        tags = rawTags.join(" ");
-      }
-      ftsInsert.run(row.rowid, row.id, row.owner, name, description, tags);
-    }
-    db.pragma("user_version = 2");
+    rebuildCardsFts(db);
+    db.pragma("user_version = 3");
   });
   migrate();
 }
+function migrateV2toV3(db) {
+  const migrate = db.transaction(() => {
+    db.exec(V2_FTS_TRIGGERS);
+    rebuildCardsFts(db);
+    db.pragma("user_version = 3");
+  });
+  migrate();
+}
+function rebuildCardsFts(db) {
+  db.exec(`INSERT INTO cards_fts(cards_fts) VALUES('delete-all')`);
+  const allRows = db.prepare("SELECT rowid, id, owner, data FROM capability_cards").all();
+  const ftsInsert = db.prepare(
+    "INSERT INTO cards_fts(rowid, id, owner, name, description, tags) VALUES (?, ?, ?, ?, ?, ?)"
+  );
+  for (const row of allRows) {
+    const data = JSON.parse(row.data);
+    const skills = data["skills"] ?? [];
+    let name;
+    let description;
+    let tags;
+    if (skills.length > 0) {
+      name = skills.map((s) => `${String(s["id"] ?? "")} ${String(s["name"] ?? "")}`.trim()).join(" ");
+      description = skills.map((s) => String(s["description"] ?? "")).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"] ?? "");
+      const meta = data["metadata"];
+      const rawTags = meta?.["tags"] ?? [];
+      tags = rawTags.join(" ");
+    }
+    ftsInsert.run(row.rowid, row.id, row.owner, name, description, tags);
+  }
+}
 function insertCard(db, card) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const withTimestamps = { ...card, created_at: card.created_at ?? now, updated_at: now };
@@ -753,9 +794,43 @@ function getReputationScore(db, agentId) {
 }
 
 // src/registry/matcher.ts
+var CACHE_MAX_ENTRIES = 100;
+var CACHE_TTL_MS = 3e4;
+var dbCaches = /* @__PURE__ */ new WeakMap();
+function getDbCache(db) {
+  let cache = dbCaches.get(db);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    dbCaches.set(db, cache);
+  }
+  return cache;
+}
+function cacheKey(query, filters) {
+  return `${query}|${filters.level ?? ""}|${filters.online ?? ""}|${(filters.apis_used ?? []).join(",")}|${filters.min_reputation ?? ""}`;
+}
+function evictCache(cache) {
+  const now = Date.now();
+  for (const [key, entry] of cache) {
+    if (entry.expiresAt <= now) cache.delete(key);
+  }
+  while (cache.size > CACHE_MAX_ENTRIES) {
+    const firstKey = cache.keys().next().value;
+    cache.delete(firstKey);
+  }
+}
 function searchCards(db, query, filters = {}) {
+  const cache = getDbCache(db);
+  const key = cacheKey(query, filters);
+  const cached = cache.get(key);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.results;
+  }
+  const trimmedQuery = query.trim();
+  const exactSkillMatches = findCardsByExactSkillId(db, trimmedQuery, filters);
   const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
-  if (words.length === 0) return [];
+  if (words.length === 0) {
+    return exactSkillMatches;
+  }
   const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
   const conditions = [];
   const params = [ftsQuery];
@@ -780,7 +855,8 @@ function searchCards(db, query, filters = {}) {
   const stmt = db.prepare(sql);
   const rows = stmt.all(...params);
   const results = rows.map((row) => JSON.parse(row.data));
-  let filtered = results;
+  const mergedResults = mergeByCardId(exactSkillMatches, results);
+  let filtered = mergedResults;
   if (filters.apis_used && filters.apis_used.length > 0) {
     const requiredApis = filters.apis_used;
     filtered = filtered.filter((card) => {
@@ -791,8 +867,38 @@ function searchCards(db, query, filters = {}) {
   if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
     filtered = applyReputationFilter(db, filtered, filters.min_reputation);
   }
+  evictCache(cache);
+  cache.set(key, { results: filtered, expiresAt: Date.now() + CACHE_TTL_MS });
   return filtered;
 }
+function mergeByCardId(primary, secondary) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const card of primary) {
+    if (seen.has(card.id)) continue;
+    seen.add(card.id);
+    merged.push(card);
+  }
+  for (const card of secondary) {
+    if (seen.has(card.id)) continue;
+    seen.add(card.id);
+    merged.push(card);
+  }
+  return merged;
+}
+function findCardsByExactSkillId(db, query, filters) {
+  if (query.length === 0) return [];
+  const rows = db.prepare("SELECT data FROM capability_cards").all();
+  const cards = rows.map((row) => JSON.parse(row.data));
+  return cards.filter((card) => {
+    if (filters.level !== void 0 && card.level !== filters.level) return false;
+    if (filters.online !== void 0 && card.availability?.online !== filters.online) return false;
+    const asRecord = card;
+    const skills = asRecord["skills"];
+    if (!Array.isArray(skills)) return false;
+    return skills.some((skill) => String(skill["id"] ?? "") === query);
+  });
+}
 function applyReputationFilter(db, cards, minReputation) {
   const owners = [...new Set(cards.map((c) => c.owner))];
   const reputationMap = /* @__PURE__ */ new Map();
@@ -1178,7 +1284,25 @@ function loadKeyPair(configDir) {
   };
 }
 function canonicalJson(data) {
-  return JSON.stringify(data, Object.keys(data).sort());
+  return JSON.stringify(sortForCanonicalJson(data));
+}
+function sortForCanonicalJson(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortForCanonicalJson(item));
+  }
+  if (value !== null && typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null) {
+      const input = value;
+      const output = {};
+      const sortedKeys = Object.keys(input).sort();
+      for (const key of sortedKeys) {
+        output[key] = sortForCanonicalJson(input[key]);
+      }
+      return output;
+    }
+  }
+  return value;
 }
 function signEscrowReceipt(data, privateKey) {
   const message = Buffer.from(canonicalJson(data), "utf-8");
@@ -1238,6 +1362,73 @@ function loadConfig() {
   }
 }
 
+// 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;
+}
+
 // src/gateway/execute.ts
 async function notifyTelegramSkillExecuted(opts) {
   const cfg = loadConfig();
@@ -1520,7 +1711,54 @@ function createGatewayServer(opts) {
     return { status: "ok", version: VERSION, uptime: process.uptime() };
   });
   fastify.post("/rpc", async (request, reply) => {
-    const body = request.body;
+    const rawBody = request.body;
+    if (Array.isArray(rawBody)) {
+      const responses = await Promise.all(
+        rawBody.map(async (single) => {
+          if (single.jsonrpc !== "2.0" || !single.method) {
+            return { jsonrpc: "2.0", id: single.id ?? null, error: { code: -32600, message: "Invalid Request" } };
+          }
+          if (single.method !== "capability.execute") {
+            return { jsonrpc: "2.0", id: single.id ?? null, error: { code: -32601, message: "Method not found" } };
+          }
+          const params2 = single.params ?? {};
+          const cardId2 = params2.card_id;
+          if (!cardId2) {
+            return { jsonrpc: "2.0", id: single.id ?? null, error: { code: -32602, message: "Invalid params: card_id required" } };
+          }
+          const requester2 = params2.requester ?? "unknown";
+          const receipt2 = params2.escrow_receipt;
+          const batchSkillId = params2.skill_id;
+          const trackKey2 = batchSkillId ?? cardId2;
+          inFlight.set(trackKey2, (inFlight.get(trackKey2) ?? 0) + 1);
+          try {
+            const result2 = await executeCapabilityRequest({
+              registryDb,
+              creditDb,
+              cardId: cardId2,
+              skillId: batchSkillId,
+              params: params2,
+              requester: requester2,
+              escrowReceipt: receipt2,
+              skillExecutor,
+              handlerUrl,
+              timeoutMs
+            });
+            if (result2.success) {
+              return { jsonrpc: "2.0", id: single.id ?? null, result: result2.result };
+            } else {
+              return { jsonrpc: "2.0", id: single.id ?? null, error: result2.error };
+            }
+          } finally {
+            const next = (inFlight.get(trackKey2) ?? 1) - 1;
+            if (next <= 0) inFlight.delete(trackKey2);
+            else inFlight.set(trackKey2, next);
+          }
+        })
+      );
+      return reply.send(responses);
+    }
+    const body = rawBody;
     if (body.jsonrpc !== "2.0" || !body.method) {
       return reply.status(400).send({
         jsonrpc: "2.0",
@@ -2839,8 +3077,31 @@ function decompose(task, _availableCapabilities) {
   return [];
 }
 
+// src/autonomy/auto-request.ts
+import { randomUUID as randomUUID11 } from "crypto";
+
 // src/gateway/client.ts
 import { randomUUID as randomUUID8 } from "crypto";
+import { Agent } from "undici";
+var gatewayAgent = new Agent({
+  keepAliveTimeout: 3e4,
+  keepAliveMaxTimeout: 6e4,
+  connections: 10,
+  pipelining: 1
+});
+function buildGatewayAuthHeaders(payload, token, identity) {
+  const headers = { "Content-Type": "application/json" };
+  if (identity) {
+    const signature = signEscrowReceipt(payload, identity.privateKey);
+    headers["X-Agent-Id"] = identity.agentId;
+    headers["X-Agent-Public-Key"] = identity.publicKey;
+    headers["X-Agent-Signature"] = signature;
+  }
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  return headers;
+}
 async function requestCapability(opts) {
   const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
   const id = randomUUID8();
@@ -2854,15 +3115,7 @@ async function requestCapability(opts) {
       ...escrowReceipt ? { escrow_receipt: escrowReceipt } : {}
     }
   };
-  const headers = { "Content-Type": "application/json" };
-  if (identity) {
-    const signature = signEscrowReceipt(payload, identity.privateKey);
-    headers["X-Agent-Id"] = identity.agentId;
-    headers["X-Agent-Public-Key"] = identity.publicKey;
-    headers["X-Agent-Signature"] = signature;
-  } else if (token) {
-    headers["Authorization"] = `Bearer ${token}`;
-  }
+  const headers = buildGatewayAuthHeaders(payload, token, identity);
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   let response;
@@ -2871,7 +3124,9 @@ async function requestCapability(opts) {
       method: "POST",
       headers,
       body: JSON.stringify(payload),
-      signal: controller.signal
+      signal: controller.signal,
+      // undici dispatcher for connection pooling (Node.js 20+)
+      dispatcher: gatewayAgent
     });
   } catch (err) {
     clearTimeout(timer);
@@ -2889,6 +3144,65 @@ async function requestCapability(opts) {
   }
   return body.result;
 }
+async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
+  if (items.length === 0) return /* @__PURE__ */ new Map();
+  if (items.length === 1) {
+    const item = items[0];
+    const result = await requestCapability({
+      gatewayUrl,
+      token,
+      cardId: item.cardId,
+      params: item.params,
+      escrowReceipt: item.escrowReceipt,
+      timeoutMs: opts.timeoutMs,
+      identity: opts.identity
+    });
+    return /* @__PURE__ */ new Map([[item.id, result]]);
+  }
+  const { timeoutMs = 3e5, identity } = opts;
+  const batchPayload = items.map((item) => ({
+    jsonrpc: "2.0",
+    id: item.id,
+    method: "capability.execute",
+    params: {
+      card_id: item.cardId,
+      ...item.params,
+      ...item.escrowReceipt ? { escrow_receipt: item.escrowReceipt } : {}
+    }
+  }));
+  const headers = buildGatewayAuthHeaders(batchPayload, token, identity);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(batchPayload),
+      signal: controller.signal,
+      dispatcher: gatewayAgent
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Batch request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  const results = /* @__PURE__ */ new Map();
+  for (const resp of body) {
+    if (resp.error) {
+      results.set(resp.id, new AgentBnBError(resp.error.message, `RPC_ERROR_${resp.error.code}`));
+    } else {
+      results.set(resp.id, resp.result);
+    }
+  }
+  return results;
+}
 async function requestViaRelay(relay, opts) {
   try {
     return await relay.request({
@@ -2922,73 +3236,6 @@ import { randomUUID as randomUUID10 } from "crypto";
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
 import { join as join3 } from "path";
 
-// 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;
-}
-
 // src/autonomy/auto-request.ts
 function minMaxNormalize(values) {
   if (values.length === 0) return [];
@@ -3265,6 +3512,65 @@ function computeWaves(subtasks) {
   }
   return waves;
 }
+async function executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl) {
+  const { taskId, match: m, interpolatedParams, primary, teamId, capabilityType } = pt;
+  try {
+    let res;
+    if (primary.url.startsWith("relay://") && relayClient) {
+      const targetOwner = primary.url.replace("relay://", "");
+      res = await relayClient.request({
+        targetOwner,
+        cardId: primary.cardId,
+        params: interpolatedParams,
+        requester: requesterOwner,
+        timeoutMs
+      });
+    } else {
+      res = await requestCapability({
+        gatewayUrl: primary.url,
+        token: gatewayToken,
+        cardId: primary.cardId,
+        params: { ...interpolatedParams, requester: requesterOwner },
+        timeoutMs
+      });
+    }
+    return { taskId, result: res, credits: m.credits, team_id: teamId, capability_type: capabilityType };
+  } catch (primaryErr) {
+    if (m.alternatives.length > 0) {
+      const alt = m.alternatives[0];
+      const altResolved = resolveAgentUrl ? resolveAgentUrl(alt.agent) : { url: `http://${alt.agent}:7700`, cardId: `card-${alt.agent}` };
+      try {
+        let altRes;
+        if (altResolved.url.startsWith("relay://") && relayClient) {
+          const targetOwner = altResolved.url.replace("relay://", "");
+          altRes = await relayClient.request({
+            targetOwner,
+            cardId: altResolved.cardId,
+            params: interpolatedParams,
+            requester: requesterOwner,
+            timeoutMs
+          });
+        } else {
+          altRes = await requestCapability({
+            gatewayUrl: altResolved.url,
+            token: gatewayToken,
+            cardId: altResolved.cardId,
+            params: { ...interpolatedParams, requester: requesterOwner },
+            timeoutMs
+          });
+        }
+        return { taskId, result: altRes, credits: alt.credits, team_id: teamId, capability_type: capabilityType };
+      } 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)}`
+        );
+      }
+    }
+    throw new Error(
+      `Task ${taskId}: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`
+    );
+  }
+}
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
@@ -3302,89 +3608,127 @@ async function orchestrate(opts) {
       }
       executableIds.push(taskId);
     }
-    const waveResults = await Promise.allSettled(
-      executableIds.map(async (taskId) => {
-        const subtask = subtaskMap.get(taskId);
-        const m = matches.get(taskId);
-        if (!m) {
-          throw new Error(`No match found for subtask ${taskId}`);
-        }
-        const stepsContext = {};
-        for (const [id, val] of results) {
-          stepsContext[id] = val;
-        }
-        const interpContext = { steps: stepsContext, prev: void 0 };
-        if (subtask.depends_on.length > 0) {
-          const lastDep = subtask.depends_on[subtask.depends_on.length - 1];
-          interpContext.prev = results.get(lastDep);
-        }
-        const interpolatedParams = interpolateObject(
-          subtask.params,
-          interpContext
-        );
-        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) {
-            const targetOwner = primary.url.replace("relay://", "");
-            res = await relayClient.request({
-              targetOwner,
-              cardId: primary.cardId,
-              params: interpolatedParams,
-              requester: requesterOwner,
-              timeoutMs
-            });
-          } else {
-            res = await requestCapability({
-              gatewayUrl: primary.url,
-              token: gatewayToken,
-              cardId: primary.cardId,
-              params: { ...interpolatedParams, requester: requesterOwner },
-              timeoutMs
-            });
-          }
-          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];
-            const altAgent = resolveAgentUrl(alt.agent);
+    const preparedTasks = [];
+    for (const taskId of executableIds) {
+      const subtask = subtaskMap.get(taskId);
+      const m = matches.get(taskId);
+      if (!m) {
+        errors.push(`No match found for subtask ${taskId}`);
+        continue;
+      }
+      const stepsContext = {};
+      for (const [id, val] of results) stepsContext[id] = val;
+      const interpContext = { steps: stepsContext, prev: void 0 };
+      if (subtask.depends_on.length > 0) {
+        const lastDep = subtask.depends_on[subtask.depends_on.length - 1];
+        interpContext.prev = results.get(lastDep);
+      }
+      const interpolatedParams = interpolateObject(
+        subtask.params,
+        interpContext
+      );
+      const teamMember = teamMemberMap.get(taskId);
+      const agentOwner = teamMember?.agent ?? m.selected_agent;
+      const primary = resolveAgentUrl(agentOwner);
+      preparedTasks.push({
+        taskId,
+        subtask,
+        match: m,
+        interpolatedParams,
+        agentOwner,
+        primary,
+        teamId: opts.team?.team_id ?? null,
+        capabilityType: teamMember?.capability_type ?? null
+      });
+    }
+    const httpGroups = /* @__PURE__ */ new Map();
+    const relayTasks = [];
+    for (const pt of preparedTasks) {
+      if (pt.primary.url.startsWith("relay://") && relayClient) {
+        relayTasks.push(pt);
+      } else {
+        const group = httpGroups.get(pt.primary.url) ?? [];
+        group.push(pt);
+        httpGroups.set(pt.primary.url, group);
+      }
+    }
+    const batchPromises = [];
+    for (const [gatewayUrl, group] of httpGroups) {
+      if (group.length >= 2) {
+        batchPromises.push(
+          (async () => {
+            const items = group.map((pt) => ({
+              id: pt.taskId,
+              cardId: pt.primary.cardId,
+              params: { ...pt.interpolatedParams, requester: requesterOwner },
+              _pt: pt
+            }));
             try {
-              let altRes;
-              if (altAgent.url.startsWith("relay://") && relayClient) {
-                const targetOwner = altAgent.url.replace("relay://", "");
-                altRes = await relayClient.request({
-                  targetOwner,
-                  cardId: altAgent.cardId,
-                  params: interpolatedParams,
-                  requester: requesterOwner,
-                  timeoutMs
-                });
-              } else {
-                altRes = await requestCapability({
-                  gatewayUrl: altAgent.url,
-                  token: gatewayToken,
-                  cardId: altAgent.cardId,
-                  params: { ...interpolatedParams, requester: requesterOwner },
-                  timeoutMs
-                });
-              }
-              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)}`
+              const batchResults = await requestCapabilityBatch(
+                gatewayUrl,
+                gatewayToken,
+                items.map(({ _pt, ...item }) => item),
+                { timeoutMs }
               );
+              return items.map((item) => {
+                const res = batchResults.get(item.id);
+                if (res instanceof Error) {
+                  return {
+                    status: "rejected",
+                    reason: new Error(`Task ${item.id}: ${res.message}`)
+                  };
+                }
+                return {
+                  status: "fulfilled",
+                  value: {
+                    taskId: item.id,
+                    result: res,
+                    credits: item._pt.match.credits,
+                    team_id: item._pt.teamId,
+                    capability_type: item._pt.capabilityType
+                  }
+                };
+              });
+            } catch (batchErr) {
+              return Promise.all(group.map(async (pt) => {
+                try {
+                  const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+                  return { status: "fulfilled", value: res };
+                } catch (err) {
+                  return { status: "rejected", reason: err };
+                }
+              }));
             }
+          })()
+        );
+      } else {
+        const pt = group[0];
+        batchPromises.push(
+          (async () => {
+            try {
+              const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+              return [{ status: "fulfilled", value: res }];
+            } catch (err) {
+              return [{ status: "rejected", reason: err }];
+            }
+          })()
+        );
+      }
+    }
+    for (const pt of relayTasks) {
+      batchPromises.push(
+        (async () => {
+          try {
+            const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+            return [{ status: "fulfilled", value: res }];
+          } catch (err) {
+            return [{ status: "rejected", reason: err }];
           }
-          throw new Error(
-            `Task ${taskId}: ${primaryErr instanceof Error ? primaryErr.message : String(primaryErr)}`
-          );
-        }
-      })
-    );
+        })()
+      );
+    }
+    const allBatchResults = await Promise.all(batchPromises);
+    const waveResults = allBatchResults.flat();
     for (const settlement of waveResults) {
       if (settlement.status === "fulfilled") {
         const { taskId, result, credits, team_id, capability_type } = settlement.value;
@@ -3452,7 +3796,7 @@ var BudgetManager = class {
 };
 
 // src/conductor/team-formation.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function selectByStrategy(matches, strategy) {
   if (matches.length === 0) return void 0;
   if (strategy === "balanced") {
@@ -3469,7 +3813,7 @@ function selectByStrategy(matches, strategy) {
 }
 async function formTeam(opts) {
   const { subtasks, strategy, db, conductorOwner, registryUrl } = opts;
-  const team_id = randomUUID11();
+  const team_id = randomUUID12();
   if (subtasks.length === 0) {
     return { team_id, strategy, matched: [], unrouted: [] };
   }
@@ -3699,7 +4043,7 @@ var ConductorMode = class {
 
 // src/credit/escrow-receipt.ts
 import { z as z3 } from "zod";
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 var EscrowReceiptSchema = z3.object({
   requester_owner: z3.string().min(1),
   requester_agent_id: z3.string().optional(),
@@ -3721,7 +4065,7 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
     card_id: opts.cardId,
     ...opts.skillId ? { skill_id: opts.skillId } : {},
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nonce: randomUUID12()
+    nonce: randomUUID13()
   };
   const signature = signEscrowReceipt(receiptData, privateKey);
   const receipt = {
@@ -3733,7 +4077,7 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
 
 // src/identity/identity.ts
 import { z as z4 } from "zod";
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash2, createPrivateKey as createPrivateKey2, createPublicKey as createPublicKey2 } from "crypto";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
 import { join as join4 } from "path";
 var AgentIdentitySchema = z4.object({
@@ -3763,6 +4107,30 @@ var AgentCertificateSchema = z4.object({
   signature: z4.string().min(1)
 });
 var IDENTITY_FILENAME = "identity.json";
+var PRIVATE_KEY_FILENAME = "private.key";
+var PUBLIC_KEY_FILENAME = "public.key";
+function derivePublicKeyFromPrivate(privateKey) {
+  const privateKeyObject = createPrivateKey2({ key: privateKey, format: "der", type: "pkcs8" });
+  const publicKeyObject = createPublicKey2(privateKeyObject);
+  const publicKey = publicKeyObject.export({ format: "der", type: "spki" });
+  return Buffer.from(publicKey);
+}
+function buildIdentityFromPublicKey(publicKey, owner, createdAt) {
+  const publicKeyHex = publicKey.toString("hex");
+  return {
+    agent_id: deriveAgentId(publicKeyHex),
+    owner,
+    public_key: publicKeyHex,
+    created_at: createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function generateFreshIdentity(configDir, owner) {
+  const keys = generateKeyPair();
+  saveKeyPair(configDir, keys);
+  const identity = buildIdentityFromPublicKey(keys.publicKey, owner);
+  saveIdentity(configDir, identity);
+  return { identity, keys, status: "generated" };
+}
 function deriveAgentId(publicKeyHex) {
   return createHash2("sha256").update(publicKeyHex, "hex").digest("hex").slice(0, 16);
 }
@@ -3805,6 +4173,57 @@ function saveIdentity(configDir, identity) {
   const filePath = join4(configDir, IDENTITY_FILENAME);
   writeFileSync4(filePath, JSON.stringify(identity, null, 2), "utf-8");
 }
+function loadOrRepairIdentity(configDir, ownerHint) {
+  if (!existsSync4(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
+  }
+  const identityPath = join4(configDir, IDENTITY_FILENAME);
+  const privateKeyPath = join4(configDir, PRIVATE_KEY_FILENAME);
+  const publicKeyPath = join4(configDir, PUBLIC_KEY_FILENAME);
+  const hasIdentity = existsSync4(identityPath);
+  const hasPrivateKey = existsSync4(privateKeyPath);
+  const hasPublicKey = existsSync4(publicKeyPath);
+  if (!hasIdentity || !hasPrivateKey || !hasPublicKey) {
+    return generateFreshIdentity(configDir, ownerHint ?? "agent");
+  }
+  let keys;
+  try {
+    keys = loadKeyPair(configDir);
+  } catch {
+    return generateFreshIdentity(configDir, ownerHint ?? "agent");
+  }
+  let derivedPublicKey;
+  try {
+    derivedPublicKey = derivePublicKeyFromPrivate(keys.privateKey);
+  } catch {
+    return generateFreshIdentity(configDir, ownerHint ?? "agent");
+  }
+  let keypairRepaired = false;
+  if (!keys.publicKey.equals(derivedPublicKey)) {
+    keypairRepaired = true;
+    keys = { privateKey: keys.privateKey, publicKey: derivedPublicKey };
+    saveKeyPair(configDir, keys);
+  }
+  const loadedIdentity = loadIdentity(configDir);
+  const expectedAgentId = deriveAgentId(derivedPublicKey.toString("hex"));
+  const expectedPublicKeyHex = derivedPublicKey.toString("hex");
+  const identityMismatch = !loadedIdentity || loadedIdentity.public_key !== expectedPublicKeyHex || loadedIdentity.agent_id !== expectedAgentId;
+  if (identityMismatch) {
+    const repairedIdentity = buildIdentityFromPublicKey(
+      derivedPublicKey,
+      loadedIdentity?.owner ?? ownerHint ?? "agent",
+      loadedIdentity?.created_at
+    );
+    saveIdentity(configDir, repairedIdentity);
+    return { identity: repairedIdentity, keys, status: "repaired" };
+  }
+  if (ownerHint && loadedIdentity.owner !== ownerHint) {
+    const updatedIdentity = { ...loadedIdentity, owner: ownerHint };
+    saveIdentity(configDir, updatedIdentity);
+    return { identity: updatedIdentity, keys, status: "repaired" };
+  }
+  return { identity: loadedIdentity, keys, status: keypairRepaired ? "repaired" : "existing" };
+}
 function issueAgentCertificate(identity, privateKey) {
   const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
   const expiresAt = new Date(Date.now() + 365 * 24 * 60 * 60 * 1e3).toISOString();
@@ -3838,15 +4257,7 @@ function verifyAgentCertificate(cert) {
   return verifyEscrowReceipt(payload, cert.signature, publicKeyBuf);
 }
 function ensureIdentity(configDir, owner) {
-  const existing = loadIdentity(configDir);
-  if (existing) {
-    if (existing.owner !== owner) {
-      existing.owner = owner;
-      saveIdentity(configDir, existing);
-    }
-    return existing;
-  }
-  return createIdentity(configDir, owner);
+  return loadOrRepairIdentity(configDir, owner).identity;
 }
 
 // src/sdk/consumer.ts
@@ -3916,7 +4327,12 @@ var AgentBnBConsumer = class {
         cardId: opts.cardId,
         params: opts.params,
         timeoutMs: opts.timeoutMs,
-        escrowReceipt: receipt
+        escrowReceipt: receipt,
+        identity: {
+          agentId: identity.agent_id,
+          publicKey: identity.public_key,
+          privateKey: this.keys.privateKey
+        }
       });
       settleRequesterEscrow(db, escrowId);
       return result;
@@ -4092,7 +4508,7 @@ var AgentBnBProvider = class {
 
 // src/identity/guarantor.ts
 import { z as z5 } from "zod";
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 var MAX_AGENTS_PER_GUARANTOR = 10;
 var GUARANTOR_CREDIT_POOL = 50;
 var GuarantorRecordSchema = z5.object({
@@ -4131,7 +4547,7 @@ function registerGuarantor(db, githubLogin) {
     );
   }
   const record = {
-    id: randomUUID13(),
+    id: randomUUID14(),
     github_login: githubLogin,
     agent_count: 0,
     credit_pool: GUARANTOR_CREDIT_POOL,
@@ -4205,178 +4621,12 @@ function getAgentGuarantor(db, agentId) {
 function initiateGithubAuth() {
   return {
     auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
-    state: randomUUID13()
+    state: randomUUID14()
   };
 }
 
-// src/relay/types.ts
-import { z as z6 } from "zod";
-var RegisterMessageSchema = z6.object({
-  type: z6.literal("register"),
-  owner: z6.string().min(1),
-  /** V8: Cryptographic agent identity. When present, used as the canonical key. */
-  agent_id: z6.string().optional(),
-  /** V8 Phase 3: Server identifier for multi-agent delegation. */
-  server_id: z6.string().optional(),
-  token: z6.string().min(1),
-  card: z6.record(z6.unknown()),
-  // CapabilityCard (validated separately)
-  cards: z6.array(z6.record(z6.unknown())).optional(),
-  // Additional cards (e.g., conductor card)
-  /** V8 Phase 3: Additional agents served by this server (multi-agent registration). */
-  agents: z6.array(z6.object({
-    agent_id: z6.string().min(1),
-    display_name: z6.string().min(1),
-    cards: z6.array(z6.record(z6.unknown())),
-    delegation_token: z6.record(z6.unknown()).optional()
-  })).optional()
-});
-var RegisteredMessageSchema = z6.object({
-  type: z6.literal("registered"),
-  agent_id: z6.string()
-});
-var RelayRequestMessageSchema = z6.object({
-  type: z6.literal("relay_request"),
-  id: z6.string().uuid(),
-  target_owner: z6.string().min(1),
-  /** V8: Target agent's cryptographic identity. Preferred over target_owner. */
-  target_agent_id: z6.string().optional(),
-  card_id: z6.string(),
-  skill_id: z6.string().optional(),
-  params: z6.record(z6.unknown()).default({}),
-  requester: z6.string().optional(),
-  escrow_receipt: z6.record(z6.unknown()).optional()
-});
-var IncomingRequestMessageSchema = z6.object({
-  type: z6.literal("incoming_request"),
-  id: z6.string().uuid(),
-  from_owner: z6.string().min(1),
-  card_id: z6.string(),
-  skill_id: z6.string().optional(),
-  params: z6.record(z6.unknown()).default({}),
-  requester: z6.string().optional(),
-  escrow_receipt: z6.record(z6.unknown()).optional()
-});
-var RelayResponseMessageSchema = z6.object({
-  type: z6.literal("relay_response"),
-  id: z6.string().uuid(),
-  result: z6.unknown().optional(),
-  error: z6.object({
-    code: z6.number(),
-    message: z6.string()
-  }).optional()
-});
-var ResponseMessageSchema = z6.object({
-  type: z6.literal("response"),
-  id: z6.string().uuid(),
-  result: z6.unknown().optional(),
-  error: z6.object({
-    code: z6.number(),
-    message: z6.string()
-  }).optional()
-});
-var ErrorMessageSchema = z6.object({
-  type: z6.literal("error"),
-  code: z6.string(),
-  message: z6.string(),
-  request_id: z6.string().optional()
-});
-var RelayProgressMessageSchema = z6.object({
-  type: z6.literal("relay_progress"),
-  id: z6.string().uuid(),
-  // request ID this progress relates to
-  progress: z6.number().min(0).max(100).optional(),
-  // optional percentage
-  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 EscrowHoldMessageSchema = z6.object({
-  type: z6.literal("escrow_hold"),
-  consumer_agent_id: z6.string().min(1),
-  provider_agent_id: z6.string().min(1),
-  skill_id: z6.string().min(1),
-  amount: z6.number().positive(),
-  request_id: z6.string().uuid(),
-  signature: z6.string().optional(),
-  public_key: z6.string().optional()
-});
-var EscrowHoldConfirmedMessageSchema = z6.object({
-  type: z6.literal("escrow_hold_confirmed"),
-  request_id: z6.string(),
-  escrow_id: z6.string(),
-  hold_amount: z6.number(),
-  consumer_remaining: z6.number()
-});
-var EscrowSettleMessageSchema = z6.object({
-  type: z6.literal("escrow_settle"),
-  escrow_id: z6.string().min(1),
-  request_id: z6.string().uuid(),
-  success: z6.boolean(),
-  failure_reason: z6.enum(["bad_execution", "overload", "timeout", "auth_error", "not_found"]).optional(),
-  result_hash: z6.string().optional(),
-  signature: z6.string().optional(),
-  public_key: z6.string().optional(),
-  consumer_agent_id: z6.string().optional()
-});
-var EscrowSettledMessageSchema = z6.object({
-  type: z6.literal("escrow_settled"),
-  escrow_id: z6.string(),
-  request_id: z6.string(),
-  provider_earned: z6.number(),
-  network_fee: z6.number(),
-  consumer_remaining: z6.number(),
-  provider_balance: z6.number()
-});
-var BalanceSyncMessageSchema = z6.object({
-  type: z6.literal("balance_sync"),
-  agent_id: z6.string().min(1)
-});
-var BalanceSyncResponseMessageSchema = z6.object({
-  type: z6.literal("balance_sync_response"),
-  agent_id: z6.string(),
-  balance: z6.number()
-});
-var RelayMessageSchema = z6.discriminatedUnion("type", [
-  RegisterMessageSchema,
-  RegisteredMessageSchema,
-  RelayRequestMessageSchema,
-  IncomingRequestMessageSchema,
-  RelayResponseMessageSchema,
-  ResponseMessageSchema,
-  ErrorMessageSchema,
-  RelayProgressMessageSchema,
-  HeartbeatMessageSchema,
-  EscrowHoldMessageSchema,
-  EscrowHoldConfirmedMessageSchema,
-  EscrowSettleMessageSchema,
-  EscrowSettledMessageSchema,
-  BalanceSyncMessageSchema,
-  BalanceSyncResponseMessageSchema
-]);
-
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 
 // src/relay/relay-credit.ts
 function lookupCardPrice(registryDb, cardId, skillId) {
@@ -4506,10 +4756,10 @@ function settleWithNetworkFee(creditDb, escrowId, providerOwner) {
 }
 
 // src/hub-agent/relay-bridge.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 
 // src/hub-agent/job-queue.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 function updateJobStatus(db, jobId, status, result) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (result !== void 0) {
@@ -4638,7 +4888,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID16(),
+        id: randomUUID17(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -5120,312 +5370,6 @@ function registerWebSocketRelay(server, db, creditDb) {
   };
 }
 
-// src/relay/websocket-client.ts
-import WebSocket from "ws";
-import { randomUUID as randomUUID17 } from "crypto";
-var RelayClient = class {
-  ws = null;
-  opts;
-  pendingRequests = /* @__PURE__ */ new Map();
-  reconnectAttempts = 0;
-  reconnectTimer = null;
-  intentionalClose = false;
-  registered = false;
-  pongTimeout = null;
-  pingInterval = null;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /**
-   * Connect to the registry relay and register.
-   * Resolves when registration is acknowledged.
-   */
-  async connect() {
-    return new Promise((resolve, reject) => {
-      this.intentionalClose = false;
-      this.registered = false;
-      const wsUrl = this.buildWsUrl();
-      this.ws = new WebSocket(wsUrl);
-      let resolved = false;
-      this.ws.on("open", () => {
-        this.reconnectAttempts = 0;
-        this.startPingInterval();
-        this.send({
-          type: "register",
-          owner: this.opts.owner,
-          ...this.opts.agent_id ? { agent_id: this.opts.agent_id } : {},
-          ...this.opts.server_id ? { server_id: this.opts.server_id } : {},
-          token: this.opts.token,
-          card: this.opts.card,
-          ...this.opts.cards && this.opts.cards.length > 0 ? { cards: this.opts.cards } : {},
-          ...this.opts.agents && this.opts.agents.length > 0 ? { agents: this.opts.agents } : {}
-        });
-      });
-      this.ws.on("message", (raw) => {
-        this.handleMessage(raw, (err) => {
-          if (!resolved) {
-            resolved = true;
-            if (err) reject(err);
-            else resolve();
-          }
-        });
-      });
-      this.ws.on("close", () => {
-        this.cleanup();
-        if (!this.intentionalClose) {
-          if (!resolved) {
-            resolved = true;
-            reject(new Error("WebSocket closed before registration"));
-          }
-          this.scheduleReconnect();
-        }
-      });
-      this.ws.on("error", (err) => {
-        if (!resolved) {
-          resolved = true;
-          reject(err);
-        }
-      });
-      setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          reject(new Error("Connection timeout"));
-          this.ws?.close();
-        }
-      }, 1e4);
-    });
-  }
-  /**
-   * Disconnect from the registry relay.
-   */
-  disconnect() {
-    this.intentionalClose = true;
-    this.cleanup();
-    if (this.ws) {
-      try {
-        this.ws.close(1e3, "Client disconnect");
-      } catch {
-      }
-      this.ws = null;
-    }
-    for (const [id, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeout);
-      pending.reject(new Error("Client disconnected"));
-      this.pendingRequests.delete(id);
-    }
-  }
-  /**
-   * Send a relay request to another agent via the registry.
-   * @returns The result from the target agent.
-   */
-  async request(opts) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registered) {
-      throw new Error("Not connected to registry relay");
-    }
-    const id = randomUUID17();
-    const timeoutMs = opts.timeoutMs ?? 3e5;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error("Relay request timeout"));
-      }, timeoutMs);
-      this.pendingRequests.set(id, { resolve, reject, timeout, timeoutMs, onProgress: opts.onProgress });
-      this.send({
-        type: "relay_request",
-        id,
-        target_owner: opts.targetOwner,
-        ...opts.targetAgentId ? { target_agent_id: opts.targetAgentId } : {},
-        card_id: opts.cardId,
-        skill_id: opts.skillId,
-        params: opts.params,
-        requester: opts.requester ?? this.opts.owner,
-        escrow_receipt: opts.escrowReceipt
-      });
-    });
-  }
-  /**
-   * Send a relay_progress message to the relay server for a given request.
-   * Used by the onRequest handler to forward SkillExecutor progress updates
-   * to the requesting agent so it can reset its timeout window.
-   *
-   * @param requestId - The relay request ID to associate progress with.
-   * @param info - Progress details (step, total, message).
-   */
-  sendProgress(requestId, info) {
-    this.send({
-      type: "relay_progress",
-      id: requestId,
-      progress: Math.round(info.step / info.total * 100),
-      message: info.message
-    });
-  }
-  /** Whether the client is connected and registered */
-  get isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN && this.registered;
-  }
-  // ── Private methods ─────────────────────────────────────────────────────────
-  buildWsUrl() {
-    let url = this.opts.registryUrl;
-    if (url.startsWith("http://")) {
-      url = "ws://" + url.slice(7);
-    } else if (url.startsWith("https://")) {
-      url = "wss://" + url.slice(8);
-    } else if (!url.startsWith("ws://") && !url.startsWith("wss://")) {
-      url = "wss://" + url;
-    }
-    if (!url.endsWith("/ws")) {
-      url = url.replace(/\/$/, "") + "/ws";
-    }
-    return url;
-  }
-  handleMessage(raw, onRegistered) {
-    let data;
-    try {
-      data = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf-8"));
-    } catch {
-      return;
-    }
-    const parsed = RelayMessageSchema.safeParse(data);
-    if (!parsed.success) return;
-    const msg = parsed.data;
-    switch (msg.type) {
-      case "registered":
-        this.registered = true;
-        if (!this.opts.silent) {
-          console.log(`  \u2713 Registered with registry (agent_id: ${msg.agent_id})`);
-        }
-        onRegistered?.();
-        break;
-      case "incoming_request":
-        this.handleIncomingRequest(msg);
-        break;
-      case "response":
-        this.handleResponse(msg);
-        break;
-      case "error":
-        this.handleError(msg);
-        break;
-      case "relay_progress":
-        this.handleProgress(msg);
-        break;
-      default:
-        break;
-    }
-  }
-  async handleIncomingRequest(msg) {
-    try {
-      const result = await this.opts.onRequest(msg);
-      this.send({
-        type: "relay_response",
-        id: msg.id,
-        result: result.result,
-        error: result.error
-      });
-    } catch (err) {
-      this.send({
-        type: "relay_response",
-        id: msg.id,
-        error: {
-          code: -32603,
-          message: err instanceof Error ? err.message : "Internal error"
-        }
-      });
-    }
-  }
-  handleResponse(msg) {
-    const pending = this.pendingRequests.get(msg.id);
-    if (!pending) return;
-    clearTimeout(pending.timeout);
-    this.pendingRequests.delete(msg.id);
-    if (msg.error) {
-      pending.reject(new Error(msg.error.message));
-    } else {
-      pending.resolve(msg.result);
-    }
-  }
-  handleError(msg) {
-    if (msg.request_id) {
-      const pending = this.pendingRequests.get(msg.request_id);
-      if (pending) {
-        clearTimeout(pending.timeout);
-        this.pendingRequests.delete(msg.request_id);
-        pending.reject(new Error(`${msg.code}: ${msg.message}`));
-      }
-    }
-  }
-  handleProgress(msg) {
-    const pending = this.pendingRequests.get(msg.id);
-    if (!pending) return;
-    clearTimeout(pending.timeout);
-    const newTimeout = setTimeout(() => {
-      this.pendingRequests.delete(msg.id);
-      pending.reject(new Error("Relay request timeout"));
-    }, pending.timeoutMs);
-    pending.timeout = newTimeout;
-    if (pending.onProgress) {
-      pending.onProgress({ id: msg.id, progress: msg.progress, message: msg.message });
-    }
-  }
-  send(msg) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-  startPingInterval() {
-    this.stopPingInterval();
-    this.pingInterval = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-        this.ws.ping();
-        this.pongTimeout = setTimeout(() => {
-          if (!this.opts.silent) {
-            console.log("  \u26A0 Registry pong timeout, reconnecting...");
-          }
-          this.ws?.terminate();
-        }, 15e3);
-      }
-    }, 3e4);
-    this.ws?.on("pong", () => {
-      if (this.pongTimeout) {
-        clearTimeout(this.pongTimeout);
-        this.pongTimeout = null;
-      }
-    });
-  }
-  stopPingInterval() {
-    if (this.pingInterval) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
-    }
-    if (this.pongTimeout) {
-      clearTimeout(this.pongTimeout);
-      this.pongTimeout = null;
-    }
-  }
-  cleanup() {
-    this.stopPingInterval();
-    this.registered = false;
-  }
-  scheduleReconnect() {
-    if (this.intentionalClose) return;
-    if (this.reconnectTimer) return;
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-    this.reconnectAttempts++;
-    if (!this.opts.silent) {
-      console.log(`  \u21BB Reconnecting to registry in ${delay / 1e3}s...`);
-    }
-    this.reconnectTimer = setTimeout(async () => {
-      this.reconnectTimer = null;
-      try {
-        await this.connect();
-        if (!this.opts.silent) {
-          console.log("  \u2713 Reconnected to registry");
-        }
-      } catch {
-      }
-    }, delay);
-  }
-};
-
 // src/onboarding/index.ts
 import { randomUUID as randomUUID19 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";