agentbnb 8.2.2 → 8.3.0

package/dist/index.js

@@ -1,8 +1,3 @@
-import {
-  RelayClient,
-  RelayMessageSchema
-} from "./chunk-3LWBH7P3.js";
-
 // src/types/index.ts
 import { z } from "zod";
 var IOSchemaSchema = z.object({
@@ -40,6 +35,16 @@ var CapabilityCardSchema = z.object({
     schedule: z.string().optional()
     // cron expression
   }),
+  /**
+   * Provider-estimated typical execution duration in milliseconds.
+   * Used by requesters to derive default client-side timeouts.
+   */
+  expected_duration_ms: z.number().positive().optional(),
+  /**
+   * Provider hard timeout in milliseconds.
+   * Used as a fallback timeout hint when expected_duration_ms is unavailable.
+   */
+  hard_timeout_ms: z.number().positive().optional(),
   powered_by: z.array(PoweredBySchema).optional(),
   /**
    * Private per-card metadata. Stripped from all API and CLI responses —
@@ -93,6 +98,16 @@ var SkillSchema = z.object({
     credits_per_minute: z.number().nonnegative().optional(),
     free_tier: z.number().nonnegative().optional()
   }),
+  /**
+   * Provider-estimated typical execution duration in milliseconds.
+   * Used by requesters to derive default client-side timeouts.
+   */
+  expected_duration_ms: z.number().positive().optional(),
+  /**
+   * Provider hard timeout in milliseconds.
+   * Used as a fallback timeout hint when expected_duration_ms is unavailable.
+   */
+  hard_timeout_ms: z.number().positive().optional(),
   /** Per-skill online flag — overrides card-level availability for this skill. */
   availability: z.object({ online: z.boolean() }).optional(),
   powered_by: z.array(PoweredBySchema).optional(),
@@ -343,6 +358,61 @@ function initEvolutionTable(db) {
   `);
 }
 
+// src/identity/agent-identity.ts
+var AGENTS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS agents (
+    agent_id TEXT PRIMARY KEY,
+    display_name TEXT NOT NULL,
+    public_key TEXT NOT NULL,
+    operator_id TEXT,
+    server_id TEXT,
+    legacy_owner TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_agents_operator ON agents(operator_id);
+  CREATE INDEX IF NOT EXISTS idx_agents_legacy_owner ON agents(legacy_owner);
+`;
+function ensureAgentsTable(db) {
+  db.exec(AGENTS_SCHEMA);
+}
+function lookupAgent(db, agentId) {
+  return db.prepare("SELECT * FROM agents WHERE agent_id = ?").get(agentId) ?? null;
+}
+function lookupAgentByOwner(db, owner) {
+  return db.prepare("SELECT * FROM agents WHERE legacy_owner = ?").get(owner) ?? null;
+}
+function resolveCanonicalIdentity(db, identifier) {
+  ensureAgentsTable(db);
+  if (/^[a-f0-9]{16}$/.test(identifier)) {
+    const byAgentId = lookupAgent(db, identifier);
+    if (byAgentId) {
+      return {
+        agent_id: byAgentId.agent_id,
+        legacy_owner: byAgentId.legacy_owner,
+        resolved: true,
+        source: "agent_id"
+      };
+    }
+  }
+  const byOwner = lookupAgentByOwner(db, identifier);
+  if (byOwner) {
+    return {
+      agent_id: byOwner.agent_id,
+      legacy_owner: byOwner.legacy_owner,
+      resolved: true,
+      source: "legacy_owner"
+    };
+  }
+  return {
+    agent_id: identifier,
+    legacy_owner: null,
+    resolved: false,
+    source: "unresolved"
+  };
+}
+
 // src/registry/store.ts
 var V2_FTS_TRIGGERS = `
   DROP TRIGGER IF EXISTS cards_ai;
@@ -562,6 +632,7 @@ function openDatabase(path = ":memory:") {
       ON capability_cards(owner);
   `);
   createRequestLogTable(db);
+  ensureAgentsTable(db);
   initFeedbackTable(db);
   initEvolutionTable(db);
   runMigrations(db);
@@ -667,7 +738,11 @@ function rebuildCardsFts(db) {
 }
 function insertCard(db, card) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const withTimestamps = { ...card, created_at: card.created_at ?? now, updated_at: now };
+  const withTimestamps = attachCanonicalAgentId(db, {
+    ...card,
+    created_at: card.created_at ?? now,
+    updated_at: now
+  });
   const parsed = CapabilityCardSchema.safeParse(withTimestamps);
   if (!parsed.success) {
     throw new AgentBnBError(
@@ -693,6 +768,19 @@ function getCard(db, id) {
   if (!row) return null;
   return JSON.parse(row.data);
 }
+function attachCanonicalAgentId(db, card) {
+  const resolved = resolveCanonicalIdentity(db, card.owner);
+  if (!resolved.resolved) {
+    return card;
+  }
+  if (card.agent_id === resolved.agent_id) {
+    return card;
+  }
+  return {
+    ...card,
+    agent_id: resolved.agent_id
+  };
+}
 function updateReputation(db, cardId, success, latencyMs) {
   const existing = getCard(db, cardId);
   if (!existing) return;
@@ -717,16 +805,35 @@ function updateReputation(db, cardId, success, latencyMs) {
   stmt.run(JSON.stringify(updatedCard), now, cardId);
 }
 function listCards(db, owner) {
-  let stmt;
-  let rows;
-  if (owner !== void 0) {
-    stmt = db.prepare("SELECT data FROM capability_cards WHERE owner = ?");
-    rows = stmt.all(owner);
-  } else {
-    stmt = db.prepare("SELECT data FROM capability_cards");
-    rows = stmt.all();
+  if (owner === void 0) {
+    const rows = db.prepare("SELECT data FROM capability_cards").all();
+    return rows.map((row) => JSON.parse(row.data));
+  }
+  const filtered = /* @__PURE__ */ new Map();
+  const resolved = resolveCanonicalIdentity(db, owner);
+  const ownerAliases = /* @__PURE__ */ new Set([owner]);
+  if (resolved.legacy_owner) {
+    ownerAliases.add(resolved.legacy_owner);
+  }
+  for (const alias of ownerAliases) {
+    const aliasRows = db.prepare("SELECT data FROM capability_cards WHERE owner = ?").all(alias);
+    for (const row of aliasRows) {
+      const parsed = JSON.parse(row.data);
+      filtered.set(parsed.id, parsed);
+    }
   }
-  return rows.map((row) => JSON.parse(row.data));
+  const agentIdentifiers = /* @__PURE__ */ new Set([owner]);
+  if (resolved.resolved) {
+    agentIdentifiers.add(resolved.agent_id);
+  }
+  for (const agentIdentifier of agentIdentifiers) {
+    const agentRows = db.prepare("SELECT data FROM capability_cards WHERE json_extract(data, '$.agent_id') = ?").all(agentIdentifier);
+    for (const row of agentRows) {
+      const parsed = JSON.parse(row.data);
+      filtered.set(parsed.id, parsed);
+    }
+  }
+  return [...filtered.values()];
 }
 function getCardsByCapabilityType(db, capabilityType) {
   const rows = db.prepare(
@@ -915,6 +1022,122 @@ function applyReputationFilter(db, cards, minReputation) {
 import Database2 from "better-sqlite3";
 import { randomUUID as randomUUID3 } from "crypto";
 
+// src/credit/owner-normalization.ts
+var RESERVED_OWNERS = /* @__PURE__ */ new Set(["platform_treasury"]);
+function tableExists(db, table) {
+  const row = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
+  return row !== void 0;
+}
+function mergeBalanceRows(db, oldOwner, newOwner, now) {
+  if (!tableExists(db, "credit_balances")) return;
+  const oldRow = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(oldOwner);
+  if (!oldRow) return;
+  const newRow = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(newOwner);
+  if (newRow) {
+    db.prepare(
+      "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
+    ).run(oldRow.balance, now, newOwner);
+    db.prepare("DELETE FROM credit_balances WHERE owner = ?").run(oldOwner);
+    return;
+  }
+  db.prepare("UPDATE credit_balances SET owner = ?, updated_at = ? WHERE owner = ?").run(
+    newOwner,
+    now,
+    oldOwner
+  );
+}
+function mergeProviderRegistryRows(db, oldOwner, newOwner) {
+  if (!tableExists(db, "provider_registry")) return;
+  const oldRow = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(oldOwner);
+  if (!oldRow) return;
+  const newRow = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(newOwner);
+  if (newRow) {
+    db.prepare("DELETE FROM provider_registry WHERE owner = ?").run(oldOwner);
+    return;
+  }
+  db.prepare("UPDATE provider_registry SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+}
+function mergeReliabilityRows(db, oldOwner, newOwner, now) {
+  if (!tableExists(db, "provider_reliability_metrics")) return;
+  const oldRow = db.prepare("SELECT * FROM provider_reliability_metrics WHERE owner = ?").get(oldOwner);
+  if (!oldRow) return;
+  const newRow = db.prepare("SELECT * FROM provider_reliability_metrics WHERE owner = ?").get(newOwner);
+  if (!newRow) {
+    db.prepare(
+      "UPDATE provider_reliability_metrics SET owner = ?, updated_at = ? WHERE owner = ?"
+    ).run(newOwner, now, oldOwner);
+    return;
+  }
+  const cycleStartCandidates = [oldRow.cycle_start, newRow.cycle_start].filter(Boolean);
+  const mergedCycleStart = cycleStartCandidates.length > 0 ? cycleStartCandidates.slice().sort((left, right) => left.localeCompare(right))[0] : now;
+  db.prepare(
+    `UPDATE provider_reliability_metrics
+     SET current_streak = ?,
+         longest_streak = ?,
+         total_hires = ?,
+         repeat_hires = ?,
+         feedback_count = ?,
+         feedback_sum = ?,
+         availability_checks = ?,
+         availability_hits = ?,
+         cycle_start = ?,
+         updated_at = ?
+     WHERE owner = ?`
+  ).run(
+    Math.max(oldRow.current_streak, newRow.current_streak),
+    Math.max(oldRow.longest_streak, newRow.longest_streak),
+    oldRow.total_hires + newRow.total_hires,
+    oldRow.repeat_hires + newRow.repeat_hires,
+    oldRow.feedback_count + newRow.feedback_count,
+    oldRow.feedback_sum + newRow.feedback_sum,
+    oldRow.availability_checks + newRow.availability_checks,
+    oldRow.availability_hits + newRow.availability_hits,
+    mergedCycleStart,
+    now,
+    newOwner
+  );
+  db.prepare("DELETE FROM provider_reliability_metrics WHERE owner = ?").run(oldOwner);
+}
+function migrateCreditOwnerData(db, oldOwner, newOwner) {
+  if (!oldOwner || !newOwner || oldOwner === newOwner) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.transaction(() => {
+    mergeBalanceRows(db, oldOwner, newOwner, now);
+    if (tableExists(db, "credit_transactions")) {
+      db.prepare("UPDATE credit_transactions SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    if (tableExists(db, "credit_escrow")) {
+      db.prepare("UPDATE credit_escrow SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    mergeProviderRegistryRows(db, oldOwner, newOwner);
+    if (tableExists(db, "demand_vouchers")) {
+      db.prepare("UPDATE demand_vouchers SET owner = ? WHERE owner = ?").run(newOwner, oldOwner);
+    }
+    mergeReliabilityRows(db, oldOwner, newOwner, now);
+  })();
+}
+function canonicalizeCreditOwner(db, owner) {
+  if (!owner || RESERVED_OWNERS.has(owner)) {
+    return owner;
+  }
+  ensureAgentsTable(db);
+  const resolved = resolveCanonicalIdentity(db, owner);
+  if (!resolved.resolved) {
+    return owner;
+  }
+  const aliases = /* @__PURE__ */ new Set();
+  if (owner !== resolved.agent_id) {
+    aliases.add(owner);
+  }
+  if (resolved.legacy_owner && resolved.legacy_owner !== resolved.agent_id) {
+    aliases.add(resolved.legacy_owner);
+  }
+  for (const alias of aliases) {
+    migrateCreditOwnerData(db, alias, resolved.agent_id);
+  }
+  return resolved.agent_id;
+}
+
 // src/credit/reliability-metrics.ts
 var RELIABILITY_METRICS_SCHEMA = `
   CREATE TABLE IF NOT EXISTS provider_reliability_metrics (
@@ -935,6 +1158,7 @@ function ensureReliabilityTable(db) {
   db.exec(RELIABILITY_METRICS_SCHEMA);
 }
 function ensureRow(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.prepare(
     `INSERT OR IGNORE INTO provider_reliability_metrics
@@ -942,18 +1166,20 @@ function ensureRow(db, owner) {
       feedback_count, feedback_sum, availability_checks, availability_hits,
       cycle_start, updated_at)
      VALUES (?, 0, 0, 0, 0, 0, 0, 0, 0, ?, ?)`
-  ).run(owner, now, now);
+  ).run(canonicalOwner, now, now);
 }
 function recordSuccessfulHire(db, providerOwner, consumerOwner) {
+  const canonicalProviderOwner = canonicalizeCreditOwner(db, providerOwner);
+  const canonicalConsumerOwner = canonicalizeCreditOwner(db, consumerOwner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  ensureRow(db, providerOwner);
+  ensureRow(db, canonicalProviderOwner);
   const isRepeat = db.prepare(
     `SELECT COUNT(*) as cnt FROM credit_transactions
      WHERE owner = ? AND reason = 'settlement'
      AND reference_id IN (
        SELECT id FROM credit_escrow WHERE owner = ?
      )`
-  ).get(providerOwner, consumerOwner);
+  ).get(canonicalProviderOwner, canonicalConsumerOwner);
   const repeatIncrement = (isRepeat?.cnt ?? 0) > 0 ? 1 : 0;
   db.prepare(
     `UPDATE provider_reliability_metrics
@@ -963,27 +1189,7 @@ function recordSuccessfulHire(db, providerOwner, consumerOwner) {
          repeat_hires = repeat_hires + ?,
          updated_at = ?
      WHERE owner = ?`
-  ).run(repeatIncrement, now, providerOwner);
-}
-
-// src/identity/agent-identity.ts
-var AGENTS_SCHEMA = `
-  CREATE TABLE IF NOT EXISTS agents (
-    agent_id TEXT PRIMARY KEY,
-    display_name TEXT NOT NULL,
-    public_key TEXT NOT NULL,
-    operator_id TEXT,
-    server_id TEXT,
-    legacy_owner TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_agents_operator ON agents(operator_id);
-  CREATE INDEX IF NOT EXISTS idx_agents_legacy_owner ON agents(legacy_owner);
-`;
-function ensureAgentsTable(db) {
-  db.exec(AGENTS_SCHEMA);
+  ).run(repeatIncrement, now, canonicalProviderOwner);
 }
 
 // src/credit/ledger.ts
@@ -1046,19 +1252,22 @@ function openCreditDb(path = ":memory:") {
   return db;
 }
 function getBalance(db, owner) {
-  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(canonicalOwner);
   return row?.balance ?? 0;
 }
 function registerProvider(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const maxRow = db.prepare("SELECT MAX(provider_number) as maxNum FROM provider_registry").get();
   const nextNum = (maxRow?.maxNum ?? 0) + 1;
-  db.prepare("INSERT OR IGNORE INTO provider_registry (owner, provider_number, registered_at) VALUES (?, ?, ?)").run(owner, nextNum, now);
-  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(owner);
+  db.prepare("INSERT OR IGNORE INTO provider_registry (owner, provider_number, registered_at) VALUES (?, ?, ?)").run(canonicalOwner, nextNum, now);
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(canonicalOwner);
   return row.provider_number;
 }
 function getProviderNumber(db, owner) {
-  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(owner);
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
+  const row = db.prepare("SELECT provider_number FROM provider_registry WHERE owner = ?").get(canonicalOwner);
   return row?.provider_number ?? null;
 }
 function getProviderBonus(providerNumber) {
@@ -1067,10 +1276,11 @@ function getProviderBonus(providerNumber) {
   return 1;
 }
 function getActiveVoucher(db, owner) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const row = db.prepare(
     "SELECT id, remaining, expires_at FROM demand_vouchers WHERE owner = ? AND is_active = 1 AND remaining > 0 AND expires_at > ? ORDER BY created_at ASC LIMIT 1"
-  ).get(owner, now);
+  ).get(canonicalOwner, now);
   return row ?? null;
 }
 function consumeVoucher(db, voucherId, amount) {
@@ -1079,6 +1289,7 @@ function consumeVoucher(db, voucherId, amount) {
   ).run(amount, voucherId, amount);
 }
 function recordEarning(db, owner, amount, _cardId, receiptNonce) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.transaction(() => {
     const existing = db.prepare(
@@ -1087,13 +1298,13 @@ function recordEarning(db, owner, amount, _cardId, receiptNonce) {
     if (existing) return;
     db.prepare(
       "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
-    ).run(owner, now);
+    ).run(canonicalOwner, now);
     db.prepare(
       "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-    ).run(amount, now, owner);
+    ).run(amount, now, canonicalOwner);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID3(), owner, amount, "remote_earning", receiptNonce, now);
+    ).run(randomUUID3(), canonicalOwner, amount, "remote_earning", receiptNonce, now);
   })();
 }
 
@@ -1107,59 +1318,116 @@ import { randomUUID as randomUUID5 } from "crypto";
 // src/credit/escrow.ts
 import { randomUUID as randomUUID4 } from "crypto";
 var NETWORK_FEE_RATE = 0.05;
+var FINALIZABLE_ESCROW_STATUSES = /* @__PURE__ */ new Set([
+  "held",
+  "started",
+  "progressing",
+  "abandoned"
+]);
+var TERMINAL_ESCROW_STATUSES = /* @__PURE__ */ new Set(["settled", "released"]);
+function getEscrowForMutation(db, escrowId) {
+  const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
+  if (!escrow) {
+    throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
+  }
+  return {
+    ...escrow,
+    owner: canonicalizeCreditOwner(db, escrow.owner)
+  };
+}
+function updateEscrowStatus(db, escrowId, fromStatuses, toStatus) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transition = db.transaction(() => {
+    const escrow = getEscrowForMutation(db, escrowId);
+    const current = escrow.status;
+    if (!fromStatuses.includes(current)) {
+      throw new AgentBnBError(
+        `Invalid escrow transition for ${escrowId}: ${current} -> ${toStatus}`,
+        "ESCROW_INVALID_TRANSITION"
+      );
+    }
+    if (current === toStatus) return;
+    const settledAt = TERMINAL_ESCROW_STATUSES.has(toStatus) ? now : null;
+    db.prepare("UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?").run(
+      toStatus,
+      settledAt,
+      escrowId
+    );
+  });
+  transition();
+}
+function assertEscrowCanFinalize(escrow) {
+  const status = escrow.status;
+  if (FINALIZABLE_ESCROW_STATUSES.has(status)) {
+    return;
+  }
+  if (TERMINAL_ESCROW_STATUSES.has(status)) {
+    throw new AgentBnBError(
+      `Escrow ${escrow.id} is already ${status}`,
+      "ESCROW_ALREADY_SETTLED"
+    );
+  }
+  throw new AgentBnBError(
+    `Escrow ${escrow.id} has invalid lifecycle status: ${escrow.status}`,
+    "ESCROW_INVALID_TRANSITION"
+  );
+}
 function holdEscrow(db, owner, amount, cardId) {
+  const canonicalOwner = canonicalizeCreditOwner(db, owner);
   const escrowId = randomUUID4();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const hold = db.transaction(() => {
-    const voucher = getActiveVoucher(db, owner);
+    const voucher = getActiveVoucher(db, canonicalOwner);
     if (voucher && voucher.remaining >= amount) {
       consumeVoucher(db, voucher.id, amount);
       db.prepare(
         "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
-      ).run(escrowId, owner, amount, cardId, "held", now, "voucher");
+      ).run(escrowId, canonicalOwner, amount, cardId, "held", now, "voucher");
       db.prepare(
         "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-      ).run(randomUUID4(), owner, -amount, "voucher_hold", escrowId, now);
+      ).run(randomUUID4(), canonicalOwner, -amount, "voucher_hold", escrowId, now);
     } else {
-      const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(owner);
+      const row = db.prepare("SELECT balance FROM credit_balances WHERE owner = ?").get(canonicalOwner);
       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);
+      ).run(amount, now, canonicalOwner, amount);
       db.prepare(
         "INSERT INTO credit_escrow (id, owner, amount, card_id, status, created_at, funding_source) VALUES (?, ?, ?, ?, ?, ?, ?)"
-      ).run(escrowId, owner, amount, cardId, "held", now, "balance");
+      ).run(escrowId, canonicalOwner, amount, cardId, "held", now, "balance");
       db.prepare(
         "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-      ).run(randomUUID4(), owner, -amount, "escrow_hold", escrowId, now);
+      ).run(randomUUID4(), canonicalOwner, -amount, "escrow_hold", escrowId, now);
     }
   });
   hold();
   return escrowId;
 }
+function markEscrowStarted(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["held", "started"], "started");
+}
+function markEscrowProgressing(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["held", "started", "progressing"], "progressing");
+}
+function markEscrowAbandoned(db, escrowId) {
+  updateEscrowStatus(db, escrowId, ["started", "progressing", "abandoned"], "abandoned");
+}
 function settleEscrow(db, escrowId, recipientOwner) {
+  const canonicalRecipientOwner = canonicalizeCreditOwner(db, recipientOwner);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const settle = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
-    if (!escrow) {
-      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
-    }
-    if (escrow.status !== "held") {
-      throw new AgentBnBError(
-        `Escrow ${escrowId} is already ${escrow.status}`,
-        "ESCROW_ALREADY_SETTLED"
-      );
-    }
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
     const feeAmount = Math.floor(escrow.amount * NETWORK_FEE_RATE);
     const providerAmount = escrow.amount - feeAmount;
     db.prepare(
       "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
-    ).run(recipientOwner, now);
+    ).run(canonicalRecipientOwner, now);
     db.prepare(
       "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-    ).run(providerAmount, now, recipientOwner);
+    ).run(providerAmount, now, canonicalRecipientOwner);
     if (feeAmount > 0) {
       db.prepare(
         "INSERT OR IGNORE INTO credit_balances (owner, balance, updated_at) VALUES (?, 0, ?)"
@@ -1176,10 +1444,10 @@ function settleEscrow(db, escrowId, recipientOwner) {
     ).run("settled", now, escrowId);
     db.prepare(
       "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-    ).run(randomUUID4(), recipientOwner, providerAmount, "settlement", escrowId, now);
-    let providerNum = getProviderNumber(db, recipientOwner);
+    ).run(randomUUID4(), canonicalRecipientOwner, providerAmount, "settlement", escrowId, now);
+    let providerNum = getProviderNumber(db, canonicalRecipientOwner);
     if (providerNum === null) {
-      providerNum = registerProvider(db, recipientOwner);
+      providerNum = registerProvider(db, canonicalRecipientOwner);
     }
     const bonus = getProviderBonus(providerNum);
     if (bonus > 1) {
@@ -1190,14 +1458,14 @@ function settleEscrow(db, escrowId, recipientOwner) {
         ).run("platform_treasury", now);
         db.prepare(
           "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
-        ).run(bonusAmount, now, recipientOwner);
+        ).run(bonusAmount, now, canonicalRecipientOwner);
         db.prepare(
           "INSERT INTO credit_transactions (id, owner, amount, reason, reference_id, created_at) VALUES (?, ?, ?, ?, ?, ?)"
-        ).run(randomUUID4(), recipientOwner, bonusAmount, "provider_bonus", escrowId, now);
+        ).run(randomUUID4(), canonicalRecipientOwner, bonusAmount, "provider_bonus", escrowId, now);
       }
     }
     try {
-      recordSuccessfulHire(db, recipientOwner, escrow.owner);
+      recordSuccessfulHire(db, canonicalRecipientOwner, escrow.owner);
     } catch {
     }
   });
@@ -1206,16 +1474,8 @@ function settleEscrow(db, escrowId, recipientOwner) {
 function releaseEscrow(db, escrowId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const release = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source FROM credit_escrow WHERE id = ?").get(escrowId);
-    if (!escrow) {
-      throw new AgentBnBError(`Escrow not found: ${escrowId}`, "ESCROW_NOT_FOUND");
-    }
-    if (escrow.status !== "held") {
-      throw new AgentBnBError(
-        `Escrow ${escrowId} is already ${escrow.status}`,
-        "ESCROW_ALREADY_SETTLED"
-      );
-    }
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
     db.prepare(
       "UPDATE credit_balances SET balance = balance + ?, updated_at = ? WHERE owner = ?"
     ).run(escrow.amount, now, escrow.owner);
@@ -1231,16 +1491,8 @@ function releaseEscrow(db, escrowId) {
 function confirmEscrowDebit(db, escrowId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const confirm = db.transaction(() => {
-    const escrow = db.prepare("SELECT id, owner, amount, status, funding_source 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"
-      );
-    }
+    const escrow = getEscrowForMutation(db, escrowId);
+    assertEscrowCanFinalize(escrow);
     db.prepare(
       "UPDATE credit_escrow SET status = ?, settled_at = ? WHERE id = ?"
     ).run("settled", now, escrowId);
@@ -1251,111 +1503,21 @@ function confirmEscrowDebit(db, escrowId) {
   confirm();
 }
 
-// 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(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");
-  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) {
-  const feeAmount = Math.floor(receipt.amount * NETWORK_FEE_RATE);
-  const providerAmount = receipt.amount - feeAmount;
-  recordEarning(
-    providerDb,
-    providerOwner,
-    providerAmount,
-    receipt.card_id,
-    receipt.nonce
-  );
-  return { settled: true };
-}
-function settleRequesterEscrow(requesterDb, escrowId) {
-  confirmEscrowDebit(requesterDb, escrowId);
-}
-function releaseRequesterEscrow(requesterDb, escrowId) {
-  releaseEscrow(requesterDb, escrowId);
-}
-
 // src/cli/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 import { homedir } from "os";
-import { join as join2 } from "path";
+import { join } from "path";
 function getConfigDir() {
-  return process.env["AGENTBNB_DIR"] ?? join2(homedir(), ".agentbnb");
+  return process.env["AGENTBNB_DIR"] ?? join(homedir(), ".agentbnb");
 }
 function getConfigPath() {
-  return join2(getConfigDir(), "config.json");
+  return join(getConfigDir(), "config.json");
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync2(configPath)) return null;
+  if (!existsSync(configPath)) return null;
   try {
-    const raw = readFileSync2(configPath, "utf-8");
+    const raw = readFileSync(configPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1508,23 +1670,17 @@ async function executeCapabilityRequest(opts) {
     cardName = card.name;
   }
   let escrowId = null;
-  let isRemoteEscrow = false;
   if (relayAuthorized) {
   } else 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" } };
+    if (creditsNeeded > 0) {
+      return {
+        success: false,
+        error: {
+          code: -32603,
+          message: "Direct HTTP paid remote settlement is disabled. Route paid requests through relay."
+        }
+      };
     }
-    isRemoteEscrow = true;
   } else {
     try {
       const balance = getBalance(creditDb, requester);
@@ -1538,9 +1694,8 @@ async function executeCapabilityRequest(opts) {
     }
   }
   const startMs = Date.now();
-  const receiptData = isRemoteEscrow ? { receipt_released: true } : void 0;
   const handleFailure = (status, latencyMs, message, failureReason = "bad_execution") => {
-    if (!isRemoteEscrow && escrowId) releaseEscrow(creditDb, escrowId);
+    if (escrowId) releaseEscrow(creditDb, escrowId);
     if (failureReason === "bad_execution" || failureReason === "auth_error") {
       updateReputation(registryDb, cardId, false, latencyMs);
     }
@@ -1559,15 +1714,10 @@ async function executeCapabilityRequest(opts) {
       });
     } catch {
     }
-    return {
-      success: false,
-      error: { code: -32603, message, ...receiptData ? { data: receiptData } : {} }
-    };
+    return { success: false, error: { code: -32603, message } };
   };
   const handleSuccess = (result, latencyMs) => {
-    if (isRemoteEscrow && receipt) {
-      settleProviderEarning(creditDb, card.owner, receipt);
-    } else if (escrowId) {
+    if (escrowId) {
       settleEscrow(creditDb, escrowId, card.owner);
     }
     updateReputation(registryDb, cardId, true, latencyMs);
@@ -1595,12 +1745,7 @@ async function executeCapabilityRequest(opts) {
       latencyMs
     }).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 };
+    return { success: true, result };
   };
   if (skillExecutor) {
     let targetSkillId = resolvedSkillId ?? skillId;
@@ -1628,33 +1773,103 @@ async function executeCapabilityRequest(opts) {
       return handleFailure("failure", Date.now() - startMs, message, "bad_execution");
     }
   }
-  if (!handlerUrl) {
-    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured", "bad_execution");
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  if (!handlerUrl) {
+    return handleFailure("failure", Date.now() - startMs, "No skill executor or handler URL configured", "bad_execution");
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  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}`, "bad_execution");
+    }
+    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",
+      isTimeout ? "timeout" : "bad_execution"
+    );
+  }
+}
+
+// src/credit/signing.ts
+import { generateKeyPairSync, sign, verify, createPublicKey, createPrivateKey } from "crypto";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, chmodSync } from "fs";
+import { join as join2 } 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 = join2(configDir, "private.key");
+  const publicPath = join2(configDir, "public.key");
+  writeFileSync2(privatePath, keys.privateKey);
+  chmodSync(privatePath, 384);
+  writeFileSync2(publicPath, keys.publicKey);
+}
+function loadKeyPair(configDir) {
+  const privatePath = join2(configDir, "private.key");
+  const publicPath = join2(configDir, "public.key");
+  if (!existsSync2(privatePath) || !existsSync2(publicPath)) {
+    throw new AgentBnBError("Keypair not found. Run `agentbnb init` to generate one.", "KEYPAIR_NOT_FOUND");
+  }
+  return {
+    publicKey: readFileSync2(publicPath),
+    privateKey: readFileSync2(privatePath)
+  };
+}
+function canonicalJson(data) {
+  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");
+  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 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}`, "bad_execution");
-    }
-    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",
-      isTimeout ? "timeout" : "bad_execution"
-    );
+    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;
   }
 }
 
@@ -1853,6 +2068,9 @@ function createGatewayServer(opts) {
 }
 
 // src/skills/executor.ts
+function buildTimeoutError(skillId, timeoutMs) {
+  return `Skill "${skillId}" timed out after ${timeoutMs}ms`;
+}
 var SkillExecutor = class {
   skillMap;
   modeMap;
@@ -1911,7 +2129,20 @@ var SkillExecutor = class {
       this.concurrencyGuard.acquire(skillId);
     }
     try {
-      const modeResult = await mode.execute(config, params, onProgress);
+      const configuredTimeoutMs = typeof config.timeout_ms === "number" ? config.timeout_ms : void 0;
+      const modeExecution = mode.execute(config, params, onProgress);
+      const modeResult = configuredTimeoutMs === void 0 ? await modeExecution : await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error(buildTimeoutError(skillId, configuredTimeoutMs)));
+        }, configuredTimeoutMs);
+        modeExecution.then((value) => {
+          clearTimeout(timeout);
+          resolve(value);
+        }).catch((err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+      });
       return {
         ...modeResult,
         latency_ms: Date.now() - startTime
@@ -1982,7 +2213,8 @@ var CapabilityDeclarationSchema = {
   description: z2.string().optional(),
   capability_types: z2.array(z2.string()).optional(),
   requires_capabilities: z2.array(z2.string()).optional(),
-  visibility: z2.enum(["public", "private"]).optional()
+  visibility: z2.enum(["public", "private"]).optional(),
+  expected_duration_ms: z2.number().positive().optional()
 };
 var ApiSkillConfigSchema = z2.object({
   id: z2.string().min(1),
@@ -2315,6 +2547,15 @@ function interpolateValue(value, context) {
 
 // src/skills/pipeline-executor.ts
 var execFileAsync = promisify(execFile);
+function isTimedOutCommandError(err) {
+  if (!(err instanceof Error)) {
+    return false;
+  }
+  const timeoutCode = err.code;
+  const signal = err.signal;
+  const killed = err.killed;
+  return timeoutCode === "ETIMEDOUT" || err.message.includes("timed out") || killed === true && typeof signal === "string";
+}
 function shellEscape(value) {
   return "'" + value.replace(/'/g, "'\\''") + "'";
 }
@@ -2366,6 +2607,8 @@ var PipelineExecutor = class {
   async execute(config, params, onProgress) {
     const pipelineConfig = config;
     const steps = pipelineConfig.steps ?? [];
+    const pipelineTimeoutMs = pipelineConfig.timeout_ms;
+    const deadline = typeof pipelineTimeoutMs === "number" ? Date.now() + pipelineTimeoutMs : void 0;
     if (steps.length === 0) {
       return { success: true, result: null };
     }
@@ -2387,11 +2630,41 @@ var PipelineExecutor = class {
         context
       );
       let stepResult;
+      const runWithRemainingDeadline = async (operation) => {
+        if (deadline === void 0) {
+          return operation();
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          throw new Error(`pipeline timed out after ${pipelineTimeoutMs}ms`);
+        }
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            reject(new Error(`pipeline timed out after ${pipelineTimeoutMs}ms`));
+          }, remainingMs);
+          operation().then((value) => {
+            clearTimeout(timeout);
+            resolve(value);
+          }).catch((err) => {
+            clearTimeout(timeout);
+            reject(err);
+          });
+        });
+      };
       if ("skill_id" in step && step.skill_id) {
-        const subResult = await this.skillExecutor.execute(
-          step.skill_id,
-          resolvedInputs
-        );
+        let subResult;
+        try {
+          subResult = await runWithRemainingDeadline(() => this.skillExecutor.execute(
+            step.skill_id,
+            resolvedInputs
+          ));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            success: false,
+            error: `Step ${i} failed: ${message}`
+          };
+        }
         if (!subResult.success) {
           return {
             success: false,
@@ -2405,10 +2678,16 @@ var PipelineExecutor = class {
           context
         );
         try {
-          const { stdout } = await execFileAsync("/bin/sh", ["-c", interpolatedCommand], { timeout: 3e4 });
+          const remainingMs = deadline === void 0 ? void 0 : deadline - Date.now();
+          if (remainingMs !== void 0 && remainingMs <= 0) {
+            throw new Error(`pipeline timed out after ${pipelineTimeoutMs}ms`);
+          }
+          const { stdout } = await execFileAsync("/bin/sh", ["-c", interpolatedCommand], {
+            timeout: remainingMs !== void 0 ? remainingMs : 3e4
+          });
           stepResult = stdout.trim();
         } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
+          const message = pipelineTimeoutMs !== void 0 && isTimedOutCommandError(err) ? `pipeline timed out after ${pipelineTimeoutMs}ms` : err instanceof Error ? err.message : String(err);
           return {
             success: false,
             error: `Step ${i} failed: ${message}`
@@ -2495,17 +2774,43 @@ function executeProcess(config, payload) {
       error: `Invalid agent name: "${config.agent_name}" (only alphanumeric, hyphens, underscores, dots allowed)`
     };
   }
-  const inputJson = JSON.stringify(payload);
+  const skillId = config.id;
+  const message = `[AgentBnB Rental Request]
+You are executing the "${skillId}" skill for an AgentBnB network rental.
+Read your skills/${skillId}/SKILL.md for detailed instructions.
+
+Input parameters:
+${JSON.stringify(payload.params ?? {}, null, 2)}
+
+IMPORTANT: Return ONLY a JSON object as your response.
+Do NOT include explanations, markdown formatting, or code blocks.
+The JSON should contain the output fields specified in your SKILL.md.
+If you cannot complete the task, return: {"error": "reason"}`;
   try {
-    const stdout = execFileSync("openclaw", ["run", config.agent_name, "--input", inputJson], {
+    const stdout = execFileSync("openclaw", [
+      "agent",
+      "--agent",
+      config.agent_name,
+      "--message",
+      message,
+      "--json",
+      "--local"
+    ], {
       timeout: timeoutMs
     });
     const text = stdout.toString().trim();
-    const result = JSON.parse(text);
-    return { success: true, result };
+    try {
+      const parsed = JSON.parse(text);
+      return { success: true, result: parsed };
+    } catch {
+      return {
+        success: false,
+        error: `OpenClaw process channel returned invalid JSON: ${text}`
+      };
+    }
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { success: false, error: message };
+    const message2 = err instanceof Error ? err.message : String(err);
+    return { success: false, error: message2 };
   }
 }
 async function executeTelegram(config, payload) {
@@ -3077,18 +3382,29 @@ 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 REQUEST_TIMEOUT_FALLBACK_MS = 3e5;
+var REQUEST_TIMEOUT_GRACE_MS = 3e4;
+var REQUEST_TIMEOUT_EXPECTED_MULTIPLIER = 1.5;
 var gatewayAgent = new Agent({
   keepAliveTimeout: 3e4,
   keepAliveMaxTimeout: 6e4,
   connections: 10,
   pipelining: 1
 });
+function deriveRequestTimeoutMs(hint) {
+  const expectedDurationMs = hint?.expected_duration_ms;
+  if (typeof expectedDurationMs === "number" && expectedDurationMs > 0) {
+    return Math.ceil(expectedDurationMs * REQUEST_TIMEOUT_EXPECTED_MULTIPLIER) + REQUEST_TIMEOUT_GRACE_MS;
+  }
+  const hardTimeoutMs = hint?.hard_timeout_ms;
+  if (typeof hardTimeoutMs === "number" && hardTimeoutMs > 0) {
+    return Math.ceil(hardTimeoutMs) + REQUEST_TIMEOUT_GRACE_MS;
+  }
+  return REQUEST_TIMEOUT_FALLBACK_MS;
+}
 function buildGatewayAuthHeaders(payload, token, identity) {
   const headers = { "Content-Type": "application/json" };
   if (identity) {
@@ -3103,7 +3419,17 @@ function buildGatewayAuthHeaders(payload, token, identity) {
   return headers;
 }
 async function requestCapability(opts) {
-  const { gatewayUrl, token, cardId, params = {}, timeoutMs = 3e5, escrowReceipt, identity } = opts;
+  const {
+    gatewayUrl,
+    token,
+    cardId,
+    params = {},
+    timeoutMs: timeoutOverrideMs,
+    timeoutHint,
+    escrowReceipt,
+    identity
+  } = opts;
+  const timeoutMs = timeoutOverrideMs ?? deriveRequestTimeoutMs(timeoutHint);
   const id = randomUUID8();
   const payload = {
     jsonrpc: "2.0",
@@ -3155,82 +3481,640 @@ async function requestCapabilityBatch(gatewayUrl, token, items, opts = {}) {
       params: item.params,
       escrowReceipt: item.escrowReceipt,
       timeoutMs: opts.timeoutMs,
+      timeoutHint: opts.timeoutHint,
       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 { timeoutMs: timeoutOverrideMs, timeoutHint, identity } = opts;
+  const timeoutMs = timeoutOverrideMs ?? deriveRequestTimeoutMs(timeoutHint);
+  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) {
+  const timeoutMs = opts.timeoutMs ?? deriveRequestTimeoutMs(opts.timeoutHint);
+  try {
+    return await relay.request({
+      targetOwner: opts.targetOwner,
+      targetAgentId: opts.targetAgentId,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      requester: opts.requester,
+      escrowReceipt: opts.escrowReceipt,
+      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/gateway/relay-dispatch.ts
+import { randomUUID as randomUUID10 } from "crypto";
+
+// src/relay/websocket-client.ts
+import WebSocket from "ws";
+import { randomUUID as randomUUID9 } from "crypto";
+
+// src/relay/types.ts
+import { z as z3 } from "zod";
+var RegisterMessageSchema = z3.object({
+  type: z3.literal("register"),
+  owner: z3.string().min(1),
+  /** V8: Cryptographic agent identity. When present, used as the canonical key. */
+  agent_id: z3.string().optional(),
+  /** V8 Phase 3: Server identifier for multi-agent delegation. */
+  server_id: z3.string().optional(),
+  token: z3.string().min(1),
+  card: z3.record(z3.unknown()),
+  // CapabilityCard (validated separately)
+  cards: z3.array(z3.record(z3.unknown())).optional(),
+  // Additional cards (e.g., conductor card)
+  /** V8 Phase 3: Additional agents served by this server (multi-agent registration). */
+  agents: z3.array(z3.object({
+    agent_id: z3.string().min(1),
+    display_name: z3.string().min(1),
+    cards: z3.array(z3.record(z3.unknown())),
+    delegation_token: z3.record(z3.unknown()).optional()
+  })).optional()
+});
+var RegisteredMessageSchema = z3.object({
+  type: z3.literal("registered"),
+  agent_id: z3.string()
+});
+var RelayRequestMessageSchema = z3.object({
+  type: z3.literal("relay_request"),
+  id: z3.string().uuid(),
+  target_owner: z3.string().min(1),
+  /** V8: Target agent's cryptographic identity. Preferred over target_owner. */
+  target_agent_id: z3.string().optional(),
+  card_id: z3.string(),
+  skill_id: z3.string().optional(),
+  params: z3.record(z3.unknown()).default({}),
+  requester: z3.string().optional(),
+  escrow_receipt: z3.record(z3.unknown()).optional()
+});
+var IncomingRequestMessageSchema = z3.object({
+  type: z3.literal("incoming_request"),
+  id: z3.string().uuid(),
+  from_owner: z3.string().min(1),
+  card_id: z3.string(),
+  skill_id: z3.string().optional(),
+  params: z3.record(z3.unknown()).default({}),
+  requester: z3.string().optional(),
+  escrow_receipt: z3.record(z3.unknown()).optional()
+});
+var RelayResponseMessageSchema = z3.object({
+  type: z3.literal("relay_response"),
+  id: z3.string().uuid(),
+  result: z3.unknown().optional(),
+  error: z3.object({
+    code: z3.number(),
+    message: z3.string()
+  }).optional()
+});
+var ResponseMessageSchema = z3.object({
+  type: z3.literal("response"),
+  id: z3.string().uuid(),
+  result: z3.unknown().optional(),
+  error: z3.object({
+    code: z3.number(),
+    message: z3.string()
+  }).optional()
+});
+var ErrorMessageSchema = z3.object({
+  type: z3.literal("error"),
+  code: z3.string(),
+  message: z3.string(),
+  request_id: z3.string().optional()
+});
+var RelayProgressMessageSchema = z3.object({
+  type: z3.literal("relay_progress"),
+  id: z3.string().uuid(),
+  // request ID this progress relates to
+  progress: z3.number().min(0).max(100).optional(),
+  // optional percentage
+  message: z3.string().optional()
+  // optional status message
+});
+var RelayStartedMessageSchema = z3.object({
+  type: z3.literal("relay_started"),
+  id: z3.string().uuid(),
+  message: z3.string().optional()
+});
+var HeartbeatMessageSchema = z3.object({
+  type: z3.literal("heartbeat"),
+  owner: z3.string().min(1),
+  capacity: z3.object({
+    current_load: z3.number(),
+    max_concurrent: z3.number(),
+    queue_depth: z3.number()
+  }),
+  self_summary: z3.object({
+    capabilities: z3.array(z3.string()),
+    success_rate: z3.number(),
+    credit_balance: z3.number(),
+    total_completed: z3.number(),
+    provider_number: z3.number(),
+    reliability: z3.object({
+      current_streak: z3.number(),
+      repeat_hire_rate: z3.number(),
+      avg_feedback: z3.number()
+    })
+  })
+});
+var EscrowHoldMessageSchema = z3.object({
+  type: z3.literal("escrow_hold"),
+  consumer_agent_id: z3.string().min(1),
+  provider_agent_id: z3.string().min(1),
+  skill_id: z3.string().min(1),
+  amount: z3.number().positive(),
+  request_id: z3.string().uuid(),
+  signature: z3.string().optional(),
+  public_key: z3.string().optional()
+});
+var EscrowHoldConfirmedMessageSchema = z3.object({
+  type: z3.literal("escrow_hold_confirmed"),
+  request_id: z3.string(),
+  escrow_id: z3.string(),
+  hold_amount: z3.number(),
+  consumer_remaining: z3.number()
+});
+var EscrowSettleMessageSchema = z3.object({
+  type: z3.literal("escrow_settle"),
+  escrow_id: z3.string().min(1),
+  request_id: z3.string().uuid(),
+  success: z3.boolean(),
+  failure_reason: z3.enum(["bad_execution", "overload", "timeout", "auth_error", "not_found"]).optional(),
+  result_hash: z3.string().optional(),
+  signature: z3.string().optional(),
+  public_key: z3.string().optional(),
+  consumer_agent_id: z3.string().optional()
+});
+var EscrowSettledMessageSchema = z3.object({
+  type: z3.literal("escrow_settled"),
+  escrow_id: z3.string(),
+  request_id: z3.string(),
+  provider_earned: z3.number(),
+  network_fee: z3.number(),
+  consumer_remaining: z3.number(),
+  provider_balance: z3.number()
+});
+var BalanceSyncMessageSchema = z3.object({
+  type: z3.literal("balance_sync"),
+  agent_id: z3.string().min(1)
+});
+var BalanceSyncResponseMessageSchema = z3.object({
+  type: z3.literal("balance_sync_response"),
+  agent_id: z3.string(),
+  balance: z3.number()
+});
+var RelayMessageSchema = z3.discriminatedUnion("type", [
+  RegisterMessageSchema,
+  RegisteredMessageSchema,
+  RelayRequestMessageSchema,
+  IncomingRequestMessageSchema,
+  RelayResponseMessageSchema,
+  ResponseMessageSchema,
+  ErrorMessageSchema,
+  RelayProgressMessageSchema,
+  RelayStartedMessageSchema,
+  HeartbeatMessageSchema,
+  EscrowHoldMessageSchema,
+  EscrowHoldConfirmedMessageSchema,
+  EscrowSettleMessageSchema,
+  EscrowSettledMessageSchema,
+  BalanceSyncMessageSchema,
+  BalanceSyncResponseMessageSchema
+]);
+
+// src/relay/websocket-client.ts
+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 = randomUUID9();
+    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_started message to acknowledge that provider has started work.
+   *
+   * @param requestId - The relay request ID being processed.
+   * @param message - Optional status message.
+   */
+  sendStarted(requestId, message) {
+    this.send({
+      type: "relay_started",
+      id: requestId,
+      ...message ? { message } : {}
+    });
+  }
+  /**
+   * 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 while work is in-flight.
+   *
+   * @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 });
     }
-  }));
-  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
+  }
+  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;
+      }
     });
-  } 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);
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.pongTimeout) {
+      clearTimeout(this.pongTimeout);
+      this.pongTimeout = null;
     }
   }
-  return results;
-}
-async function requestViaRelay(relay, opts) {
+  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/gateway/relay-dispatch.ts
+async function requestViaTemporaryRelay(opts) {
+  const {
+    registryUrl,
+    owner,
+    token,
+    targetOwner,
+    targetAgentId,
+    cardId,
+    skillId,
+    params,
+    timeoutMs = 3e5
+  } = opts;
+  const requesterId = `${owner}:req:${randomUUID10()}`;
+  const relay = new RelayClient({
+    registryUrl,
+    owner: requesterId,
+    token,
+    card: {
+      spec_version: "1.0",
+      id: randomUUID10(),
+      owner: requesterId,
+      name: requesterId,
+      description: "Temporary relay requester",
+      level: 1,
+      inputs: [],
+      outputs: [],
+      pricing: { credits_per_call: 0 },
+      availability: { online: false }
+    },
+    onRequest: async () => ({
+      error: { code: -32601, message: "Temporary relay requester does not serve capabilities" }
+    }),
+    silent: true
+  });
   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
-    });
+    await relay.connect();
   } catch (err) {
+    relay.disconnect();
     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");
+    throw new AgentBnBError(`Relay connection failed: ${message}`, "RELAY_UNAVAILABLE");
+  }
+  try {
+    return await requestViaRelay(relay, {
+      targetOwner,
+      targetAgentId,
+      cardId,
+      skillId,
+      params,
+      requester: owner,
+      // actual owner for credit tracking on relay server
+      timeoutMs
+    });
+  } finally {
+    relay.disconnect();
   }
 }
 
 // src/autonomy/tiers.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 
 // src/autonomy/pending-requests.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 
 // src/cli/peers.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
@@ -3247,8 +4131,17 @@ function minMaxNormalize(values) {
   }
   return values.map((v) => (v - min) / (max - min));
 }
-function scorePeers(candidates, selfOwner) {
-  const eligible = candidates.filter((c) => c.card.owner !== selfOwner);
+function scorePeers(candidates, selfOwner, registryDb) {
+  const selfIdentity = registryDb ? resolveCanonicalIdentity(registryDb, selfOwner) : null;
+  const eligible = candidates.filter((c) => {
+    if (c.card.owner === selfOwner) return false;
+    if (!registryDb || !selfIdentity?.resolved) return true;
+    if (typeof c.card.agent_id === "string" && c.card.agent_id.length > 0) {
+      return c.card.agent_id !== selfIdentity.agent_id;
+    }
+    const peerIdentity = resolveCanonicalIdentity(registryDb, c.card.owner);
+    return !peerIdentity.resolved || peerIdentity.agent_id !== selfIdentity.agent_id;
+  });
   if (eligible.length === 0) return [];
   const successRates = eligible.map((c) => {
     if (c.skillMetadata?.success_rate !== void 0) {
@@ -3473,7 +4366,7 @@ function buildConductorCard(owner) {
   return CapabilityCardV2Schema.parse(card);
 }
 function registerConductorCard(db) {
-  const card = buildConductorCard();
+  const card = attachCanonicalAgentId(db, buildConductorCard());
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const existing = db.prepare("SELECT id FROM capability_cards WHERE id = ?").get(card.id);
   if (existing) {
@@ -3574,6 +4467,7 @@ async function executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, re
 async function orchestrate(opts) {
   const { subtasks, matches, gatewayToken, resolveAgentUrl, timeoutMs = 3e5, maxBudget, relayClient, requesterOwner } = opts;
   const startTime = Date.now();
+  const hardDeadline = startTime + timeoutMs;
   const teamMemberMap = /* @__PURE__ */ new Map();
   if (opts.team) {
     for (const member of opts.team.matched) {
@@ -3595,6 +4489,12 @@ async function orchestrate(opts) {
   const waves = computeWaves(subtasks);
   const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
   for (const wave of waves) {
+    const remainingWaveMs = hardDeadline - Date.now();
+    if (remainingWaveMs <= 0) {
+      errors.push(`Orchestration timed out after ${timeoutMs}ms`);
+      break;
+    }
+    const waveTimeoutMs = Math.max(1, Math.min(timeoutMs, remainingWaveMs));
     if (maxBudget !== void 0 && totalCredits >= maxBudget) {
       errors.push(`Budget exceeded: spent ${totalCredits} cr, max ${maxBudget} cr`);
       break;
@@ -3668,7 +4568,7 @@ async function orchestrate(opts) {
                 gatewayUrl,
                 gatewayToken,
                 items.map(({ _pt, ...item }) => item),
-                { timeoutMs }
+                { timeoutMs: waveTimeoutMs }
               );
               return items.map((item) => {
                 const res = batchResults.get(item.id);
@@ -3692,7 +4592,7 @@ async function orchestrate(opts) {
             } catch (batchErr) {
               return Promise.all(group.map(async (pt) => {
                 try {
-                  const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+                  const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
                   return { status: "fulfilled", value: res };
                 } catch (err) {
                   return { status: "rejected", reason: err };
@@ -3706,7 +4606,7 @@ async function orchestrate(opts) {
         batchPromises.push(
           (async () => {
             try {
-              const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+              const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
               return [{ status: "fulfilled", value: res }];
             } catch (err) {
               return [{ status: "rejected", reason: err }];
@@ -3719,7 +4619,7 @@ async function orchestrate(opts) {
       batchPromises.push(
         (async () => {
           try {
-            const res = await executeSingleTask(pt, gatewayToken, timeoutMs, requesterOwner, relayClient, resolveAgentUrl);
+            const res = await executeSingleTask(pt, gatewayToken, waveTimeoutMs, requesterOwner, relayClient, resolveAgentUrl);
             return [{ status: "fulfilled", value: res }];
           } catch (err) {
             return [{ status: "rejected", reason: err }];
@@ -3796,7 +4696,7 @@ var BudgetManager = class {
 };
 
 // src/conductor/team-formation.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 function selectByStrategy(matches, strategy) {
   if (matches.length === 0) return void 0;
   if (strategy === "balanced") {
@@ -3813,7 +4713,7 @@ function selectByStrategy(matches, strategy) {
 }
 async function formTeam(opts) {
   const { subtasks, strategy, db, conductorOwner, registryUrl } = opts;
-  const team_id = randomUUID12();
+  const team_id = randomUUID13();
   if (subtasks.length === 0) {
     return { team_id, strategy, matched: [], unrouted: [] };
   }
@@ -3909,6 +4809,7 @@ var ConductorMode = class {
    * @returns Execution result without latency_ms (added by SkillExecutor).
    */
   async execute(config, params, onProgress) {
+    const skillTimeoutMs = typeof config.timeout_ms === "number" ? config.timeout_ms : void 0;
     const conductorSkill = config.conductor_skill;
     if (conductorSkill !== "orchestrate" && conductorSkill !== "plan") {
       return {
@@ -3948,7 +4849,7 @@ var ConductorMode = class {
               decomposition_depth: decompositionDepth + 1,
               orchestration_depth: orchestrationDepth + 1
             },
-            timeoutMs: 3e4
+            timeoutMs: skillTimeoutMs ?? 3e4
           });
           if (Array.isArray(response)) {
             const validation = validateAndNormalizeSubtasks(response, {
@@ -4019,6 +4920,7 @@ var ConductorMode = class {
       matches: matchMap,
       gatewayToken: this.gatewayToken,
       resolveAgentUrl: this.resolveAgentUrl,
+      timeoutMs: skillTimeoutMs,
       maxBudget: this.maxBudget,
       team
     });
@@ -4042,18 +4944,18 @@ var ConductorMode = class {
 };
 
 // src/credit/escrow-receipt.ts
-import { z as z3 } from "zod";
-import { randomUUID as randomUUID13 } from "crypto";
-var EscrowReceiptSchema = z3.object({
-  requester_owner: z3.string().min(1),
-  requester_agent_id: z3.string().optional(),
-  requester_public_key: z3.string().min(1),
-  amount: z3.number().positive(),
-  card_id: z3.string().min(1),
-  skill_id: z3.string().optional(),
-  timestamp: z3.string(),
-  nonce: z3.string().uuid(),
-  signature: z3.string().min(1)
+import { z as z4 } from "zod";
+import { randomUUID as randomUUID14 } from "crypto";
+var EscrowReceiptSchema = z4.object({
+  requester_owner: z4.string().min(1),
+  requester_agent_id: z4.string().optional(),
+  requester_public_key: z4.string().min(1),
+  amount: z4.number().positive(),
+  card_id: z4.string().min(1),
+  skill_id: z4.string().optional(),
+  timestamp: z4.string(),
+  nonce: z4.string().uuid(),
+  signature: z4.string().min(1)
 });
 function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
   const escrowId = holdEscrow(db, opts.owner, opts.amount, opts.cardId);
@@ -4065,7 +4967,7 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
     card_id: opts.cardId,
     ...opts.skillId ? { skill_id: opts.skillId } : {},
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    nonce: randomUUID13()
+    nonce: randomUUID14()
   };
   const signature = signEscrowReceipt(receiptData, privateKey);
   const receipt = {
@@ -4075,36 +4977,56 @@ function createSignedEscrowReceipt(db, privateKey, publicKey, opts) {
   return { escrowId, receipt };
 }
 
+// src/credit/settlement.ts
+function settleProviderEarning(providerDb, providerOwner, receipt) {
+  const feeAmount = Math.floor(receipt.amount * NETWORK_FEE_RATE);
+  const providerAmount = receipt.amount - feeAmount;
+  recordEarning(
+    providerDb,
+    providerOwner,
+    providerAmount,
+    receipt.card_id,
+    receipt.nonce
+  );
+  return { settled: true };
+}
+function settleRequesterEscrow(requesterDb, escrowId) {
+  confirmEscrowDebit(requesterDb, escrowId);
+}
+function releaseRequesterEscrow(requesterDb, escrowId) {
+  releaseEscrow(requesterDb, escrowId);
+}
+
 // src/identity/identity.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 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({
+var AgentIdentitySchema = z5.object({
   /** Deterministic ID derived from public key: sha256(hex).slice(0, 16). */
-  agent_id: z4.string().min(1),
+  agent_id: z5.string().min(1),
   /** Human-readable owner name (from config or init). */
-  owner: z4.string().min(1),
+  owner: z5.string().min(1),
   /** Hex-encoded Ed25519 public key. */
-  public_key: z4.string().min(1),
+  public_key: z5.string().min(1),
   /** ISO 8601 timestamp of identity creation. */
-  created_at: z4.string().datetime(),
+  created_at: z5.string().datetime(),
   /** Optional guarantor info if linked to a human. */
-  guarantor: z4.object({
-    github_login: z4.string().min(1),
-    verified_at: z4.string().datetime()
+  guarantor: z5.object({
+    github_login: z5.string().min(1),
+    verified_at: z5.string().datetime()
   }).optional()
 });
-var AgentCertificateSchema = z4.object({
+var AgentCertificateSchema = z5.object({
   identity: AgentIdentitySchema,
   /** ISO 8601 timestamp of certificate issuance. */
-  issued_at: z4.string().datetime(),
+  issued_at: z5.string().datetime(),
   /** ISO 8601 timestamp of certificate expiry. */
-  expires_at: z4.string().datetime(),
+  expires_at: z5.string().datetime(),
   /** Hex-encoded public key of the issuer (same as identity for self-signed). */
-  issuer_public_key: z4.string().min(1),
+  issuer_public_key: z5.string().min(1),
   /** Base64url Ed25519 signature over { identity, issued_at, expires_at, issuer_public_key }. */
-  signature: z4.string().min(1)
+  signature: z5.string().min(1)
 });
 var IDENTITY_FILENAME = "identity.json";
 var PRIVATE_KEY_FILENAME = "private.key";
@@ -4293,6 +5215,34 @@ var AgentBnBConsumer = class {
     return this.identity;
   }
   /**
+   * Requests a paid capability via the relay. The relay handles escrow + network fee
+   * server-side, avoiding the fee bypass bug in the signed receipt path.
+   *
+   * @param opts - Relay request options.
+   * @returns The result from the capability execution.
+   * @throws {AgentBnBError} on relay connection failure or execution error.
+   */
+  async requestViaRelay(opts) {
+    const identity = this.getIdentity();
+    const config = loadConfig();
+    const token = config?.token ?? "";
+    return requestViaTemporaryRelay({
+      registryUrl: opts.registryUrl,
+      owner: identity.owner,
+      token,
+      targetOwner: opts.targetOwner,
+      targetAgentId: opts.targetAgentId,
+      cardId: opts.cardId,
+      skillId: opts.skillId,
+      params: opts.params ?? {},
+      timeoutMs: opts.timeoutMs
+    });
+  }
+  /**
+   * @deprecated Use `requestViaRelay()` for paid remote requests. This method uses
+   * local escrow + signed receipts which bypass the network fee. Still works for
+   * free/local requests.
+   *
    * Requests a capability from a remote agent with full escrow lifecycle.
    *
    * 1. Creates a signed escrow receipt (holds credits locally)
@@ -4327,6 +5277,10 @@ var AgentBnBConsumer = class {
         cardId: opts.cardId,
         params: opts.params,
         timeoutMs: opts.timeoutMs,
+        timeoutHint: {
+          expected_duration_ms: opts.expectedDurationMs,
+          hard_timeout_ms: opts.providerHardTimeoutMs
+        },
         escrowReceipt: receipt,
         identity: {
           agentId: identity.agent_id,
@@ -4507,16 +5461,16 @@ var AgentBnBProvider = class {
 };
 
 // src/identity/guarantor.ts
-import { z as z5 } from "zod";
-import { randomUUID as randomUUID14 } from "crypto";
+import { z as z6 } from "zod";
+import { randomUUID as randomUUID15 } from "crypto";
 var MAX_AGENTS_PER_GUARANTOR = 10;
 var GUARANTOR_CREDIT_POOL = 50;
-var GuarantorRecordSchema = z5.object({
-  id: z5.string().uuid(),
-  github_login: z5.string().min(1),
-  agent_count: z5.number().int().nonnegative(),
-  credit_pool: z5.number().int().nonnegative(),
-  created_at: z5.string().datetime()
+var GuarantorRecordSchema = z6.object({
+  id: z6.string().uuid(),
+  github_login: z6.string().min(1),
+  agent_count: z6.number().int().nonnegative(),
+  credit_pool: z6.number().int().nonnegative(),
+  created_at: z6.string().datetime()
 });
 var GUARANTOR_SCHEMA = `
   CREATE TABLE IF NOT EXISTS guarantors (
@@ -4547,7 +5501,7 @@ function registerGuarantor(db, githubLogin) {
     );
   }
   const record = {
-    id: randomUUID14(),
+    id: randomUUID15(),
     github_login: githubLogin,
     agent_count: 0,
     credit_pool: GUARANTOR_CREDIT_POOL,
@@ -4621,12 +5575,12 @@ function getAgentGuarantor(db, agentId) {
 function initiateGithubAuth() {
   return {
     auth_url: "https://github.com/login/oauth/authorize?client_id=PLACEHOLDER&scope=read:user",
-    state: randomUUID14()
+    state: randomUUID15()
   };
 }
 
 // src/relay/websocket-relay.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 
 // src/relay/relay-credit.ts
 function lookupCardPrice(registryDb, cardId, skillId) {
@@ -4724,7 +5678,9 @@ function processEscrowSettle(creditDb, escrowId, success, providerAgentId, signa
       throw new Error("Invalid consumer signature on escrow settle");
     }
   }
-  const escrowRow = creditDb.prepare("SELECT amount, owner FROM credit_escrow WHERE id = ? AND status = ?").get(escrowId, "held");
+  const escrowRow = creditDb.prepare(
+    "SELECT amount, owner FROM credit_escrow WHERE id = ? AND status IN ('held', 'started', 'progressing', 'abandoned')"
+  ).get(escrowId);
   if (!escrowRow) {
     throw new Error(`Escrow not found or already settled: ${escrowId}`);
   }
@@ -4756,10 +5712,10 @@ function settleWithNetworkFee(creditDb, escrowId, providerOwner) {
 }
 
 // src/hub-agent/relay-bridge.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 
 // src/hub-agent/job-queue.ts
-import { randomUUID as randomUUID15 } from "crypto";
+import { randomUUID as randomUUID16 } from "crypto";
 function updateJobStatus(db, jobId, status, result) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (result !== void 0) {
@@ -4799,7 +5755,16 @@ function handleJobRelayResponse(opts) {
 // src/relay/websocket-relay.ts
 var RATE_LIMIT_MAX = 60;
 var RATE_LIMIT_WINDOW_MS = 6e4;
-var RELAY_TIMEOUT_MS = 3e5;
+var RELAY_IDLE_TIMEOUT_MS = 3e4;
+var RELAY_HARD_TIMEOUT_MS = 3e5;
+var RELAY_DISCONNECT_GRACE_MS = RELAY_HARD_TIMEOUT_MS + 3e4;
+function readTimeoutOverride(envKey, fallbackMs) {
+  const raw = process.env[envKey];
+  if (!raw) return fallbackMs;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallbackMs;
+  return Math.floor(parsed);
+}
 function registerWebSocketRelay(server, db, creditDb) {
   const connections = /* @__PURE__ */ new Map();
   const agentIdToOwner = /* @__PURE__ */ new Map();
@@ -4813,6 +5778,136 @@ function registerWebSocketRelay(server, db, creditDb) {
     if (connections.has(target)) return target;
     return void 0;
   }
+  function clearPendingTimers(pending) {
+    clearTimeout(pending.timeout);
+    if (pending.idleTimeout) clearTimeout(pending.idleTimeout);
+    if (pending.hardTimeout) clearTimeout(pending.hardTimeout);
+    if (pending.graceTimeout) clearTimeout(pending.graceTimeout);
+  }
+  function setPendingTimer(pending, timerType, timer) {
+    const existing = pending[timerType];
+    if (existing) clearTimeout(existing);
+    pending[timerType] = timer;
+    pending.timeout = timer;
+  }
+  function scheduleIdleTimeout(requestId, pending) {
+    const timeoutMs = readTimeoutOverride("AGENTBNB_RELAY_IDLE_TIMEOUT_MS", RELAY_IDLE_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      const current = pendingRequests.get(requestId);
+      if (!current || (current.lifecycle ?? "held") !== "held") return;
+      pendingRequests.delete(requestId);
+      clearPendingTimers(current);
+      if (current.escrowId && creditDb) {
+        try {
+          releaseForRelay(creditDb, current.escrowId);
+        } catch (e) {
+          console.error("[relay] escrow release on idle timeout failed:", e);
+        }
+      }
+      const originWs = connections.get(current.originOwner);
+      if (originWs && originWs.readyState === 1) {
+        sendMessage(originWs, {
+          type: "response",
+          id: requestId,
+          error: { code: -32603, message: "Relay request timeout" }
+        });
+      }
+    }, timeoutMs);
+    setPendingTimer(pending, "idleTimeout", timer);
+  }
+  function scheduleHardTimeout(requestId, pending) {
+    const timeoutMs = readTimeoutOverride("AGENTBNB_RELAY_HARD_TIMEOUT_MS", RELAY_HARD_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      const current = pendingRequests.get(requestId);
+      if (!current || current.lifecycle === "abandoned") return;
+      pendingRequests.delete(requestId);
+      clearPendingTimers(current);
+      if (current.escrowId && creditDb) {
+        try {
+          releaseForRelay(creditDb, current.escrowId);
+        } catch (e) {
+          console.error("[relay] escrow release on hard timeout failed:", e);
+        }
+      }
+      const originWs = connections.get(current.originOwner);
+      if (originWs && originWs.readyState === 1) {
+        sendMessage(originWs, {
+          type: "response",
+          id: requestId,
+          error: { code: -32603, message: "Relay request timeout" }
+        });
+      }
+    }, timeoutMs);
+    setPendingTimer(pending, "hardTimeout", timer);
+  }
+  function scheduleGraceTimeout(requestId, pending) {
+    const timeoutMs = readTimeoutOverride(
+      "AGENTBNB_RELAY_DISCONNECT_GRACE_MS",
+      RELAY_DISCONNECT_GRACE_MS
+    );
+    const timer = setTimeout(() => {
+      const current = pendingRequests.get(requestId);
+      if (!current || current.lifecycle !== "abandoned") return;
+      pendingRequests.delete(requestId);
+      clearPendingTimers(current);
+      if (current.escrowId && creditDb) {
+        try {
+          releaseForRelay(creditDb, current.escrowId);
+        } catch (e) {
+          console.error("[relay] escrow release after grace timeout failed:", e);
+        }
+      }
+    }, timeoutMs);
+    setPendingTimer(pending, "graceTimeout", timer);
+  }
+  function transitionPendingToStarted(requestId, pending) {
+    if (pending.lifecycle === "started" || pending.lifecycle === "progressing" || pending.lifecycle === "abandoned") {
+      return;
+    }
+    pending.lifecycle = "started";
+    pending.startedAt = Date.now();
+    if (pending.idleTimeout) clearTimeout(pending.idleTimeout);
+    if (pending.graceTimeout) clearTimeout(pending.graceTimeout);
+    if (pending.escrowId && creditDb) {
+      try {
+        markEscrowStarted(creditDb, pending.escrowId);
+      } catch (e) {
+        console.error("[relay] escrow transition to started failed:", e);
+      }
+    }
+    scheduleHardTimeout(requestId, pending);
+  }
+  function transitionPendingToProgressing(requestId, pending) {
+    if (pending.lifecycle === "abandoned") {
+      return;
+    }
+    if ((pending.lifecycle ?? "held") === "held") {
+      transitionPendingToStarted(requestId, pending);
+    }
+    pending.lifecycle = "progressing";
+    if (pending.escrowId && creditDb) {
+      try {
+        markEscrowProgressing(creditDb, pending.escrowId);
+      } catch (e) {
+        console.error("[relay] escrow transition to progressing failed:", e);
+      }
+    }
+  }
+  function transitionPendingToAbandoned(requestId, pending) {
+    if (pending.lifecycle === "abandoned") return;
+    pending.lifecycle = "abandoned";
+    pending.abandonedAt = Date.now();
+    if (pending.idleTimeout) clearTimeout(pending.idleTimeout);
+    if (pending.hardTimeout) clearTimeout(pending.hardTimeout);
+    if (pending.escrowId && creditDb) {
+      try {
+        markEscrowAbandoned(creditDb, pending.escrowId);
+      } catch (e) {
+        console.error("[relay] escrow transition to abandoned failed:", e);
+      }
+    }
+    scheduleGraceTimeout(requestId, pending);
+  }
   function checkRateLimit(owner) {
     const now = Date.now();
     const entry = rateLimits.get(owner);
@@ -4862,15 +5957,20 @@ function registerWebSocketRelay(server, db, creditDb) {
     } catch {
     }
   }
-  function upsertCard(cardData, owner) {
-    const parsed = AnyCardSchema.safeParse(cardData);
+  function upsertCard(cardData, owner, agentId) {
+    const parsed = AnyCardSchema.safeParse(
+      agentId ? { ...cardData, agent_id: agentId } : cardData
+    );
     if (!parsed.success) {
       throw new AgentBnBError(
         `Card validation failed: ${parsed.error.message}`,
         "VALIDATION_ERROR"
       );
     }
-    const card = { ...parsed.data, availability: { ...parsed.data.availability, online: true } };
+    const card = attachCanonicalAgentId(db, {
+      ...parsed.data,
+      availability: { ...parsed.data.availability, online: true }
+    });
     const cardId = card.id;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const existing = db.prepare("SELECT id FROM capability_cards WHERE id = ?").get(cardId);
@@ -4888,7 +5988,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function logAgentJoined(owner, cardName, cardId) {
     try {
       insertRequestLog(db, {
-        id: randomUUID17(),
+        id: randomUUID18(),
         card_id: cardId,
         card_name: cardName,
         requester: owner,
@@ -4924,7 +6024,7 @@ function registerWebSocketRelay(server, db, creditDb) {
         agentIdToOwner.set(agentEntry.agent_id, owner);
         for (const agentCard of agentEntry.cards) {
           try {
-            upsertCard(agentCard, owner);
+            upsertCard(agentCard, owner, agentEntry.agent_id);
           } catch {
           }
         }
@@ -4938,7 +6038,7 @@ function registerWebSocketRelay(server, db, creditDb) {
     }
     let cardId;
     try {
-      cardId = upsertCard(card, owner);
+      cardId = upsertCard(card, owner, msg.agent_id);
     } catch (err) {
       console.error(`[relay] card validation failed for ${owner}:`, err instanceof Error ? err.message : err);
       cardId = card.id ?? owner;
@@ -4948,7 +6048,7 @@ function registerWebSocketRelay(server, db, creditDb) {
     if (msg.cards && msg.cards.length > 0) {
       for (const extraCard of msg.cards) {
         try {
-          upsertCard(extraCard, owner);
+          upsertCard(extraCard, owner, msg.agent_id);
         } catch {
         }
       }
@@ -5003,23 +6103,17 @@ function registerWebSocketRelay(server, db, creditDb) {
         console.error("[relay] credit hold error (non-fatal):", err);
       }
     }
-    const timeout = setTimeout(() => {
-      const pending = pendingRequests.get(msg.id);
-      pendingRequests.delete(msg.id);
-      if (pending?.escrowId && creditDb) {
-        try {
-          releaseForRelay(creditDb, pending.escrowId);
-        } catch (e) {
-          console.error("[relay] escrow release on timeout failed:", e);
-        }
-      }
-      sendMessage(ws, {
-        type: "response",
-        id: msg.id,
-        error: { code: -32603, message: "Relay request timeout" }
-      });
-    }, RELAY_TIMEOUT_MS);
-    pendingRequests.set(msg.id, { originOwner: fromOwner, creditOwner, timeout, escrowId, targetOwner: msg.target_owner });
+    const pending = {
+      originOwner: fromOwner,
+      creditOwner,
+      timeout: setTimeout(() => void 0, 1),
+      escrowId,
+      targetOwner: targetKey ?? msg.target_owner,
+      lifecycle: "held",
+      createdAt: Date.now()
+    };
+    pendingRequests.set(msg.id, pending);
+    scheduleIdleTimeout(msg.id, pending);
     sendMessage(targetWs, {
       type: "incoming_request",
       id: msg.id,
@@ -5031,30 +6125,23 @@ function registerWebSocketRelay(server, db, creditDb) {
       escrow_receipt: msg.escrow_receipt
     });
   }
+  function handleRelayStarted(msg) {
+    const pending = pendingRequests.get(msg.id);
+    if (!pending) return;
+    transitionPendingToStarted(msg.id, pending);
+    const originWs = connections.get(pending.originOwner);
+    if (originWs && originWs.readyState === 1) {
+      sendMessage(originWs, {
+        type: "relay_started",
+        id: msg.id,
+        message: msg.message
+      });
+    }
+  }
   function handleRelayProgress(msg) {
     const pending = pendingRequests.get(msg.id);
     if (!pending) return;
-    clearTimeout(pending.timeout);
-    const newTimeout = setTimeout(() => {
-      const p = pendingRequests.get(msg.id);
-      pendingRequests.delete(msg.id);
-      if (p?.escrowId && creditDb) {
-        try {
-          releaseForRelay(creditDb, p.escrowId);
-        } catch (e) {
-          console.error("[relay] escrow release on progress timeout failed:", e);
-        }
-      }
-      const originWs2 = connections.get(pending.originOwner);
-      if (originWs2 && originWs2.readyState === 1) {
-        sendMessage(originWs2, {
-          type: "response",
-          id: msg.id,
-          error: { code: -32603, message: "Relay request timeout" }
-        });
-      }
-    }, RELAY_TIMEOUT_MS);
-    pending.timeout = newTimeout;
+    transitionPendingToProgressing(msg.id, pending);
     const originWs = connections.get(pending.originOwner);
     if (originWs && originWs.readyState === 1) {
       sendMessage(originWs, {
@@ -5068,7 +6155,7 @@ function registerWebSocketRelay(server, db, creditDb) {
   function handleRelayResponse(msg) {
     const pending = pendingRequests.get(msg.id);
     if (!pending) return;
-    clearTimeout(pending.timeout);
+    clearPendingTimers(pending);
     pendingRequests.delete(msg.id);
     if (pending.jobId && creditDb) {
       try {
@@ -5131,16 +6218,15 @@ function registerWebSocketRelay(server, db, creditDb) {
     connections.delete(owner);
     rateLimits.delete(owner);
     agentCapacities.delete(owner);
-    for (const [agentId, o] of agentIdToOwner) {
-      if (o === owner) {
+    for (const [agentId, mappedOwner] of Array.from(agentIdToOwner.entries())) {
+      if (mappedOwner === owner) {
         agentIdToOwner.delete(agentId);
-        break;
       }
     }
     markOwnerOffline(owner);
     for (const [reqId, pending] of pendingRequests) {
       if (pending.targetOwner === owner) {
-        clearTimeout(pending.timeout);
+        clearPendingTimers(pending);
         pendingRequests.delete(reqId);
         if (pending.escrowId && creditDb) {
           try {
@@ -5158,14 +6244,19 @@ function registerWebSocketRelay(server, db, creditDb) {
           });
         }
       } else if (pending.originOwner === owner) {
-        clearTimeout(pending.timeout);
-        pendingRequests.delete(reqId);
-        if (pending.escrowId && creditDb) {
-          try {
-            releaseForRelay(creditDb, pending.escrowId);
-          } catch (e) {
-            console.error("[relay] escrow release on requester disconnect failed:", e);
+        const lifecycle = pending.lifecycle ?? "held";
+        if (lifecycle === "held") {
+          clearPendingTimers(pending);
+          pendingRequests.delete(reqId);
+          if (pending.escrowId && creditDb) {
+            try {
+              releaseForRelay(creditDb, pending.escrowId);
+            } catch (e) {
+              console.error("[relay] escrow release on requester disconnect failed:", e);
+            }
           }
+        } else {
+          transitionPendingToAbandoned(reqId, pending);
         }
       }
     }
@@ -5208,7 +6299,9 @@ function registerWebSocketRelay(server, db, creditDb) {
       return;
     }
     try {
-      const escrow = creditDb.prepare("SELECT card_id FROM credit_escrow WHERE id = ? AND status = ?").get(msg.escrow_id, "held");
+      const escrow = creditDb.prepare(
+        "SELECT card_id FROM credit_escrow WHERE id = ? AND status IN ('held', 'started', 'progressing', 'abandoned')"
+      ).get(msg.escrow_id);
       if (!escrow) {
         sendMessage(ws, { type: "error", code: "escrow_not_found", message: `Escrow not found: ${msg.escrow_id}`, request_id: msg.request_id });
         return;
@@ -5305,6 +6398,9 @@ function registerWebSocketRelay(server, db, creditDb) {
             case "relay_response":
               handleRelayResponse(msg);
               break;
+            case "relay_started":
+              handleRelayStarted(msg);
+              break;
             case "relay_progress":
               handleRelayProgress(msg);
               break;
@@ -5351,7 +6447,7 @@ function registerWebSocketRelay(server, db, creditDb) {
       }
       connections.clear();
       for (const [, pending] of pendingRequests) {
-        clearTimeout(pending.timeout);
+        clearPendingTimers(pending);
       }
       pendingRequests.clear();
       rateLimits.clear();
@@ -5371,12 +6467,12 @@ function registerWebSocketRelay(server, db, creditDb) {
 }
 
 // src/onboarding/index.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join5 } from "path";
 
 // src/cli/onboarding.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 import { createConnection } from "net";
 var KNOWN_API_KEYS = [
   "OPENAI_API_KEY",
@@ -5518,7 +6614,7 @@ function capabilitiesToV2Card(capabilities, owner, agentName) {
   }));
   const card = {
     spec_version: "2.0",
-    id: randomUUID19(),
+    id: randomUUID20(),
     owner,
     agent_name: agentName ?? owner,
     skills,