agentbnb 8.0.1 → 8.2.0

package/dist/{conductor-mode-2GSLHVN6.js → chunk-P4LOYSLA.js}

@@ -1,21 +1,17 @@
 import {
-  fetchRemoteCards,
-  interpolateObject,
-  requestCapability,
-  searchCards
-} from "./chunk-B2VJTKO5.js";
-import "./chunk-HLUEOLSZ.js";
+  findPeer
+} from "./chunk-HLUEOLSZ.js";
 import {
   getBalance,
-  getCardsByCapabilityType,
-  getCardsBySkillCapability
+  getFeedbackForProvider,
+  holdEscrow,
+  releaseEscrow,
+  settleEscrow,
+  signEscrowReceipt
 } from "./chunk-7EF3HYVZ.js";
-import "./chunk-NWIQJ2CL.js";
-import "./chunk-IVOYM3WG.js";
-import "./chunk-WVY2W7AA.js";
-
-// src/conductor/task-decomposer.ts
-import { randomUUID } from "crypto";
+import {
+  AgentBnBError
+} from "./chunk-WVY2W7AA.js";
 
 // src/conductor/decomposition-validator.ts
 function validateAndNormalizeSubtasks(raw, context) {
@@ -152,6 +148,7 @@ function _validate(raw, context) {
 }
 
 // src/conductor/task-decomposer.ts
+import { randomUUID } from "crypto";
 var TEMPLATES = {
   "video-production": {
     keywords: ["video", "demo", "clip", "animation"],
@@ -259,6 +256,367 @@ function decompose(task, _availableCapabilities) {
   return [];
 }
 
+// src/gateway/client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+async function requestCapability(opts) {
+  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
+  const id = randomUUID2();
+  const payload = {
+    jsonrpc: "2.0",
+    id,
+    method: "capability.execute",
+    params: {
+      card_id: cardId,
+      ...params,
+      ...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 controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(`${gatewayUrl}/rpc`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    throw new AgentBnBError(
+      isTimeout ? "Request timed out" : `Network error: ${String(err)}`,
+      isTimeout ? "TIMEOUT" : "NETWORK_ERROR"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const body = await response.json();
+  if (body.error) {
+    throw new AgentBnBError(body.error.message, `RPC_ERROR_${body.error.code}`);
+  }
+  return body.result;
+}
+async function requestViaRelay(relay, opts) {
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      requester: opts.requester,
+      escrowReceipt: opts.escrowReceipt,
+      timeoutMs: opts.timeoutMs
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("timeout")) {
+      throw new AgentBnBError(message, "TIMEOUT");
+    }
+    if (message.includes("offline")) {
+      throw new AgentBnBError(message, "AGENT_OFFLINE");
+    }
+    throw new AgentBnBError(message, "RELAY_ERROR");
+  }
+}
+
+// src/feedback/reputation.ts
+var QUALITY_SCORES = {
+  excellent: 1,
+  good: 0.8,
+  acceptable: 0.6,
+  poor: 0.3,
+  failed: 0
+};
+var COST_VALUE_SCORES = {
+  great: 1,
+  fair: 0.6,
+  overpriced: 0.2
+};
+var DECAY_DAYS = 30;
+var WEIGHTS = {
+  rating: 0.4,
+  quality: 0.3,
+  would_reuse: 0.2,
+  cost_value: 0.1
+};
+function computeReputation(feedbacks) {
+  if (feedbacks.length === 0) return 0.5;
+  const now = Date.now();
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (const fb of feedbacks) {
+    const feedbackDate = new Date(fb.timestamp).getTime();
+    const ageDays = Math.max(0, (now - feedbackDate) / (1e3 * 60 * 60 * 24));
+    const recencyWeight = Math.exp(-ageDays / DECAY_DAYS);
+    const ratingScore = (fb.rating - 1) / 4;
+    const qualityScore = QUALITY_SCORES[fb.result_quality];
+    const reuseScore = fb.would_reuse ? 1 : 0;
+    const costScore = COST_VALUE_SCORES[fb.cost_value_ratio];
+    const componentScore = WEIGHTS.rating * ratingScore + WEIGHTS.quality * qualityScore + WEIGHTS.would_reuse * reuseScore + WEIGHTS.cost_value * costScore;
+    weightedSum += recencyWeight * componentScore;
+    totalWeight += recencyWeight;
+  }
+  if (totalWeight === 0) return 0.5;
+  const raw = weightedSum / totalWeight;
+  return Math.max(0, Math.min(1, raw));
+}
+function getReputationScore(db, agentId) {
+  const feedbacks = getFeedbackForProvider(db, agentId);
+  return computeReputation(feedbacks);
+}
+
+// src/registry/matcher.ts
+function searchCards(db, query, filters = {}) {
+  const words = query.trim().split(/\s+/).map((w) => w.replace(/["*^{}():]/g, "")).filter((w) => w.length > 0);
+  if (words.length === 0) return [];
+  const ftsQuery = words.map((w) => `"${w}"`).join(" OR ");
+  const conditions = [];
+  const params = [ftsQuery];
+  if (filters.level !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.level') = ?`);
+    params.push(filters.level);
+  }
+  if (filters.online !== void 0) {
+    conditions.push(`json_extract(cc.data, '$.availability.online') = ?`);
+    params.push(filters.online ? 1 : 0);
+  }
+  const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : "";
+  const sql = `
+    SELECT cc.data
+    FROM capability_cards cc
+    JOIN cards_fts ON cc.rowid = cards_fts.rowid
+    WHERE cards_fts MATCH ?
+      ${whereClause}
+    ORDER BY bm25(cards_fts)
+    LIMIT 50
+  `;
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params);
+  const results = rows.map((row) => JSON.parse(row.data));
+  let filtered = results;
+  if (filters.apis_used && filters.apis_used.length > 0) {
+    const requiredApis = filters.apis_used;
+    filtered = filtered.filter((card) => {
+      const cardApis = card.metadata?.apis_used ?? [];
+      return requiredApis.every((api) => cardApis.includes(api));
+    });
+  }
+  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
+    filtered = applyReputationFilter(db, filtered, filters.min_reputation);
+  }
+  return filtered;
+}
+function filterCards(db, filters) {
+  const conditions = [];
+  const params = [];
+  if (filters.level !== void 0) {
+    conditions.push(`json_extract(data, '$.level') = ?`);
+    params.push(filters.level);
+  }
+  if (filters.online !== void 0) {
+    conditions.push(`json_extract(data, '$.availability.online') = ?`);
+    params.push(filters.online ? 1 : 0);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const sql = `SELECT data FROM capability_cards ${whereClause}`;
+  const stmt = db.prepare(sql);
+  const rows = stmt.all(...params);
+  let cards = rows.map((row) => JSON.parse(row.data));
+  if (filters.min_reputation !== void 0 && filters.min_reputation > 0) {
+    cards = applyReputationFilter(db, cards, filters.min_reputation);
+  }
+  return cards;
+}
+function applyReputationFilter(db, cards, minReputation) {
+  const owners = [...new Set(cards.map((c) => c.owner))];
+  const reputationMap = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    reputationMap.set(owner, getReputationScore(db, owner));
+  }
+  return cards.filter((card) => {
+    const score = reputationMap.get(card.owner) ?? 0.5;
+    return score >= minReputation;
+  });
+}
+function buildReputationMap(db, owners) {
+  const unique = [...new Set(owners)];
+  const map = /* @__PURE__ */ new Map();
+  for (const owner of unique) {
+    map.set(owner, getReputationScore(db, owner));
+  }
+  return map;
+}
+
+// src/autonomy/tiers.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var DEFAULT_AUTONOMY_CONFIG = {
+  tier1_max_credits: 0,
+  tier2_max_credits: 0
+};
+function getAutonomyTier(creditAmount, config) {
+  if (creditAmount < config.tier1_max_credits) return 1;
+  if (creditAmount < config.tier2_max_credits) return 2;
+  return 3;
+}
+function insertAuditEvent(db, event) {
+  const isShareEvent = event.type === "auto_share" || event.type === "auto_share_notify" || event.type === "auto_share_pending";
+  const cardId = isShareEvent ? "system" : event.card_id;
+  const creditsCharged = isShareEvent ? 0 : event.credits;
+  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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    randomUUID3(),
+    cardId,
+    "autonomy-audit",
+    "self",
+    "success",
+    0,
+    creditsCharged,
+    (/* @__PURE__ */ new Date()).toISOString(),
+    event.skill_id,
+    event.type,
+    event.tier_invoked
+  );
+}
+
+// src/autonomy/pending-requests.ts
+import { randomUUID as randomUUID4 } from "crypto";
+function createPendingRequest(db, opts) {
+  const id = randomUUID4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const paramsJson = opts.params !== void 0 ? JSON.stringify(opts.params) : null;
+  db.prepare(`
+    INSERT INTO pending_requests (
+      id, skill_query, max_cost_credits, selected_peer, selected_card_id,
+      selected_skill_id, credits, status, params, created_at, resolved_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, NULL)
+  `).run(
+    id,
+    opts.skill_query,
+    opts.max_cost_credits,
+    opts.selected_peer ?? null,
+    opts.selected_card_id ?? null,
+    opts.selected_skill_id ?? null,
+    opts.credits,
+    paramsJson,
+    now
+  );
+  return id;
+}
+function listPendingRequests(db) {
+  const rows = db.prepare(`SELECT * FROM pending_requests WHERE status = 'pending' ORDER BY created_at DESC`).all();
+  return rows;
+}
+function resolvePendingRequest(db, id, resolution) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const result = db.prepare(
+    `UPDATE pending_requests SET status = ?, resolved_at = ? WHERE id = ?`
+  ).run(resolution, now, id);
+  if (result.changes === 0) {
+    throw new AgentBnBError(
+      `Pending request not found: ${id}`,
+      "NOT_FOUND"
+    );
+  }
+}
+
+// src/cli/remote-registry.ts
+var RegistryTimeoutError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Registry at ${url} did not respond within 5s. Showing local results only.`,
+      "REGISTRY_TIMEOUT"
+    );
+    this.name = "RegistryTimeoutError";
+  }
+};
+var RegistryConnectionError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Cannot reach ${url}. Is the registry running? Showing local results only.`,
+      "REGISTRY_CONNECTION"
+    );
+    this.name = "RegistryConnectionError";
+  }
+};
+var RegistryAuthError = class extends AgentBnBError {
+  constructor(url) {
+    super(
+      `Authentication failed for ${url}. Run \`agentbnb config set token <your-token>\`.`,
+      "REGISTRY_AUTH"
+    );
+    this.name = "RegistryAuthError";
+  }
+};
+async function fetchRemoteCards(registryUrl, params, timeoutMs = 5e3) {
+  let cardsUrl;
+  try {
+    cardsUrl = new URL("/cards", registryUrl);
+  } catch {
+    throw new AgentBnBError(`Invalid registry URL: ${registryUrl}`, "INVALID_REGISTRY_URL");
+  }
+  const searchParams = new URLSearchParams();
+  if (params.q !== void 0) searchParams.set("q", params.q);
+  if (params.level !== void 0) searchParams.set("level", String(params.level));
+  if (params.online !== void 0) searchParams.set("online", String(params.online));
+  if (params.tag !== void 0) searchParams.set("tag", params.tag);
+  searchParams.set("limit", "100");
+  cardsUrl.search = searchParams.toString();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(cardsUrl.toString(), { signal: controller.signal });
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err instanceof Error && err.name === "AbortError";
+    if (isTimeout) {
+      throw new RegistryTimeoutError(registryUrl);
+    }
+    throw new RegistryConnectionError(registryUrl);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (response.status === 401 || response.status === 403) {
+    throw new RegistryAuthError(registryUrl);
+  }
+  if (!response.ok) {
+    throw new RegistryConnectionError(registryUrl);
+  }
+  const body = await response.json();
+  return body.items;
+}
+function mergeResults(localCards, remoteCards, hasQuery) {
+  const taggedLocal = localCards.map((c) => ({ ...c, source: "local" }));
+  const taggedRemote = remoteCards.map((c) => ({ ...c, source: "remote" }));
+  const localIds = new Set(localCards.map((c) => c.id));
+  const dedupedRemote = taggedRemote.filter((c) => !localIds.has(c.id));
+  if (!hasQuery) {
+    return [...taggedLocal, ...dedupedRemote];
+  }
+  const result = [];
+  const maxLen = Math.max(taggedLocal.length, dedupedRemote.length);
+  for (let i = 0; i < maxLen; i++) {
+    if (i < taggedLocal.length) result.push(taggedLocal[i]);
+    if (i < dedupedRemote.length) result.push(dedupedRemote[i]);
+  }
+  return result;
+}
+
 // src/autonomy/auto-request.ts
 function minMaxNormalize(values) {
   if (values.length === 0) return [];
@@ -301,6 +659,188 @@ function scorePeers(candidates, selfOwner) {
   scored.sort((a, b) => b.rawScore - a.rawScore);
   return scored;
 }
+var AutoRequestor = class {
+  owner;
+  registryDb;
+  creditDb;
+  autonomyConfig;
+  budgetManager;
+  registryUrl;
+  /**
+   * Creates a new AutoRequestor.
+   *
+   * @param opts - Configuration for this AutoRequestor instance.
+   */
+  constructor(opts) {
+    this.owner = opts.owner;
+    this.registryDb = opts.registryDb;
+    this.creditDb = opts.creditDb;
+    this.autonomyConfig = opts.autonomyConfig;
+    this.budgetManager = opts.budgetManager;
+    this.registryUrl = opts.registryUrl;
+  }
+  /**
+   * Executes an autonomous capability request.
+   *
+   * Performs the full flow:
+   * 1. Search for matching capability cards
+   * 2. Filter self-owned and over-budget candidates
+   * 3. Score candidates using min-max normalized composite scoring
+   * 4. Resolve peer gateway config
+   * 5. Check autonomy tier (Tier 3 queues to pending_requests)
+   * 6. Check budget reserve
+   * 7. Hold escrow
+   * 8. Execute via peer gateway
+   * 9. Settle or release escrow based on outcome
+   * 10. Log audit event (for Tier 2 notifications and all failures)
+   *
+   * @param need - The capability need to fulfill.
+   * @returns The result of the auto-request attempt.
+   */
+  async requestWithAutonomy(need) {
+    let cards = searchCards(this.registryDb, need.query, { online: true });
+    if (cards.length === 0 && this.registryUrl) {
+      try {
+        cards = await fetchRemoteCards(this.registryUrl, { q: need.query, online: true });
+      } catch {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request_failed",
+          card_id: "none",
+          skill_id: "none",
+          tier_invoked: 3,
+          credits: 0,
+          peer: "none",
+          reason: `Remote registry fallback failed for query "${need.query}"`
+        });
+        cards = [];
+      }
+    }
+    const candidates = [];
+    for (const card of cards) {
+      const cardAsV2 = card;
+      if (Array.isArray(cardAsV2.skills)) {
+        for (const skill of cardAsV2.skills) {
+          const cost = skill.pricing.credits_per_call;
+          if (cost <= need.maxCostCredits) {
+            candidates.push({
+              card,
+              cost,
+              skillId: skill.id,
+              // Carry skill-level metadata so scorePeers() can prefer it over card-level
+              skillMetadata: skill.metadata,
+              skillInternal: skill._internal
+            });
+          }
+        }
+      } else {
+        const cost = card.pricing.credits_per_call;
+        if (cost <= need.maxCostCredits) {
+          candidates.push({ card, cost, skillId: void 0 });
+        }
+      }
+    }
+    const scored = scorePeers(candidates, this.owner);
+    if (scored.length === 0) {
+      this.logFailure("auto_request_failed", "system", "none", 3, 0, "none", "No eligible peer found");
+      return { status: "no_peer", reason: "No eligible peer found" };
+    }
+    const top = scored[0];
+    const peerConfig = findPeer(top.card.owner);
+    if (!peerConfig) {
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", 3, top.cost, top.card.owner, "No gateway config for peer");
+      return { status: "no_peer", reason: "No gateway config for peer" };
+    }
+    const tier = getAutonomyTier(top.cost, this.autonomyConfig);
+    if (tier === 3) {
+      createPendingRequest(this.registryDb, {
+        skill_query: need.query,
+        max_cost_credits: need.maxCostCredits,
+        credits: top.cost,
+        selected_peer: top.card.owner,
+        selected_card_id: top.card.id,
+        selected_skill_id: top.skillId,
+        params: need.params
+      });
+      insertAuditEvent(this.registryDb, {
+        type: "auto_request_pending",
+        card_id: top.card.id,
+        skill_id: top.skillId ?? top.card.id,
+        tier_invoked: 3,
+        credits: top.cost,
+        peer: top.card.owner
+      });
+      return {
+        status: "tier_blocked",
+        reason: "Tier 3: owner approval required",
+        peer: top.card.owner
+      };
+    }
+    if (!this.budgetManager.canSpend(top.cost)) {
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, "Budget reserve would be breached");
+      return { status: "budget_blocked", reason: "Insufficient credits \u2014 reserve floor would be breached" };
+    }
+    const escrowId = holdEscrow(this.creditDb, this.owner, top.cost, top.card.id);
+    try {
+      const execResult = await requestCapability({
+        gatewayUrl: peerConfig.url,
+        token: peerConfig.token,
+        cardId: top.card.id,
+        params: top.skillId ? { skill_id: top.skillId, ...need.params, requester: this.owner } : { ...need.params, requester: this.owner }
+      });
+      settleEscrow(this.creditDb, escrowId, top.card.owner);
+      if (tier === 2) {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request_notify",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 2,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      } else {
+        insertAuditEvent(this.registryDb, {
+          type: "auto_request",
+          card_id: top.card.id,
+          skill_id: top.skillId ?? top.card.id,
+          tier_invoked: 1,
+          credits: top.cost,
+          peer: top.card.owner
+        });
+      }
+      return {
+        status: "success",
+        result: execResult,
+        escrowId,
+        peer: top.card.owner,
+        creditsSpent: top.cost
+      };
+    } catch (err) {
+      releaseEscrow(this.creditDb, escrowId);
+      const reason = err instanceof Error ? err.message : String(err);
+      this.logFailure("auto_request_failed", top.card.id, top.skillId ?? "none", tier, top.cost, top.card.owner, `Execution failed: ${reason}`);
+      return {
+        status: "failed",
+        reason: `Execution failed: ${reason}`,
+        peer: top.card.owner
+      };
+    }
+  }
+  /**
+   * Logs a failure audit event to request_log.
+   * Used for all non-success paths to satisfy REQ-06.
+   */
+  logFailure(type, cardId, skillId, tier, credits, peer, reason) {
+    insertAuditEvent(this.registryDb, {
+      type,
+      card_id: cardId,
+      skill_id: skillId,
+      tier_invoked: tier,
+      credits,
+      peer,
+      reason
+    });
+  }
+};
 
 // src/conductor/capability-matcher.ts
 var MAX_ALTERNATIVES = 2;
@@ -476,6 +1016,53 @@ var BudgetManager = class {
   }
 };
 
+// src/utils/interpolation.ts
+function resolvePath(obj, path) {
+  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter((s) => s.length > 0);
+  let current = obj;
+  for (const segment of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function interpolate(template, context) {
+  return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => {
+    const resolved = resolvePath(context, expression.trim());
+    if (resolved === void 0 || resolved === null) {
+      return "";
+    }
+    if (typeof resolved === "object") {
+      return JSON.stringify(resolved);
+    }
+    return String(resolved);
+  });
+}
+function interpolateObject(obj, context) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = interpolateValue(value, context);
+  }
+  return result;
+}
+function interpolateValue(value, context) {
+  if (typeof value === "string") {
+    return interpolate(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolateValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return interpolateObject(value, context);
+  }
+  return value;
+}
+
 // src/conductor/pipeline-orchestrator.ts
 function computeWaves(subtasks) {
   const waves = [];
@@ -641,251 +1228,28 @@ async function orchestrate(opts) {
   };
 }
 
-// src/conductor/team-formation.ts
-import { randomUUID as randomUUID2 } 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 = randomUUID2();
-  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;
-  creditDb;
-  conductorOwner;
-  gatewayToken;
-  resolveAgentUrl;
-  maxBudget;
-  constructor(opts) {
-    this.db = opts.db;
-    this.creditDb = opts.creditDb;
-    this.conductorOwner = opts.conductorOwner;
-    this.gatewayToken = opts.gatewayToken;
-    this.resolveAgentUrl = opts.resolveAgentUrl;
-    this.maxBudget = opts.maxBudget ?? 100;
-  }
-  /**
-   * Execute a conductor skill with the given config and params.
-   *
-   * @param config - SkillConfig with type 'conductor' and conductor_skill field.
-   * @param params - Must include `task` string.
-   * @returns Execution result without latency_ms (added by SkillExecutor).
-   */
-  async execute(config, params, onProgress) {
-    const conductorSkill = config.conductor_skill;
-    if (conductorSkill !== "orchestrate" && conductorSkill !== "plan") {
-      return {
-        success: false,
-        error: `Unknown conductor skill: "${conductorSkill}"`
-      };
-    }
-    const task = params.task;
-    if (typeof task !== "string" || task.length === 0) {
-      return {
-        success: false,
-        error: 'Missing or empty "task" parameter'
-      };
-    }
-    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,
-        error: "No template matches task"
-      };
-    }
-    onProgress?.({ step: 1, total: 5, message: `Decomposed into ${subtasks.length} sub-tasks` });
-    const matchResults = await matchSubTasks({
-      db: this.db,
-      subtasks,
-      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);
-    if (!budgetController.canExecute(executionBudget)) {
-      return {
-        success: false,
-        error: `Budget exceeded: estimated ${executionBudget.estimated_total} cr, max ${this.maxBudget} cr`
-      };
-    }
-    onProgress?.({ step: 3, total: 5, message: `Budget approved: ${executionBudget.estimated_total} cr` });
-    if (conductorSkill === "plan") {
-      return {
-        success: true,
-        result: {
-          subtasks,
-          matches: matchResults,
-          budget: executionBudget,
-          team
-          // undefined when no role hints
-        }
-      };
-    }
-    const matchMap = new Map(
-      matchResults.map((m) => [m.subtask_id, m])
-    );
-    const orchResult = await orchestrate({
-      subtasks,
-      matches: matchMap,
-      gatewayToken: this.gatewayToken,
-      resolveAgentUrl: this.resolveAgentUrl,
-      maxBudget: this.maxBudget,
-      team
-    });
-    onProgress?.({ step: 4, total: 5, message: "Pipeline execution complete" });
-    const resultObj = {};
-    for (const [key, value] of orchResult.results) {
-      resultObj[key] = value;
-    }
-    return {
-      success: orchResult.success,
-      result: {
-        plan: subtasks,
-        execution: resultObj,
-        total_credits: orchResult.total_credits,
-        latency_ms: orchResult.latency_ms,
-        errors: orchResult.errors
-      },
-      error: orchResult.success ? void 0 : orchResult.errors?.join("; ")
-    };
-  }
-};
 export {
-  ConductorMode
+  interpolateObject,
+  validateAndNormalizeSubtasks,
+  decompose,
+  computeReputation,
+  searchCards,
+  filterCards,
+  buildReputationMap,
+  requestCapability,
+  requestViaRelay,
+  DEFAULT_AUTONOMY_CONFIG,
+  getAutonomyTier,
+  insertAuditEvent,
+  listPendingRequests,
+  resolvePendingRequest,
+  fetchRemoteCards,
+  mergeResults,
+  AutoRequestor,
+  matchSubTasks,
+  ORCHESTRATION_FEE,
+  BudgetController,
+  DEFAULT_BUDGET_CONFIG,
+  BudgetManager,
+  orchestrate
 };