agentbnb 3.0.0 → 3.1.0

package/dist/{chunk-PJSYSVKN.js → chunk-2LLXUKMY.js}

@@ -3,9 +3,6 @@ import {
   CapabilityCardSchema
 } from "./chunk-TQMI73LL.js";
 
-// src/registry/store.ts
-import Database from "better-sqlite3";
-
 // src/registry/request-log.ts
 var SINCE_MS = {
   "24h": 864e5,
@@ -77,7 +74,7 @@ function getActivityFeed(db, limit = 20, since) {
              r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
       FROM request_log r
       LEFT JOIN capability_cards c ON r.card_id = c.id
-      WHERE (r.action_type IS NULL OR r.action_type = 'auto_share')
+      WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
         AND r.created_at > ?
       ORDER BY r.created_at DESC
       LIMIT ?
@@ -89,7 +86,7 @@ function getActivityFeed(db, limit = 20, since) {
            r.status, r.credits_charged, r.latency_ms, r.created_at, r.action_type
     FROM request_log r
     LEFT JOIN capability_cards c ON r.card_id = c.id
-    WHERE (r.action_type IS NULL OR r.action_type = 'auto_share')
+    WHERE (r.action_type IS NULL OR r.action_type IN ('auto_share', 'agent_joined'))
     ORDER BY r.created_at DESC
     LIMIT ?
   `);
@@ -117,6 +114,7 @@ function getRequestLog(db, limit = 10, since) {
 }
 
 // src/registry/store.ts
+import Database from "better-sqlite3";
 var V2_FTS_TRIGGERS = `
   DROP TRIGGER IF EXISTS cards_ai;
   DROP TRIGGER IF EXISTS cards_au;

package/dist/chunk-3Y36WQDV.js

@@ -0,0 +1,70 @@
+// src/relay/types.ts
+import { z } from "zod";
+var RegisterMessageSchema = z.object({
+  type: z.literal("register"),
+  owner: z.string().min(1),
+  token: z.string().min(1),
+  card: z.record(z.unknown())
+  // CapabilityCard (validated separately)
+});
+var RegisteredMessageSchema = z.object({
+  type: z.literal("registered"),
+  agent_id: z.string()
+});
+var RelayRequestMessageSchema = z.object({
+  type: z.literal("relay_request"),
+  id: z.string().uuid(),
+  target_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var IncomingRequestMessageSchema = z.object({
+  type: z.literal("incoming_request"),
+  id: z.string().uuid(),
+  from_owner: z.string().min(1),
+  card_id: z.string(),
+  skill_id: z.string().optional(),
+  params: z.record(z.unknown()).default({}),
+  requester: z.string().optional(),
+  escrow_receipt: z.record(z.unknown()).optional()
+});
+var RelayResponseMessageSchema = z.object({
+  type: z.literal("relay_response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ResponseMessageSchema = z.object({
+  type: z.literal("response"),
+  id: z.string().uuid(),
+  result: z.unknown().optional(),
+  error: z.object({
+    code: z.number(),
+    message: z.string()
+  }).optional()
+});
+var ErrorMessageSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  request_id: z.string().optional()
+});
+var RelayMessageSchema = z.discriminatedUnion("type", [
+  RegisterMessageSchema,
+  RegisteredMessageSchema,
+  RelayRequestMessageSchema,
+  IncomingRequestMessageSchema,
+  RelayResponseMessageSchema,
+  ResponseMessageSchema,
+  ErrorMessageSchema
+]);
+
+export {
+  RelayMessageSchema
+};

package/dist/chunk-4Q7D24DP.js

@@ -0,0 +1,257 @@
+import {
+  getCard,
+  insertRequestLog,
+  updateReputation
+} from "./chunk-2LLXUKMY.js";
+import {
+  confirmEscrowDebit,
+  getBalance,
+  holdEscrow,
+  recordEarning,
+  releaseEscrow,
+  settleEscrow
+} from "./chunk-ZJCIBK6O.js";
+import {
+  AgentBnBError
+} from "./chunk-TQMI73LL.js";
+
+// src/gateway/execute.ts
+import { randomUUID } from "crypto";
+
+// src/credit/signing.ts
+import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
+import { writeFileSync, readFileSync, existsSync, chmodSync } from "fs";
+import { join } from "path";
+function generateKeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "der" },
+    privateKeyEncoding: { type: "pkcs8", format: "der" }
+  });
+  return {
+    publicKey: Buffer.from(publicKey),
+    privateKey: Buffer.from(privateKey)
+  };
+}
+function saveKeyPair(configDir, keys) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  writeFileSync(privatePath, keys.privateKey);
+  chmodSync(privatePath, 384);
+  writeFileSync(publicPath, keys.publicKey);
+}
+function loadKeyPair(configDir) {
+  const privatePath = join(configDir, "private.key");
+  const publicPath = join(configDir, "public.key");
+  if (!existsSync(privatePath) || !existsSync(publicPath)) {
+    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+  }
+  return {
+    publicKey: readFileSync(publicPath),
+    privateKey: readFileSync(privatePath)
+  };
+}
+function canonicalJson(data) {
+  return JSON.stringify(data, Object.keys(data).sort());
+}
+function signEscrowReceipt(data, privateKey) {
+  const message = Buffer.from(canonicalJson(data), "utf-8");
+  const keyObject = createPrivateKey({ key: privateKey, format: "der", type: "pkcs8" });
+  const signature = sign(null, message, keyObject);
+  return signature.toString("base64url");
+}
+function verifyEscrowReceipt(data, signature, publicKey) {
+  try {
+    const message = Buffer.from(canonicalJson(data), "utf-8");
+    const keyObject = createPublicKey({ key: publicKey, format: "der", type: "spki" });
+    const sigBuffer = Buffer.from(signature, "base64url");
+    return verify(null, message, keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+
+// src/credit/settlement.ts
+function settleProviderEarning(providerDb, providerOwner, receipt) {
+  recordEarning(
+    providerDb,
+    providerOwner,
+    receipt.amount,
+    receipt.card_id,
+    receipt.nonce
+  );
+  return { settled: true };
+}
+function settleRequesterEscrow(requesterDb, escrowId) {
+  confirmEscrowDebit(requesterDb, escrowId);
+}
+function releaseRequesterEscrow(requesterDb, escrowId) {
+  releaseEscrow(requesterDb, escrowId);
+}
+
+// src/gateway/execute.ts
+async function executeCapabilityRequest(opts) {
+  const {
+    registryDb,
+    creditDb,
+    cardId,
+    skillId,
+    params,
+    requester,
+    escrowReceipt: receipt,
+    skillExecutor,
+    handlerUrl,
+    timeoutMs = 3e4
+  } = opts;
+  const card = getCard(registryDb, cardId);
+  if (!card) {
+    return { success: false, error: { code: -32602, message: `Card not found: ${cardId}` } };
+  }
+  let creditsNeeded;
+  let cardName;
+  let resolvedSkillId;
+  const rawCard = card;
+  if (Array.isArray(rawCard["skills"])) {
+    const v2card = card;
+    const skill = skillId ? v2card.skills.find((s) => s.id === skillId) : v2card.skills[0];
+    if (!skill) {
+      return { success: false, error: { code: -32602, message: `Skill not found: ${skillId}` } };
+    }
+    creditsNeeded = skill.pricing.credits_per_call;
+    cardName = skill.name;
+    resolvedSkillId = skill.id;
+  } else {
+    creditsNeeded = card.pricing.credits_per_call;
+    cardName = card.name;
+  }
+  let escrowId = null;
+  let isRemoteEscrow = false;
+  if (receipt) {
+    const { signature, ...receiptData2 } = receipt;
+    const publicKeyBuf = Buffer.from(receipt.requester_public_key, "hex");
+    const valid = verifyEscrowReceipt(receiptData2, signature, publicKeyBuf);
+    if (!valid) {
+      return { success: false, error: { code: -32603, message: "Invalid escrow receipt signature" } };
+    }
+    if (receipt.amount < creditsNeeded) {
+      return { success: false, error: { code: -32603, message: "Insufficient escrow amount" } };
+    }
+    const receiptAge = Date.now() - new Date(receipt.timestamp).getTime();
+    if (receiptAge > 5 * 60 * 1e3) {
+      return { success: false, error: { code: -32603, message: "Escrow receipt expired" } };
+    }
+    isRemoteEscrow = true;
+  } else {
+    try {
+      const balance = getBalance(creditDb, requester);
+      if (balance < creditsNeeded) {
+        return { success: false, error: { code: -32603, message: "Insufficient credits" } };
+      }
+      escrowId = holdEscrow(creditDb, requester, creditsNeeded, cardId);
+    } catch (err) {
+      const msg = err instanceof AgentBnBError ? err.message : "Failed to hold escrow";
+      return { success: false, error: { code: -32603, message: msg } };
+    }
+  }
+  const startMs = Date.now();
+  const receiptData = isRemoteEscrow ? { receipt_released: true } : void 0;
+  const handleFailure = (status, latencyMs, message) => {
+    if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
+    updateReputation(registryDb, cardId, false, latencyMs);
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: cardId,
+        card_name: cardName,
+        skill_id: resolvedSkillId,
+        requester,
+        status,
+        latency_ms: latencyMs,
+        credits_charged: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+    return {
+      success: false,
+      error: { code: -32603, message, ...receiptData ? { data: receiptData } : {} }
+    };
+  };
+  const handleSuccess = (result, latencyMs) => {
+    if (isRemoteEscrow && receipt) {
+      settleProviderEarning(creditDb, card.owner, receipt);
+    } else if (escrowId) {
+      settleEscrow(creditDb, escrowId, card.owner);
+    }
+    updateReputation(registryDb, cardId, true, latencyMs);
+    try {
+      insertRequestLog(registryDb, {
+        id: randomUUID(),
+        card_id: cardId,
+        card_name: cardName,
+        skill_id: resolvedSkillId,
+        requester,
+        status: "success",
+        latency_ms: latencyMs,
+        credits_charged: creditsNeeded,
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+    }
+    const successResult = isRemoteEscrow ? {
+      ...typeof result === "object" && result !== null ? result : { data: result },
+      receipt_settled: true,
+      receipt_nonce: receipt.nonce
+    } : result;
+    return { success: true, result: successResult };
+  };
+  if (skillExecutor) {
+    const targetSkillId = resolvedSkillId ?? skillId ?? cardId;
+    try {
+      const execResult = await skillExecutor.execute(targetSkillId, params);
+      if (!execResult.success) {
+        return handleFailure("failure", execResult.latency_ms, execResult.error ?? "Execution failed");
+      }
+      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);
+    }
+  }
+  if (!handlerUrl) {
+    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(handlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ card_id: cardId, skill_id: resolvedSkillId, params }),
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!response.ok) {
+      return handleFailure("failure", Date.now() - startMs, `Handler returned ${response.status}`);
+    }
+    const result = await response.json();
+    return handleSuccess(result, Date.now() - startMs);
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    return handleFailure(
+      isTimeout ? "timeout" : "failure",
+      Date.now() - startMs,
+      isTimeout ? "Execution timeout" : "Handler error"
+    );
+  }
+}
+
+export {
+  generateKeyPair,
+  saveKeyPair,
+  loadKeyPair,
+  signEscrowReceipt,
+  settleRequesterEscrow,
+  releaseRequesterEscrow,
+  executeCapabilityRequest
+};

package/dist/{chunk-V7M6GIJZ.js → chunk-QVIGMCHA.js}

@@ -1,90 +1,18 @@
 import {
   findPeer
 } from "./chunk-BEI5MTNZ.js";
+import {
+  getBalance,
+  holdEscrow,
+  releaseEscrow,
+  settleEscrow
+} from "./chunk-ZJCIBK6O.js";
 import {
   AgentBnBError
 } from "./chunk-TQMI73LL.js";
 
-// src/credit/ledger.ts
-import Database from "better-sqlite3";
-import { randomUUID } from "crypto";
-var CREDIT_SCHEMA = `
-  CREATE TABLE IF NOT EXISTS credit_balances (
-    owner TEXT PRIMARY KEY,
-    balance INTEGER NOT NULL DEFAULT 0,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS credit_transactions (
-    id TEXT PRIMARY KEY,
-    owner TEXT NOT NULL,
-    amount INTEGER NOT NULL,
-    reason TEXT NOT NULL,
-    reference_id TEXT,
-    created_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS credit_escrow (
-    id TEXT PRIMARY KEY,
-    owner TEXT NOT NULL,
-    amount INTEGER NOT NULL,
-    card_id TEXT NOT NULL,
-    status TEXT NOT NULL DEFAULT 'held',
-    created_at TEXT NOT NULL,
-    settled_at TEXT
-  );
-
-  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);
-`;
-function openCreditDb(path = ":memory:") {
-  const db = new Database(path);
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  db.exec(CREDIT_SCHEMA);
-  return db;
-}
-function bootstrapAgent(db, owner, amount = 100) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.transaction(() => {
-    const result = db.prepare("INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, ?, ?)").run(owner, amount, now);
-    if (result.changes > 0) {
-      db.prepare(
-        "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-      ).run(randomUUID(), owner, amount, "bootstrap", null, now);
-    }
-  })();
-}
-function getBalance(db, owner) {
-  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
-  return row?.balance ?? 0;
-}
-function getTransactions(db, owner, limit = 100) {
-  return db.prepare(
-    "SELECT id, owner, amount, reason, reference_id, created_at FROM credit_transactions WHERE owner = ? ORDER BY created_at DESC LIMIT ?"
-  ).all(owner, limit);
-}
-function recordEarning(db, owner, amount, _cardId, receiptNonce) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  db.transaction(() => {
-    const existing = db.prepare(
-      "SELECT id FROM credit_transactions WHERE reference_id = ? AND reason = 'remote_earning'"
-    ).get(receiptNonce);
-    if (existing) return;
-    db.prepare(
-      "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
-    ).run(owner, now);
-    db.prepare(
-      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-    ).run(amount, now, owner);
-    db.prepare(
-      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID(), owner, amount, "remote_earning", receiptNonce, now);
-  })();
-}
-
 // src/autonomy/tiers.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 var DEFAULT_AUTONOMY_CONFIG = {
   tier1_max_credits: 0,
   tier2_max_credits: 0
@@ -105,7 +33,7 @@ function insertAuditEvent(db, event) {
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   stmt.run(
-    randomUUID2(),
+    randomUUID(),
     cardId,
     "autonomy-audit",
     "self",
@@ -220,10 +148,10 @@ function filterCards(db, filters) {
 }
 
 // src/gateway/client.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 async function requestCapability(opts) {
   const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e4, escrowReceipt } = opts;
-  const id = randomUUID3();
+  const id = randomUUID2();
   const payload = {
     jsonrpc: "2.0",
     id,
@@ -264,109 +192,10 @@ async function requestCapability(opts) {
   return body.result;
 }
 
-// src/credit/escrow.ts
-import { randomUUID as randomUUID4 } from "crypto";
-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");
-    }
-    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;
-}
-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);
-    if (!escrow) {
-      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
-    }
-    if (escrow.status !== "held") {
-      throw new AgentBnBError(
-        `Escrow ${escrowId} is already ${escrow.status}`,
-        "ESCROW_ALREADY_SETTLED"
-      );
-    }
-    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);
-    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);
-  });
-  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);
-    if (!escrow) {
-      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
-    }
-    if (escrow.status !== "held") {
-      throw new AgentBnBError(
-        `Escrow ${escrowId} is already ${escrow.status}`,
-        "ESCROW_ALREADY_SETTLED"
-      );
-    }
-    db.prepare(
-      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-    ).run(escrow.amount, now, escrow.owner);
-    db.prepare(
-      "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
-    ).run("released", now, escrowId);
-    db.prepare(
-      "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID4(), escrow.owner, escrow.amount, "refund", escrowId, now);
-  });
-  release();
-}
-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);
-    if (!escrow) {
-      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
-    }
-    if (escrow.status !== "held") {
-      throw new AgentBnBError(
-        `Escrow ${escrowId} is already ${escrow.status}`,
-        "ESCROW_ALREADY_SETTLED"
-      );
-    }
-    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(), escrow.owner, 0, "remote_settlement_confirmed", escrowId, now);
-  });
-  confirm();
-}
-
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 function createPendingRequest(db, opts) {
-  const id = randomUUID5();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
   db.prepare(`
@@ -641,15 +470,6 @@ function interpolateValue(value, context) {
 }
 
 export {
-  holdEscrow,
-  settleEscrow,
-  releaseEscrow,
-  confirmEscrowDebit,
-  openCreditDb,
-  bootstrapAgent,
-  getBalance,
-  getTransactions,
-  recordEarning,
   DEFAULT_AUTONOMY_CONFIG,
   getAutonomyTier,
   insertAuditEvent,

package/dist/{chunk-EZB4RUIG.js → chunk-T7ZJPQHD.js}

@@ -3,7 +3,7 @@ import {
   requestCapability,
   scorePeers,
   searchCards
-} from "./chunk-V7M6GIJZ.js";
+} from "./chunk-QVIGMCHA.js";
 
 // src/conductor/task-decomposer.ts
 import { randomUUID } from "crypto";