@lawrenceliang-btc/atel-sdk 1.1.41 → 1.1.43

package/bin/atel.mjs

@@ -9,7 +9,7 @@
  *   atel start [port]                   Start endpoint (auto network + auto register)
  *   atel setup [port]                   Network setup only (detect IP, UPnP, verify)
  *   atel verify                         Verify port reachability
- *   atel inbox [count]                  Show received messages
+ *   atel inbox [count]                  Show received messages / notifications
  *   atel register [name] [caps] [url]   Register on public registry
  *   atel search <capability>            Search registry for agents
  *   atel handshake <endpoint> [did]     Handshake with a remote agent
@@ -79,6 +79,7 @@ const REGISTRY_URL = process.env.ATEL_REGISTRY || ATEL_PLATFORM || 'https://api.
 const ATEL_RELAY = process.env.ATEL_RELAY || 'https://api.atelai.org';
 const ATEL_NOTIFY_GATEWAY = process.env.ATEL_NOTIFY_GATEWAY || process.env.OPENCLAW_GATEWAY_URL || '';
 const ATEL_NOTIFY_TARGET = process.env.ATEL_NOTIFY_TARGET || '';
+const ATEL_NOTIFY_AUTO_BIND = /^(1|true|yes)$/i.test(String(process.env.ATEL_NOTIFY_AUTO_BIND || ''));
 let EXECUTOR_URL = process.env.ATEL_EXECUTOR_URL || '';
 const INBOX_FILE = resolve(ATEL_DIR, 'inbox.jsonl');
 const POLICY_FILE = resolve(ATEL_DIR, 'policy.json');
@@ -90,6 +91,9 @@ const TRACES_DIR = resolve(ATEL_DIR, 'traces');
 const PENDING_FILE = resolve(ATEL_DIR, 'pending-tasks.json');
 const RESULT_PUSH_QUEUE_FILE = resolve(ATEL_DIR, 'pending-result-pushes.json');
 const NOTIFY_TARGETS_FILE = resolve(ATEL_DIR, 'notify-targets.json');
+const NOTIFY_ROUTES_FILE = resolve(ATEL_DIR, 'notify-routes.json');
+const TELEGRAM_UPDATES_STATE_FILE = resolve(process.env.HOME || '/root', '.openclaw', 'deploy', 'sdk-telegram-updates.json');
+const TELEGRAM_BINDINGS_FILE = resolve(process.env.HOME || '/root', '.openclaw', 'deploy', 'sdk-telegram-bindings.json');
 const TRADE_TRACK_FILE = resolve(ATEL_DIR, 'tracked-orders.json');
 const P2P_STATUS_FILE = resolve(ATEL_DIR, 'p2p-task-status.jsonl');
 const PENDING_AGENT_CALLBACKS_FILE = resolve(ATEL_DIR, 'pending-agent-callbacks.json');
@@ -222,6 +226,96 @@ function saveNotifyTargets(data) {
   writeFileSync(NOTIFY_TARGETS_FILE, JSON.stringify(data, null, 2));
 }
 
+function loadNotifyRoutes() {
+  try { return JSON.parse(readFileSync(NOTIFY_ROUTES_FILE, 'utf-8')); }
+  catch { return { version: 1, defaultTelegram: null, orderBindings: {} }; }
+}
+
+function saveNotifyRoutes(data) {
+  ensureDir();
+  writeFileSync(NOTIFY_ROUTES_FILE, JSON.stringify(data, null, 2));
+}
+
+function getPrimaryTelegramTarget() {
+  const targets = loadNotifyTargets();
+  return (targets.targets || []).find((target) => target && target.enabled !== false && target.channel === 'telegram' && target.target) || null;
+}
+
+function rememberTelegramRoute(chatId, botToken, orderId = '') {
+  const normalizedChatId = String(chatId || '').trim();
+  if (!normalizedChatId) return false;
+  const routes = loadNotifyRoutes();
+  const updatedAt = new Date().toISOString();
+  const nextDefault = { chatId: normalizedChatId, updatedAt };
+  if (botToken) nextDefault.botToken = botToken;
+  routes.defaultTelegram = nextDefault;
+  if (!routes.orderBindings || typeof routes.orderBindings !== 'object') routes.orderBindings = {};
+  if (orderId) {
+    routes.orderBindings[orderId] = { chatId: normalizedChatId, updatedAt };
+    if (botToken) routes.orderBindings[orderId].botToken = botToken;
+  }
+  saveNotifyRoutes(routes);
+  return true;
+}
+
+function rememberCurrentTelegramRoute(orderId = '') {
+  if (!String(process.env.OPENCLAW_SHELL || '').trim()) return false;
+  let chatId = discoverTelegramChat();
+  let botToken = discoverTelegramBot();
+  if (!chatId) {
+    const primary = getPrimaryTelegramTarget();
+    if (primary?.target) {
+      chatId = primary.target;
+      botToken = botToken || primary.botToken;
+    }
+  }
+  if (!chatId) return false;
+  return rememberTelegramRoute(chatId, botToken, orderId);
+}
+
+function dropTelegramRoute(orderId = '') {
+  if (!orderId) return false;
+  const routes = loadNotifyRoutes();
+  if (!routes.orderBindings || !routes.orderBindings[orderId]) return false;
+  delete routes.orderBindings[orderId];
+  saveNotifyRoutes(routes);
+  return true;
+}
+
+function resolveNotifyTargets(orderId = '') {
+  const targets = loadNotifyTargets();
+  let enabled = (targets.targets || []).filter(t => t.enabled !== false);
+  const routes = loadNotifyRoutes();
+  const primary = getPrimaryTelegramTarget();
+  const preferred = (orderId && routes.orderBindings && routes.orderBindings[orderId]) || routes.defaultTelegram || (primary ? { chatId: String(primary.target), botToken: primary.botToken, updatedAt: primary.lastUsedAt || primary.createdAt || new Date().toISOString() } : null);
+  if (!preferred?.chatId) return { targets, enabled };
+  let hasTelegram = false;
+  enabled = enabled.map((target) => {
+    if (target.channel !== 'telegram') return target;
+    hasTelegram = true;
+    return {
+      ...target,
+      target: String(preferred.chatId),
+      botToken: preferred.botToken || target.botToken,
+      routeSource: orderId && routes.orderBindings && routes.orderBindings[orderId] ? 'order' : 'default',
+    };
+  });
+  if (!hasTelegram) {
+    enabled = [{
+      id: `tg_${preferred.chatId}`,
+      channel: 'telegram',
+      target: String(preferred.chatId),
+      botToken: preferred.botToken || discoverTelegramBot() || undefined,
+      label: orderId ? `order:${orderId}` : 'owner',
+      enabled: true,
+      createdAt: preferred.updatedAt || new Date().toISOString(),
+      lastUsedAt: null,
+      routeSource: orderId && routes.orderBindings && routes.orderBindings[orderId] ? 'order' : 'default',
+    }, ...enabled];
+  }
+  return { targets, enabled };
+}
+
 // Auto-detect current TG chat from OpenClaw session state
 function discoverTelegramChat() {
   const sessionPaths = [
@@ -252,10 +346,11 @@ function autoBindNotifications() {
   const targets = loadNotifyTargets();
   if (targets.targets.length > 0) return; // already has targets
 
-  const chatId = discoverTelegramChat();
+  const routes = loadNotifyRoutes();
+  const chatId = routes.defaultTelegram?.chatId || discoverTelegramChat();
   if (!chatId) return;
 
-  const botToken = discoverTelegramBot();
+  const botToken = routes.defaultTelegram?.botToken || discoverTelegramBot();
   const id = `tg_${chatId}`;
   targets.targets.push({
     id, channel: 'telegram', target: chatId,
@@ -264,6 +359,7 @@ function autoBindNotifications() {
     createdAt: new Date().toISOString(), lastUsedAt: null,
   });
   saveNotifyTargets(targets);
+  rememberTelegramRoute(chatId, botToken || undefined);
   console.log(`🔔 Auto-bound TG notifications to chat ${chatId}`);
 }
 
@@ -305,80 +401,324 @@ function discoverTelegramBot() {
   // Also check env
 }
 
+function loadTelegramUpdatesState() {
+  try { return JSON.parse(readFileSync(TELEGRAM_UPDATES_STATE_FILE, 'utf-8')); }
+  catch { return { version: 1, cursors: {}, leaders: {} }; }
+}
+
+function saveTelegramUpdatesState(data) {
+  ensureDir();
+  writeFileSync(TELEGRAM_UPDATES_STATE_FILE, JSON.stringify(data, null, 2));
+}
+
+function loadTelegramBindings() {
+  try { return JSON.parse(readFileSync(TELEGRAM_BINDINGS_FILE, 'utf-8')); }
+  catch { return { version: 1, bindings: {} }; }
+}
+
+function saveTelegramBindings(data) {
+  mkdirSync(dirname(TELEGRAM_BINDINGS_FILE), { recursive: true });
+  writeFileSync(TELEGRAM_BINDINGS_FILE, JSON.stringify(data, null, 2));
+}
+
+function registerTelegramInboundBinding(did, config) {
+  if (!did || !config?.cursorKey || !config?.chatId) return { ownerDid: '', rebound: false };
+  const data = loadTelegramBindings();
+  if (!data.bindings || typeof data.bindings !== 'object') data.bindings = {};
+  const key = config.cursorKey;
+  const current = data.bindings[key];
+  const ownerDid = String(current?.ownerDid || '').trim();
+  if (ownerDid && ownerDid !== did) {
+    return { ownerDid, rebound: false };
+  }
+  data.bindings[key] = {
+    chatId: config.chatId,
+    botId: config.botId,
+    ownerDid: did,
+    updatedAt: new Date().toISOString(),
+  };
+  saveTelegramBindings(data);
+  return { ownerDid: did, rebound: true };
+}
+
+function acquireTelegramInboundLeader(did, config) {
+  const state = loadTelegramUpdatesState();
+  if (!state.leaders || typeof state.leaders !== 'object') state.leaders = {};
+  const now = Date.now();
+  const leaseMs = 15000;
+  const current = state.leaders[config.cursorKey];
+  if (current && current.did && current.did !== did && Number(current.expiresAt || 0) > now) {
+    return { leader: current.did, acquired: false };
+  }
+  state.leaders[config.cursorKey] = { did, expiresAt: now + leaseMs, updatedAt: new Date().toISOString() };
+  saveTelegramUpdatesState(state);
+  return { leader: did, acquired: true };
+}
+
+function getTelegramInboundConfig() {
+  const routes = loadNotifyRoutes();
+  const primary = getPrimaryTelegramTarget();
+  const chatId = String(routes.defaultTelegram?.chatId || primary?.target || '').trim();
+  const botToken = String(routes.defaultTelegram?.botToken || primary?.botToken || discoverTelegramBot() || '').trim();
+  if (!chatId || !botToken) return null;
+  const botId = botToken.split(':', 1)[0] || 'telegram';
+  return { chatId, botToken, botId, cursorKey: `${botId}:${chatId}` };
+}
+
+function extractTelegramInboundPayload(update) {
+  const msg = update?.message || update?.edited_message;
+  if (!msg || msg?.from?.is_bot) return null;
+  const chatId = String(msg?.chat?.id || '').trim();
+  const text = typeof msg?.text === 'string' && msg.text.trim()
+    ? msg.text.trim()
+    : (typeof msg?.caption === 'string' && msg.caption.trim() ? msg.caption.trim() : '');
+  if (!chatId || !text) return null;
+  const nameParts = [];
+  if (typeof msg?.from?.username === 'string' && msg.from.username.trim()) nameParts.push(`@${msg.from.username.trim()}`);
+  if (typeof msg?.from?.first_name === 'string' && msg.from.first_name.trim()) nameParts.push(msg.from.first_name.trim());
+  if (typeof msg?.from?.last_name === 'string' && msg.from.last_name.trim()) nameParts.push(msg.from.last_name.trim());
+  const unixTs = Number(msg?.date || update?.edited_message?.date || 0);
+  const occurredAt = unixTs > 0 ? new Date(unixTs * 1000).toISOString() : new Date().toISOString();
+  return {
+    chatId,
+    text,
+    occurredAt,
+    messageId: msg?.message_id ?? null,
+    senderName: nameParts.join(' ').trim(),
+  };
+}
+
+async function queueTelegramInboundMirror(targetDid, config, update) {
+  const payload = extractTelegramInboundPayload(update);
+  if (!payload || payload.chatId !== config.chatId) return false;
+  const sender = `telegram:${payload.chatId}`;
+  const relayMessage = {
+    method: 'POST',
+    path: '/atel/v1/relay-message',
+    body: {
+      kind: 'telegram_message',
+      channel: 'telegram',
+      text: payload.text,
+      senderDid: sender,
+      timestamp: payload.occurredAt,
+      telegramChatId: payload.chatId,
+      telegramUpdateId: update?.update_id ?? null,
+      telegramMessageId: payload.messageId,
+      telegramSender: payload.senderName || '',
+    },
+  };
+  const resp = await fetch(`${ATEL_PLATFORM}/relay/v1/respond/${encodeURIComponent(targetDid)}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ sender, message: relayMessage }),
+    signal: AbortSignal.timeout(10000),
+  });
+  const raw = await resp.text().catch(() => '');
+  if (!resp.ok) throw new Error(`telegram_mirror_http_${resp.status}:${raw || 'unknown'}`);
+  log({ event: 'telegram_inbound_mirrored', did: targetDid, chatId: payload.chatId, updateId: update?.update_id ?? null, text: payload.text.slice(0, 120) });
+  return true;
+}
+
+async function mirrorTelegramInboundToBindings(config, update) {
+  const bindings = loadTelegramBindings();
+  const ownerDid = String(bindings.bindings?.[config.cursorKey]?.ownerDid || '').trim();
+  if (!ownerDid) return 0;
+  try {
+    return (await queueTelegramInboundMirror(ownerDid, config, update)) ? 1 : 0;
+  } catch (e) {
+    log({ event: 'telegram_inbound_mirror_error', did: ownerDid, chatId: config.chatId, updateId: update?.update_id ?? null, error: e.message || 'unknown_error' });
+    return 0;
+  }
+}
+
+async function pollTelegramInboundUpdates(targetDid) {
+  const config = getTelegramInboundConfig();
+  if (!config) return { status: 'noop' };
+
+  const binding = registerTelegramInboundBinding(targetDid, config);
+  if (binding.ownerDid && binding.ownerDid !== targetDid) {
+    return { status: 'follower', ownerDid: binding.ownerDid };
+  }
+
+  const leadership = acquireTelegramInboundLeader(targetDid, config);
+  if (!leadership.acquired) {
+    return { status: 'follower', leader: leadership.leader };
+  }
+
+  const state = loadTelegramUpdatesState();
+  if (!state.cursors || typeof state.cursors !== 'object') state.cursors = {};
+  const cursor = state.cursors[config.cursorKey] || {};
+  const nextUpdateId = Number(cursor.nextUpdateId || 0);
+  const params = new URLSearchParams({ timeout: '0', limit: '20' });
+  if (nextUpdateId > 0) params.set('offset', String(nextUpdateId));
+
+  const resp = await fetch(`https://api.telegram.org/bot${config.botToken}/getUpdates?${params.toString()}`, {
+    signal: AbortSignal.timeout(12000),
+  });
+  const data = await resp.json().catch(() => null);
+  if (!resp.ok || data?.ok === false) {
+    throw new Error(data?.description || `telegram_getUpdates_http_${resp.status}`);
+  }
+
+  const updates = Array.isArray(data?.result) ? data.result : [];
+  if (updates.length === 0) return { status: 'idle' };
+
+  let nextCursor = nextUpdateId;
+  for (const update of updates) {
+    const updateId = Number(update?.update_id || 0);
+    if (updateId > 0) nextCursor = Math.max(nextCursor, updateId + 1);
+  }
+
+  let effectiveUpdates = updates;
+  if (nextUpdateId === 0) {
+    effectiveUpdates = updates.slice(-1);
+    state.cursors[config.cursorKey] = {
+      nextUpdateId: nextCursor,
+      chatId: config.chatId,
+      botId: config.botId,
+      updatedAt: new Date().toISOString(),
+    };
+    saveTelegramUpdatesState(state);
+    log({ event: 'telegram_inbound_bootstrap', did: targetDid, chatId: config.chatId, skipped: Math.max(0, updates.length - effectiveUpdates.length), mirroredOnBootstrap: effectiveUpdates.length, nextUpdateId: nextCursor });
+  }
+
+  let mirrored = 0;
+  for (const update of effectiveUpdates) {
+    mirrored += await mirrorTelegramInboundToBindings(config, update);
+  }
+
+  state.cursors[config.cursorKey] = {
+    nextUpdateId: nextCursor,
+    chatId: config.chatId,
+    botId: config.botId,
+    updatedAt: new Date().toISOString(),
+  };
+  saveTelegramUpdatesState(state);
+  return { status: 'ok', mirrored, nextUpdateId: nextCursor };
+}
+
 // Send notification to all enabled targets (fire-and-forget, never blocks)
 async function pushTradeNotification(eventType, payload, body) {
-  const targets = loadNotifyTargets();
-  const enabled = (targets.targets || []).filter(t => t.enabled !== false);
+  const orderId = payload?.orderId || body?.orderId || '';
+  const { targets, enabled } = resolveNotifyTargets(orderId);
   if (enabled.length === 0) return;
 
-  const chainLabel = (p) => {
-    const c = p?.chain || body?.chain || '';
-    if (c === 'fast-coop') return ' (Fast)';
-    if (c === 'bsc') return ' (BSC)';
-    return '';
-  };
   const templates = {
-    'order_created': (p) => `📥 收到新订单\n订单: ${p.orderId || body?.orderId || '?'}\n金额: $${p.priceAmount ?? '?'} USDC${chainLabel(p)}\n来自: ${p.requesterDid || '未知请求方'}\n请审核后决定是否接单`,
-    'order_accepted': (p) => `📋 订单已被接单\n订单: ${p.orderId || body?.orderId || '?'}${chainLabel(p)}\n执行方已开始处理，进入里程碑阶段`,
+    'order_created': (p) => `📥 收到新订单
+订单: ${p.orderId || body?.orderId || '?'}
+金额: $${p.priceAmount ?? '?'} USDC
+来自: ${p.requesterDid || '未知请求方'}
+请审核后决定是否接单`,
+    'order_accepted': (p) => `📋 订单已被接单
+订单: ${p.orderId || body?.orderId || '?'}
+执行方已开始处理，进入里程碑阶段`,
+    'escrow_confirmed': (p) => `🔒 托管已确认
+订单: ${p.orderId || body?.orderId || '?'}
+链上托管已完成，等待里程碑方案确认`,
+    'milestone_plan_confirmed': (p) => {
+      const desc = p.milestoneDescription || p.nextMilestoneDescription || '';
+      const progress = p.totalMilestones ? `
+进度: 1/${p.totalMilestones}` : '';
+      return `🚀 里程碑方案已确认
+订单: ${p.orderId || body?.orderId || '?'}${desc ? `
+当前里程碑: ${desc}` : ''}${progress}`;
+    },
     'milestone_submitted': (p) => {
-      const desc = p.milestoneDescription ? `\n目标: ${p.milestoneDescription}` : '';
-      const content = p.resultSummary ? `\n提交内容: ${String(p.resultSummary).substring(0, 200)}` : '';
-      return `📝 里程碑 M${p.milestoneIndex ?? '?'} 已提交\n订单: ${p.orderId || body?.orderId || '?'}${desc}${content}\n等待审核`;
+      const desc = p.milestoneDescription ? `
+目标: ${p.milestoneDescription}` : '';
+      const content = p.resultSummary ? `
+提交内容: ${String(p.resultSummary).substring(0, 200)}` : '';
+      return `📝 里程碑 M${p.milestoneIndex ?? '?'} 已提交
+订单: ${p.orderId || body?.orderId || '?'}${desc}${content}
+等待审核`;
     },
     'milestone_verified': (p) => {
-      const desc = p.milestoneDescription ? `\n目标: ${p.milestoneDescription}` : '';
-      const content = p.resultSummary ? `\n提交内容: ${String(p.resultSummary).substring(0, 200)}` : '';
-      const progress = p.totalMilestones ? `\n进度: ${(p.milestoneIndex ?? 0) + 1}/${p.totalMilestones}` : '';
-      return `✅ 里程碑 M${p.milestoneIndex ?? '?'} 审核通过\n订单: ${p.orderId || body?.orderId || '?'}${desc}${content}${progress}`;
+      const desc = p.milestoneDescription ? `
+目标: ${p.milestoneDescription}` : '';
+      const content = p.resultSummary ? `
+提交内容: ${String(p.resultSummary).substring(0, 200)}` : '';
+      const progress = p.totalMilestones ? `
+进度: ${(p.milestoneIndex ?? 0) + 1}/${p.totalMilestones}` : '';
+      return `✅ 里程碑 M${p.milestoneIndex ?? '?'} 审核通过
+订单: ${p.orderId || body?.orderId || '?'}${desc}${content}${progress}`;
     },
     'milestone_rejected': (p) => {
-      const desc = p.milestoneDescription ? `\n目标: ${p.milestoneDescription}` : '';
-      return `❌ 里程碑 M${p.milestoneIndex ?? '?'} 被拒绝\n订单: ${p.orderId || body?.orderId || '?'}${desc}\n原因: ${p.rejectReason || '未说明'}`;
+      const desc = p.milestoneDescription ? `
+目标: ${p.milestoneDescription}` : '';
+      return `❌ 里程碑 M${p.milestoneIndex ?? '?'} 被拒绝
+订单: ${p.orderId || body?.orderId || '?'}${desc}
+原因: ${p.rejectReason || '未说明'}`;
     },
+    'order_completed': (p) => `📦 订单已提交完成
+订单: ${p.orderId || body?.orderId || '?'}
+等待对方确认或系统自动确认`,
+    'order_cancelled': (p) => `🛑 订单已取消
+订单: ${p.orderId || body?.orderId || '?'}
+原因: ${p.reason || '未说明'}`,
+    'order_expired': (p) => `⌛ 订单已过期
+订单: ${p.orderId || body?.orderId || '?'}
+系统已自动结束该订单`,
+    'dispute_created': (p) => `⚖️ 争议已创建
+订单: ${p.orderId || body?.orderId || '?'}
+请尽快补充证据`,
+    'dispute_resolved': (p) => `🧾 争议已处理完成
+订单: ${p.orderId || body?.orderId || '?'}
+结果: ${p.result || p.resolution || '已裁定'}`,
     'order_settled': (p) => {
-      const cl = chainLabel(p);
-      const amount = p.priceAmount ? `\n金额: $${p.priceAmount} USDC${cl}` : '';
-      const dest = cl === ' (Fast)' ? '\n资金已到达执行方 Fast 钱包' : '\nUSDC 已支付';
-      return `💰 订单已结算完成\n订单: ${p.orderId || body?.orderId || '?'}${amount}${dest}`;
+      const amount = p.priceAmount ? `
+金额: $${p.priceAmount} USDC` : '';
+      return `💰 订单已结算完成
+订单: ${p.orderId || body?.orderId || '?'}${amount}
+USDC 已支付`;
     },
   };
   const tmpl = templates[eventType];
-  if (!tmpl) return;
-  const message = tmpl(payload);
+  const orderIdText = orderId || '?';
+  const message = tmpl ? tmpl(payload) : `🔔 平台事件更新
+事件: ${eventType}
+订单: ${orderIdText}`;
 
   for (const target of enabled) {
     try {
-      if (target.channel === 'telegram' && target.botToken) {
-        // Direct TG Bot API — no gateway needed
-        // Note: parse_mode is intentionally omitted. Templates render plain
-        // text (no HTML markup), and milestone payloads frequently contain
-        // raw `<` characters (e.g. "<5秒", "<30秒") that would otherwise
-        // trip Telegram's HTML parser and cause silent 400 drops.
-        await fetch(`https://api.telegram.org/bot${target.botToken}/sendMessage`, {
+      if (target.channel === 'telegram') {
+        if (!target.botToken) {
+          log({ event: 'trade_notify_target_skipped', eventType, channel: 'telegram', target: target.id || target.target, reason: 'missing_bot_token' });
+          continue;
+        }
+        const resp = await fetch(`https://api.telegram.org/bot${target.botToken}/sendMessage`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ chat_id: target.target, text: message }),
           signal: AbortSignal.timeout(5000),
-        }).catch(() => {});
+        });
+        const data = await resp.json().catch(() => null);
+        if (!resp.ok || data?.ok === false) {
+          log({ event: 'trade_notify_delivery_error', eventType, channel: 'telegram', target: target.id || target.target, status: resp.status, error: data?.description || `http_${resp.status}` });
+          continue;
+        }
       } else if (target.channel === 'gateway') {
-        // OpenClaw gateway
         const gw = discoverGateway();
         if (gw?.url && gw?.token) {
-          await fetch(`${gw.url}/tools/invoke`, {
+          const resp = await fetch(`${gw.url}/tools/invoke`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${gw.token}` },
             body: JSON.stringify({ tool: 'message', args: { action: 'send', message, target: target.target } }),
             signal: AbortSignal.timeout(5000),
-          }).catch(() => {});
+          });
+          if (!resp.ok) {
+            log({ event: 'trade_notify_delivery_error', eventType, channel: 'gateway', target: target.id || target.target, status: resp.status, error: `http_${resp.status}` });
+            continue;
+          }
+        } else {
+          log({ event: 'trade_notify_target_skipped', eventType, channel: 'gateway', target: target.id || target.target, reason: 'missing_gateway' });
+          continue;
         }
       }
-      // Update lastUsedAt
       target.lastUsedAt = new Date().toISOString();
     } catch (e) {
-      // Never block main flow
+      log({ event: 'trade_notify_delivery_error', eventType, channel: target.channel, target: target.id || target.target, error: e.message || 'unknown_error' });
     }
   }
-  // Best-effort save lastUsedAt
   try { saveNotifyTargets(targets); } catch {}
 }
 
@@ -389,17 +729,34 @@ function appendP2PTaskStatus(entry) {
 }
 
 async function pushP2PNotification(eventType, payload = {}) {
-  const targets = loadNotifyTargets();
-  const enabled = (targets.targets || []).filter(t => t.enabled !== false);
+  const { targets, enabled } = resolveNotifyTargets('');
   if (enabled.length === 0) return;
 
   const templates = {
-    'p2p_task_sent': (p) => `📤 P2P任务已发送\n任务: ${p.taskId || '?'}\n目标: ${p.peerDid || '?'}`,
-    'p2p_task_received': (p) => `📩 收到新的P2P任务\n任务: ${p.taskId || '?'}\n来自: ${p.peerDid || '?'}`,
-    'p2p_task_started': (p) => `▶️ P2P任务开始处理\n任务: ${p.taskId || '?'}\n来自: ${p.peerDid || '?'}`,
-    'p2p_result_submitted': (p) => `📨 P2P结果已发回对方\n任务: ${p.taskId || '?'}\n目标: ${p.peerDid || '?'}`,
-    'p2p_result_received': (p) => `✅ P2P任务已完成\n任务: ${p.taskId || '?'}\n结果: ${String(p.result || '').slice(0, 80) || '已返回'}`,
-    'p2p_task_failed': (p) => `❌ P2P任务失败\n任务: ${p.taskId || '?'}\n原因: ${p.reason || '未知错误'}`,
+    'p2p_task_sent': (p) => `📤 P2P任务已发送
+任务: ${p.taskId || '?'}
+目标: ${p.peerDid || '?'}`,
+    'p2p_task_received': (p) => `📩 收到新的P2P任务
+任务: ${p.taskId || '?'}
+来自: ${p.peerDid || '?'}`,
+    'p2p_task_started': (p) => `▶️ P2P任务开始处理
+任务: ${p.taskId || '?'}
+来自: ${p.peerDid || '?'}`,
+    'p2p_result_submitted': (p) => `📨 P2P结果已发回对方
+任务: ${p.taskId || '?'}
+目标: ${p.peerDid || '?'}`,
+    'p2p_result_received': (p) => `✅ P2P任务已完成
+任务: ${p.taskId || '?'}
+结果: ${String(p.result || '').slice(0, 80) || '已返回'}`,
+    'p2p_task_failed': (p) => `❌ P2P任务失败
+任务: ${p.taskId || '?'}
+原因: ${p.reason || '未知错误'}`,
+    'p2p_message_received': (p) => `💬 收到新消息
+来自: ${p.peerDid || '?'}
+内容: ${String(p.text || '').slice(0, 120) || '[message]'}`,
+    'p2p_contact_added': (p) => `👤 联系人提醒
+来自: ${p.peerDid || '?'}${p.alias ? `
+备注: ${p.alias}` : ''}`,
   };
   const tmpl = templates[eventType];
   if (!tmpl) return;
@@ -407,27 +764,44 @@ async function pushP2PNotification(eventType, payload = {}) {
 
   for (const target of enabled) {
     try {
-      if (target.channel === 'telegram' && target.botToken) {
-        // parse_mode intentionally omitted — see pushTradeNotification for rationale
-        await fetch(`https://api.telegram.org/bot${target.botToken}/sendMessage`, {
+      if (target.channel === 'telegram') {
+        if (!target.botToken) {
+          log({ event: 'p2p_notify_target_skipped', eventType, channel: 'telegram', target: target.id || target.target, reason: 'missing_bot_token' });
+          continue;
+        }
+        const resp = await fetch(`https://api.telegram.org/bot${target.botToken}/sendMessage`, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ chat_id: target.target, text: message }),
           signal: AbortSignal.timeout(5000),
-        }).catch(() => {});
+        });
+        const data = await resp.json().catch(() => null);
+        if (!resp.ok || data?.ok === false) {
+          log({ event: 'p2p_notify_delivery_error', eventType, channel: 'telegram', target: target.id || target.target, status: resp.status, error: data?.description || `http_${resp.status}` });
+          continue;
+        }
       } else if (target.channel === 'gateway') {
         const gw = discoverGateway();
         if (gw?.url && gw?.token) {
-          await fetch(`${gw.url}/tools/invoke`, {
+          const resp = await fetch(`${gw.url}/tools/invoke`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${gw.token}` },
             body: JSON.stringify({ tool: 'message', args: { action: 'send', message, target: target.target } }),
             signal: AbortSignal.timeout(5000),
-          }).catch(() => {});
+          });
+          if (!resp.ok) {
+            log({ event: 'p2p_notify_delivery_error', eventType, channel: 'gateway', target: target.id || target.target, status: resp.status, error: `http_${resp.status}` });
+            continue;
+          }
+        } else {
+          log({ event: 'p2p_notify_target_skipped', eventType, channel: 'gateway', target: target.id || target.target, reason: 'missing_gateway' });
+          continue;
         }
       }
       target.lastUsedAt = new Date().toISOString();
-    } catch {}
+    } catch (e) {
+      log({ event: 'p2p_notify_delivery_error', eventType, channel: target.channel, target: target.id || target.target, error: e.message || 'unknown_error' });
+    }
   }
   try { saveNotifyTargets(targets); } catch {}
 }
@@ -1082,6 +1456,7 @@ function saveTrackedOrders(orders) {
 }
 function trackOrder(orderId, role) {
   if (!orderId || !role) return;
+  rememberCurrentTelegramRoute(orderId);
   const now = new Date().toISOString();
   const orders = loadTrackedOrders().filter((o) => o && o.orderId);
   const existing = orders.find((o) => o.orderId === orderId);
@@ -1096,11 +1471,146 @@ function trackOrder(orderId, role) {
 function untrackOrder(orderId) {
   if (!orderId) return;
   saveTrackedOrders(loadTrackedOrders().filter((o) => o?.orderId !== orderId));
+  dropTelegramRoute(orderId);
 }
 function loadTasks() { if (!existsSync(TASKS_FILE)) return {}; try { return JSON.parse(readFileSync(TASKS_FILE, 'utf-8')); } catch { return {}; } }
 function saveTasks(t) { ensureDir(); writeFileSync(TASKS_FILE, JSON.stringify(t, null, 2)); }
 function loadNetwork() { if (!existsSync(NETWORK_FILE)) return null; try { return JSON.parse(readFileSync(NETWORK_FILE, 'utf-8')); } catch { return null; } }
 function saveNetwork(n) { ensureDir(); writeFileSync(NETWORK_FILE, JSON.stringify(n, null, 2)); }
+function syncNetworkConfigToPort(networkConfig, port) {
+  if (!networkConfig || typeof networkConfig !== 'object') return { config: networkConfig, changed: false };
+  let changed = false;
+  const next = { ...networkConfig };
+  if (next.port !== port) { next.port = port; changed = true; }
+  const rewriteUrlPort = (value) => {
+    if (typeof value !== 'string' || !value.trim()) return value;
+    try {
+      const parsed = new URL(value);
+      const desiredPort = String(port);
+      if (parsed.port === desiredPort) return value;
+      parsed.port = desiredPort;
+      changed = true;
+      return parsed.toString();
+    } catch {
+      return value;
+    }
+  };
+  next.endpoint = rewriteUrlPort(next.endpoint);
+  if (Array.isArray(next.candidates)) {
+    next.candidates = next.candidates.map((candidate) => {
+      if (!candidate || typeof candidate !== 'object') return candidate;
+      const updated = { ...candidate };
+      if (updated.type === 'relay') {
+        if (typeof next.relayUrl === 'string' && next.relayUrl.trim() && updated.url !== next.relayUrl) {
+          updated.url = next.relayUrl;
+          changed = true;
+        }
+        if (updated.port && updated.port !== 18204) {
+          updated.port = 18204;
+          changed = true;
+        }
+        return updated;
+      }
+      if (updated.port !== port) { updated.port = port; changed = true; }
+      updated.url = rewriteUrlPort(updated.url);
+      return updated;
+    });
+  }
+  if (changed) next.configuredAt = new Date().toISOString();
+  return { config: next, changed };
+}
+function isLegacyPassiveRelayMessage(req) {
+  if (!req || typeof req !== 'object' || Array.isArray(req)) return false;
+  const path = typeof req.path === 'string' ? req.path.trim() : '';
+  const method = typeof req.method === 'string' ? req.method.trim().toUpperCase() : '';
+  if (path || method) return false;
+  const kind = typeof req.kind === 'string' ? req.kind.trim() : '';
+  const text = typeof req.text === 'string' ? req.text.trim() : '';
+  const msgType = typeof req.msgType === 'string' ? req.msgType.trim() : '';
+  const p2pType = typeof req.type === 'string' ? req.type.trim() : '';
+  return Boolean(text || msgType === 'message' || kind === 'portal_message' || kind === 'contact_added' || ['friend_request','friend_accept','friend_reject'].includes(p2pType));
+}
+function buildPassiveRelayRequest(req, senderDid = '') {
+  const normalizedSender = String(req?.senderDid || req?.from || senderDid || '').trim();
+  const normalizedKind = typeof req?.kind === 'string' && req.kind.trim()
+    ? req.kind.trim()
+    : ((typeof req?.msgType === 'string' && req.msgType.trim() === 'message') || typeof req?.text === 'string'
+      ? 'portal_message'
+      : 'relay_message');
+  return {
+    method: 'POST',
+    path: '/atel/v1/relay-message',
+    body: {
+      ...req,
+      senderDid: normalizedSender,
+      kind: normalizedKind,
+      timestamp: req?.timestamp || new Date().toISOString(),
+    },
+  };
+}
+function extractSignedRelayEnvelope(message) {
+  if (!message || typeof message !== 'object' || Array.isArray(message)) return {};
+  if (
+    message.envelope === 'atel.msg.v1' &&
+    typeof message.from === 'string' &&
+    typeof message.to === 'string' &&
+    typeof message.type === 'string' &&
+    message.payload !== undefined &&
+    typeof message.signature === 'string'
+  ) {
+    return {
+      envelope: message.envelope,
+      type: message.type,
+      from: message.from,
+      to: message.to,
+      timestamp: message.timestamp,
+      nonce: message.nonce,
+      payload: message.payload,
+      signature: message.signature,
+    };
+  }
+  const signed = {};
+  for (const key of ['to', 'from', 'type', 'action', 'msgType', 'msgId', 'text', 'images', 'attachments', 'summary', 'kind', 'nonce', 'payload', 'envelope', 'signature', 'timestamp']) {
+    if (message[key] !== undefined) signed[key] = message[key];
+  }
+  return signed;
+}
+function isAckableMalformedRelayMessage(req, inner) {
+  if (typeof inner === 'string') {
+    const raw = inner.trim();
+    if (raw === '' || raw === '{}') return true;
+  }
+  if (!req || typeof req !== 'object' || Array.isArray(req)) return false;
+  const keys = Object.keys(req);
+  if (keys.length === 0) return true;
+  const path = typeof req.path === 'string' ? req.path.trim() : '';
+  const method = typeof req.method === 'string' ? req.method.trim().toUpperCase() : '';
+  const body = req.body;
+  const hasBodyObject = !!body && typeof body === 'object' && !Array.isArray(body) && Object.keys(body).length > 0;
+  const hasBodyString = typeof body === 'string' && body.trim() !== '';
+  if ((!path || path === '/') && !hasBodyObject && !hasBodyString) return true;
+  return !path && !method && !hasBodyObject && !hasBodyString;
+}
+const HUMAN_INBOX_EVENT_PREFIXES = ['p2p_task_', 'p2p_result_'];
+const HUMAN_INBOX_EVENTS = new Set([
+  'notification',
+  'result_received',
+  'rejection_proof',
+  'friend_added',
+  'friend_removed',
+  'friend_request_received',
+  'friend_request_accepted_by_peer',
+  'friend_request_rejected_by_peer',
+  'relay_message_received',
+]);
+function isHumanInboxEntry(entry) {
+  if (!entry || typeof entry !== 'object') return false;
+  if (entry.type === 'task-result') return true;
+  const event = typeof entry.event === 'string' ? entry.event : '';
+  if (!event) return false;
+  if (HUMAN_INBOX_EVENTS.has(event)) return true;
+  return HUMAN_INBOX_EVENT_PREFIXES.some((prefix) => event.startsWith(prefix));
+}
 function saveTrace(taskId, trace) { if (!existsSync(TRACES_DIR)) mkdirSync(TRACES_DIR, { recursive: true }); writeFileSync(resolve(TRACES_DIR, `${taskId}.jsonl`), trace.export()); }
 function loadTrace(taskId) { const f = resolve(TRACES_DIR, `${taskId}.jsonl`); if (!existsSync(f)) return null; return readFileSync(f, 'utf-8'); }
 function loadPending() { if (!existsSync(PENDING_FILE)) return {}; try { return JSON.parse(readFileSync(PENDING_FILE, 'utf-8')); } catch { return {}; } }
@@ -1319,7 +1829,9 @@ function removeFriend(did) {
 
 // Check if DID is a friend
 function isFriend(did) {
-  const data = getCachedFriends();
+  // Friendship can be updated by a separate CLI process (for example `atel friend accept`).
+  // Read from disk here so the long-running agent process does not enforce a stale cache.
+  const data = loadFriends();
   return data.friends.some(f => f.did === did && f.status === 'accepted');
 }
 
@@ -1759,6 +2271,121 @@ function checkP2PAccess(from, action, payload, currentPolicy) {
   };
 }
 
+function checkP2PMessageAccess(from, currentPolicy) {
+  if (!from) {
+    return {
+      allowed: false,
+      reason: 'UNKNOWN_SENDER',
+      message: 'Missing sender DID',
+      code: 'INVALID_SENDER'
+    };
+  }
+
+  if (currentPolicy.blockedDIDs && currentPolicy.blockedDIDs.length > 0 && currentPolicy.blockedDIDs.includes(from)) {
+    log({
+      event: 'p2p_access_denied',
+      from,
+      action: 'message',
+      reason: 'DID_BLOCKED',
+      timestamp: new Date().toISOString()
+    });
+    return {
+      allowed: false,
+      reason: 'DID_BLOCKED',
+      message: 'You are blocked by this agent',
+      code: 'BLOCKED'
+    };
+  }
+
+  const relPolicy = currentPolicy.relationshipPolicy || getDefaultRelationshipPolicy();
+
+  if (isFriend(from)) {
+    log({
+      event: 'p2p_access_granted',
+      from,
+      action: 'message',
+      reason: 'FRIEND',
+      relationship: 'friend',
+      timestamp: new Date().toISOString()
+    });
+    return {
+      allowed: true,
+      reason: 'FRIEND',
+      relationship: 'friend'
+    };
+  }
+
+  const tempSession = getActiveTempSession(from);
+  if (tempSession) {
+    if (Date.now() > new Date(tempSession.expiresAt).getTime()) {
+      removeTempSession(tempSession.sessionId);
+      log({
+        event: 'p2p_access_denied',
+        from,
+        action: 'message',
+        reason: 'TEMP_SESSION_EXPIRED',
+        sessionId: tempSession.sessionId,
+        timestamp: new Date().toISOString()
+      });
+      return {
+        allowed: false,
+        reason: 'TEMP_SESSION_EXPIRED',
+        message: 'Your temporary session has expired. Please request a new one.',
+        code: 'TEMP_EXPIRED'
+      };
+    }
+
+    log({
+      event: 'p2p_access_granted',
+      from,
+      action: 'message',
+      reason: 'TEMP_SESSION',
+      relationship: 'temporary',
+      sessionId: tempSession.sessionId,
+      timestamp: new Date().toISOString()
+    });
+    return {
+      allowed: true,
+      reason: 'TEMP_SESSION',
+      relationship: 'temporary',
+      sessionId: tempSession.sessionId
+    };
+  }
+
+  if (relPolicy.defaultMode === 'open') {
+    log({
+      event: 'p2p_access_granted',
+      from,
+      action: 'message',
+      reason: 'OPEN_MODE',
+      relationship: 'stranger',
+      timestamp: new Date().toISOString()
+    });
+    return {
+      allowed: true,
+      reason: 'OPEN_MODE',
+      relationship: 'stranger'
+    };
+  }
+
+  log({
+    event: 'p2p_access_denied',
+    from,
+    action: 'message',
+    reason: 'NOT_FRIEND',
+    defaultMode: relPolicy.defaultMode || 'unknown',
+    timestamp: new Date().toISOString()
+  });
+
+  return {
+    allowed: false,
+    reason: 'NOT_FRIEND',
+    message: 'You are not a friend. Please send a friend request first.',
+    hint: 'Send friend request: atel friend request <your-did>',
+    code: 'NOT_FRIEND'
+  };
+}
+
 // ─── Unified Trust Score & Level System ──────────────────────────
 // Single source of truth: computeTrustScore() calculates score,
 // trustLevel is derived from score. No independent logic.
@@ -1979,19 +2606,8 @@ async function promptInput(question) {
 // ─── Anchor Configuration ────────────────────────────────────────
 
 async function configureAnchor() {
-  console.log('\n🔗 Configure On-Chain Anchoring (legacy V1 mode)\n');
-  console.log('⚠️  In V2 the ATEL Platform anchors on behalf of agents using its own');
-  console.log('    executor wallets — you do NOT need this for paid orders.');
-  console.log('    Your smart wallet addresses (derived from your DID) already receive');
-  console.log('    USDC and the platform pays gas for you. Only continue if you are');
-  console.log('    running a legacy V1 self-anchoring agent.');
-  console.log('');
-  const go = await promptYesNo('Continue anyway?');
-  if (!go) {
-    console.log('Aborted. Your identity is unchanged.');
-    return;
-  }
-
+  console.log('\n🔗 Configure On-Chain Anchoring\n');
+  
   // 1. Select chain
   const chain = await promptChoice(
     'Select blockchain for anchoring:',
@@ -2048,108 +2664,99 @@ async function configureAnchor() {
 // ─── Commands ────────────────────────────────────────────────────
 
 async function cmdInit(agentId) {
-  const name = agentId || `agent-${Date.now()}`;
+  const existingIdentity = loadIdentity();
+  if (existingIdentity && process.env.ATEL_REINIT != '1') {
+    console.log(JSON.stringify({
+      status: 'exists',
+      agent_id: existingIdentity.agent_id,
+      did: existingIdentity.did,
+      next: 'Reuse existing identity. Run: atel start [port]'
+    }, null, 2));
+    return;
+  }
+
+  let name = (agentId || '').trim();
+  if (!name && process.stdin.isTTY) {
+    const chosen = await promptInput('Choose your agent name (required):');
+    name = (chosen || '').trim();
+  }
+  if (!name) {
+    console.error('Agent name is required. Pass a name explicitly, or run `atel init` interactively and enter one.');
+    process.exit(1);
+  }
+
   const identity = new AgentIdentity({ agent_id: name });
   saveIdentity(identity);
   savePolicy(DEFAULT_POLICY);
-
+  
   // Create default agent-context.md for built-in executor
   const ctxFile = resolve(ATEL_DIR, 'agent-context.md');
   if (!existsSync(ctxFile)) {
-    writeFileSync(ctxFile, `# Agent Context\n\nYou are an ATEL agent (${name}) processing tasks from other agents via the ATEL protocol.\n\n## Guidelines\n- Complete the task accurately and concisely\n- Return only the requested result, no extra commentary\n- If the task is unclear, do your best interpretation\n- Do not access private files or sensitive data\n- Do not make external network requests unless the task requires it\n`);
-  }
-
-  // NOTE (2026-04-09): We intentionally do NOT prompt for an on-chain anchor
-  // private key here any more. That prompt is a V1 leftover — in V2 the
-  // Platform handles all on-chain anchoring on behalf of agents using its own
-  // registered executor wallets, and the user's USDC lives in a smart wallet
-  // (AA) whose address is derived from the ATEL identity key. Asking users to
-  // paste a raw Base/BSC/Solana private key at install time is both
-  // unnecessary and intimidating. If someone genuinely needs legacy
-  // self-anchoring they can opt in later via `atel anchor config`.
+    writeFileSync(ctxFile, `# Agent Context
 
-  // Derive the smart-wallet addresses from the identity so the user can see
-  // where to top up USDC for paid orders.
-  let smartWallet = null;
-  try {
-    const info = identity.toJSON?.() || {};
-    smartWallet = info.smart_wallet || info.wallet || null;
-  } catch { /* best-effort */ }
+You are an ATEL agent (${name}) processing tasks from other agents via the ATEL protocol.
 
-  const output = {
-    status: 'created',
-    agent_id: identity.agent_id,
-    did: identity.did,
+## Guidelines
+- Complete the task accurately and concisely
+- Return only the requested result, no extra commentary
+- If the task is unclear, do your best interpretation
+- Do not access private files or sensitive data
+- Do not make external network requests unless the task requires it
+`);
+  }
+  
+  console.log('');
+  const providePaidOrders = await promptYesNo(
+    'Do you want to provide paid order services? (requires on-chain anchoring)'
+  );
+  
+  let anchorConfigured = false;
+  if (providePaidOrders) {
+    try {
+      await configureAnchor();
+      anchorConfigured = true;
+    } catch (e) {
+      console.error(`❌ Failed to configure anchor: ${e.message}`);
+    }
+  }
+  
+  console.log(JSON.stringify({ 
+    status: 'created', 
+    agent_id: identity.agent_id, 
+    did: identity.did, 
     policy: POLICY_FILE,
-    nextSteps: [
-      'atel start            — bring the agent online (network + auto-register)',
-      `atel register ${name} "<capability1>,<capability2>"   — advertise what you can do`,
-      'atel info             — show your DID, wallets, and policy',
-      'atel balance          — check USDC balance on Base/BSC smart wallets',
-    ],
-    note: 'Paid orders work out of the box in V2 — no on-chain private key needed. The Platform anchors on your behalf using its own executor wallets. If you specifically need legacy self-anchoring, run: atel anchor config',
-  };
-  if (smartWallet) output.smartWallet = smartWallet;
-  console.log(JSON.stringify(output, null, 2));
+    anchor: anchorConfigured ? 'configured' : 'disabled',
+    next: 'Run: atel start [port] — auto-configures network and registers'
+  }, null, 2));
 
-  // Auto-install SKILL.md to OpenClaw skills directory
   try {
-    const installed = syncAtelSkillToOpenClaw({ verbose: true });
-    if (!installed.length) {
-      const sdkSkillPath = resolveSdkSkillPath();
-      console.log('\n📋 To teach your AI agent about ATEL, send it this message:');
-      console.log(`   "Read ${sdkSkillPath} carefully, then help me set up ATEL and start earning."`);
-    }
-  } catch (e) { /* skill install is best-effort */ }
-}
-
-// Path to the SKILL.md shipped inside the currently-installed SDK package.
-// Used both at `atel init` time and on every `atel start` to keep openclaw's
-// workspace copy in sync with the latest published skill content.
-function resolveSdkSkillPath() {
-  return resolve(dirname(fileURLToPath(import.meta.url)), '..', 'skill', 'atel-agent', 'SKILL.md');
-}
-
-// Sync the SDK's SKILL.md into every openclaw skills dir that already hosts
-// an atel-agent skill. Written to fix a subtle version-drift bug: `npm i -g`
-// upgrades the SDK package on disk, but openclaw's session `skillsSnapshot`
-// reads from `~/.openclaw/workspace/skills/atel-agent/SKILL.md`, which is a
-// physical copy made at init time and never refreshed. After an upgrade the
-// agent keeps seeing stale skill content indefinitely. See incident
-// 2026-04-09, order ord-4c12a03d-ea8, where the workspace copy was ~12 days
-// older than the npm copy and missing the "--desc required" guidance.
-//
-// We intentionally sync to *every* candidate dir where an `atel-agent` sibling
-// is present (not just the first one), because different openclaw versions
-// read from different roots and we want all of them to end up coherent.
-// Returns the list of destinations actually written.
-function syncAtelSkillToOpenClaw({ verbose = false } = {}) {
-  const sdkSkillPath = resolveSdkSkillPath();
-  if (!existsSync(sdkSkillPath)) return [];
-  const home = process.env.HOME || '';
-  // Candidate parent dirs, in the order we want to probe. We sync to any
-  // that exist, creating the leaf `atel-agent/` dir if its parent is present.
-  const parents = [
-    join(home, '.openclaw', 'workspace', 'skills'),
-    join(home, '.openclaw', 'skills'),
-  ];
-  const written = [];
-  for (const parent of parents) {
-    if (!existsSync(parent)) continue;
-    const dir = join(parent, 'atel-agent');
-    try {
-      mkdirSync(dir, { recursive: true });
-      const dest = join(dir, 'SKILL.md');
-      copyFileSync(sdkSkillPath, dest);
-      written.push(dest);
-      if (verbose) {
-        console.log(`✅ ATEL skill synced → ${dest}`);
+    const sdkSkillPath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'skill', 'atel-agent', 'SKILL.md');
+    if (existsSync(sdkSkillPath)) {
+      const home = process.env.HOME || '';
+      const candidates = [
+        join(home, '.openclaw', 'skills', 'atel-agent'),
+        join(home, '.openclaw', 'workspace', 'skills', 'atel-agent'),
+      ];
+      let installed = false;
+      for (const dir of candidates) {
+        if (existsSync(dirname(dir))) {
+          mkdirSync(dir, { recursive: true });
+          copyFileSync(sdkSkillPath, join(dir, 'SKILL.md'));
+          console.log(`\n✅ ATEL Skill auto-installed to ${dir}`);
+          console.log('   Your AI agent will automatically know how to use ATEL.');
+          console.log('');
+          console.log('📌 Tell your agent this message to get started:');
+          console.log('   "Read the atel-agent skill at ~/.openclaw/skills/atel-agent/SKILL.md carefully, then help me set up ATEL and start earning."');
+          installed = true;
+          break;
+        }
+      }
+      if (!installed) {
+        console.log('\n📋 To teach your AI agent about ATEL, send it this message:');
+        console.log(`   "Read ${sdkSkillPath} carefully, then help me set up ATEL and start earning."`);
       }
-    } catch (e) {
-      if (verbose) console.error(`   (skipped ${dir}: ${e.message})`);
     }
-  }
-  return written;
+  } catch (e) { /* skill install is best-effort */ }
 }
 
 async function cmdAnchor(subcommand) {
@@ -2319,7 +2926,7 @@ async function cmdStatus() {
 async function cmdSetup(port) {
   const p = parseInt(port || '3100');
   console.log(JSON.stringify({ event: 'network_setup', port: p }));
-  const net = await autoNetworkSetup(p);
+  const net = await autoNetworkSetup(p, ATEL_RELAY);
   for (const step of net.steps) console.log(JSON.stringify({ event: 'step', message: step }));
   if (net.endpoint) {
     saveNetwork({ publicIP: net.publicIP, port: p, endpoint: net.endpoint, upnp: net.upnpSuccess, reachable: net.reachable, configuredAt: new Date().toISOString() });
@@ -2495,21 +3102,6 @@ async function cmdStart(port) {
     log({ event: 'openclaw_lock_cleanup_error', error: e.message });
   }
 
-  // Refresh workspace SKILL.md from the currently-installed SDK package.
-  // Without this, `npm i -g` upgrades leave a stale copy at
-  // ~/.openclaw/workspace/skills/atel-agent/SKILL.md that openclaw keeps
-  // reading — the documented behaviour of the upgrade then silently lags
-  // behind the code. Fixes incident 2026-04-09 where a ~12-day-old workspace
-  // skill copy was missing "--desc is required" guidance.
-  try {
-    const synced = syncAtelSkillToOpenClaw();
-    if (synced.length > 0) {
-      log({ event: 'atel_skill_synced', count: synced.length, destinations: synced });
-    }
-  } catch (e) {
-    log({ event: 'atel_skill_sync_error', error: e.message });
-  }
-
   // Initialize Ollama only if explicitly enabled (optional local AI audit)
   if (process.env.ATEL_OLLAMA_ENABLED === 'true') {
     await initializeOllama().catch(err => {
@@ -2646,12 +3238,19 @@ async function cmdStart(port) {
   let networkConfig = loadNetwork();
   if (!networkConfig) {
     log({ event: 'network_setup', status: 'auto-detecting' });
-    networkConfig = await autoNetworkSetup(p);
+    networkConfig = await autoNetworkSetup(p, ATEL_RELAY);
     for (const step of networkConfig.steps) log({ event: 'network_step', message: step });
     delete networkConfig.steps;
     saveNetwork(networkConfig);
   } else {
-    log({ event: 'network_loaded', candidates: networkConfig.candidates?.length || 0 });
+    const synced = syncNetworkConfigToPort(networkConfig, p);
+    networkConfig = synced.config;
+    if (synced.changed) {
+      saveNetwork(networkConfig);
+      log({ event: 'network_port_aligned', port: p, endpoint: networkConfig.endpoint, candidates: networkConfig.candidates?.length || 0 });
+    } else {
+      log({ event: 'network_loaded', candidates: networkConfig.candidates?.length || 0 });
+    }
   }
 
   // ── Start endpoint ──
@@ -2922,6 +3521,7 @@ async function cmdStart(port) {
       summary: body.summary,
       error: body.error,
       childSessionKey: pending.childSessionKey,
+      duration_ms: pending.startedAt ? Date.now() - pending.startedAt : undefined,
     });
 
     if (body.status === 'failed') {
@@ -2937,6 +3537,7 @@ async function cmdStart(port) {
           childSessionKey: pending.childSessionKey,
           summary: body.summary,
           error: body.error,
+          duration_ms: pending.startedAt ? Date.now() - pending.startedAt : undefined,
         });
 
         if (failedAction.action?.type === 'local_result') {
@@ -3115,7 +3716,7 @@ async function cmdStart(port) {
 
 Important requirements:
 1. This is a P2P task. Do not call atel result; the local SDK will submit the result automatically after your callback.
-2. Your job is to complete the AI work carefully and send the final conclusion back to the local SDK through the callback.
+2. Your job is to complete the AI work carefully and send the final conclusion back to the local SDK through the callback. Writing text alone does NOT deliver the result. Only the callback counts.
 ${fileAccessRule}
 ${contextRule}
 5. After finishing, you must immediately run the success callback command template below and replace its content with your real result:
@@ -3132,7 +3733,7 @@ ${callbackFailed}
 
 Important requirements:
 1. Do not run atel milestone-submit / milestone-verify / milestone-feedback. The local SDK will execute those commands on your behalf after the callback.
-2. Your job is to complete the AI work carefully and send the final conclusion back to the local SDK through the callback.
+2. Your job is to complete the AI work carefully and send the final conclusion back to the local SDK through the callback. Writing text alone does NOT deliver the result. Only the callback counts.
 ${fileAccessRule}
 ${contextRule}
 ${repoRule}
@@ -3333,11 +3934,14 @@ Format:
     if (!safePrompt) return { ok: false, error: 'empty_agent_prompt' };
     const taskPrompt = buildGatewayCallbackPrompt(eventType, safePrompt, callbackUrl, dedupeKey, cwd, payload);
     const timeoutMs = 10 * 60 * 1000;
+    const startedAt = Date.now();
 
     return await new Promise(async (resolve) => {
       const timer = setTimeout(() => {
+        const active = pendingAgentCallbacks.get(dedupeKey);
         pendingAgentCallbacks.delete(dedupeKey);
         persistPendingAgentCallback(dedupeKey, { eventType, payload, cwd, source: dedupeKey.startsWith('reconcile:') ? 'reconcile' : 'main', timeout: true });
+        log({ event: 'agent_callback_timeout', eventType, dedupeKey, childSessionKey: active?.childSessionKey || null, duration_ms: Date.now() - startedAt });
         resolve({ ok: false, error: 'agent_callback_timeout' });
       }, timeoutMs);
 
@@ -3346,6 +3950,7 @@ Format:
         payload,
         cwd,
         childSessionKey: null,
+        startedAt,
         resolve: (result) => {
           clearTimeout(timer);
           resolve(result);
@@ -3375,9 +3980,11 @@ Format:
           signal: AbortSignal.timeout(15000),
         });
         if (!resp.ok) {
+          const errorText = await resp.text().catch(() => '');
           pendingAgentCallbacks.delete(dedupeKey);
           clearPersistedPendingAgentCallback(dedupeKey);
           clearTimeout(timer);
+          log({ event: 'agent_session_spawn_failed', eventType, dedupeKey, status: resp.status, error: errorText.slice(0, 300), duration_ms: Date.now() - startedAt });
           resolve({ ok: false, error: `sessions_spawn_http_${resp.status}` });
           return;
         }
@@ -3386,25 +3993,35 @@ Format:
         const childSessionKey = data.result?.details?.childSessionKey || data.result?.childSessionKey || '';
         const pending = pendingAgentCallbacks.get(dedupeKey);
         if (pending) pending.childSessionKey = childSessionKey;
-        log({ event: 'agent_session_spawned', eventType, dedupeKey, childSessionKey });
+        log({ event: 'agent_session_spawned', eventType, dedupeKey, childSessionKey, spawn_duration_ms: Date.now() - startedAt });
       } catch (e) {
         pendingAgentCallbacks.delete(dedupeKey);
         clearPersistedPendingAgentCallback(dedupeKey);
         clearTimeout(timer);
+        log({ event: 'agent_session_spawn_failed', eventType, dedupeKey, error: e.message, duration_ms: Date.now() - startedAt });
         resolve({ ok: false, error: e.message });
       }
     });
   }
 
   function queueAgentHook(eventType, dedupeKey, promptText, cwd, payload = {}, options = {}) {
-    if (!detectedAgentCmd) return false;
+    if (!detectedAgentCmd) {
+      log({ event: 'agent_hook_not_queued', eventType, dedupeKey, reason: 'missing_agent_cmd' });
+      return false;
+    }
     const safePrompt = sanitizeAgentPrompt(promptText, { eventType, dedupeKey });
-    if (!safePrompt) return false;
+    if (!safePrompt) {
+      log({ event: 'agent_hook_not_queued', eventType, dedupeKey, reason: 'empty_prompt' });
+      return false;
+    }
     const parsedCmd = detectedAgentCmd.trim().split(/\s+/);
     parsedCmd.push(safePrompt);
     const recoveryKey = options.recoveryKey || '';
     if (recoveryKey) {
-      if (activeRecoveryKeys.has(recoveryKey)) return false;
+      if (activeRecoveryKeys.has(recoveryKey)) {
+        log({ event: 'agent_hook_not_queued', eventType, dedupeKey, reason: 'recovery_key_active', recoveryKey });
+        return false;
+      }
       activeRecoveryKeys.add(recoveryKey);
     }
     hookQueue.push({ event: eventType, dedupeKey, cmd: parsedCmd[0], args: parsedCmd.slice(1), cwd, payload, recoveryKey });
@@ -3451,7 +4068,7 @@ Format:
     const ms = await fetchMilestoneState(orderId);
     if (ms.orderStatus !== 'executing') return;
 
-    if (executorDid === id.did && ms.phase === 'waiting_executor_submission') {
+    if (executorDid === id.did && ['waiting_executor_submission', 'waiting_executor_resubmission'].includes(ms.phase)) {
       const currentIndex = Number.isFinite(ms.currentMilestone) ? ms.currentMilestone : 0;
       const currentMilestone = (ms.milestones || []).find(m => m.index === currentIndex) || {};
       const previousApprovedOutputs = summarizeApprovedMilestones(ms.milestones || [], currentIndex);
@@ -3466,33 +4083,64 @@ Format:
         milestoneObjective: currentMilestone.title || '',
         previousApprovedOutputs,
       });
-      const eventType = currentIndex === 0 ? 'milestone_plan_confirmed' : 'milestone_verified';
-      const payload = currentIndex === 0
+      const isResubmission = ms.phase === 'waiting_executor_resubmission' || currentMilestone.status === 'rejected';
+      const eventType = isResubmission
+        ? 'milestone_rejected'
+        : (currentIndex === 0 ? 'milestone_plan_confirmed' : 'milestone_verified');
+      const payload = isResubmission
         ? {
             orderId,
-            milestoneIndex: 0,
+            milestoneIndex: currentIndex,
             totalMilestones: ms.totalMilestones || 5,
             milestoneDescription: currentMilestone.title || '',
             orderDescription,
             previousApprovedOutputs,
+            rejectReason: currentMilestone.rejectReason || '',
+            submitCount: currentMilestone.submitCount || 0,
           }
-        : {
-            orderId,
-            milestoneIndex: currentIndex - 1,
-            currentMilestone: currentIndex,
-            totalMilestones: ms.totalMilestones || 5,
-            allComplete: false,
-            nextMilestoneDescription: currentMilestone.title || '',
-            orderDescription,
-            previousApprovedOutputs,
-          };
-      const promptText = currentIndex === 0
-        ? `You are the ATEL executor agent. The plan has been confirmed and execution begins.\nOriginal order requirements: ${orderDescription || 'not provided'}\nCurrent milestone M0: ${currentMilestone.title || ''}\nComplete only this milestone for the current order and return the final deliverable via the callback.`
-        : `You are the ATEL executor agent. M${currentIndex - 1} has been approved.\nOriginal order requirements: ${orderDescription || 'not provided'}\nNext milestone M${currentIndex}: ${currentMilestone.title || ''}\nPreviously approved outputs:\n${previousApprovedOutputs || 'none'}\n\nAdvance the current milestone strictly based on these approved results. Do not invent missing materials or read local shared files to fill missing context. After completion, return the final deliverable via the callback.`;
+        : (currentIndex === 0
+          ? {
+              orderId,
+              milestoneIndex: 0,
+              totalMilestones: ms.totalMilestones || 5,
+              milestoneDescription: currentMilestone.title || '',
+              orderDescription,
+              previousApprovedOutputs,
+            }
+          : {
+              orderId,
+              milestoneIndex: currentIndex - 1,
+              currentMilestone: currentIndex,
+              totalMilestones: ms.totalMilestones || 5,
+              allComplete: false,
+              nextMilestoneDescription: currentMilestone.title || '',
+              orderDescription,
+              previousApprovedOutputs,
+            });
+      const promptText = isResubmission
+        ? `You are the ATEL executor agent. Your previous submission for milestone M${currentIndex} was rejected.
+Original order requirements: ${orderDescription || 'not provided'}
+Current milestone M${currentIndex}: ${currentMilestone.title || ''}
+Previously approved outputs:
+${previousApprovedOutputs || 'none'}
+
+Revise only the rejected milestone based on the rejection feedback and submit an improved deliverable.`
+        : (currentIndex === 0
+          ? `You are the ATEL executor agent. The plan has been confirmed and execution begins.
+Original order requirements: ${orderDescription || 'not provided'}
+Current milestone M0: ${currentMilestone.title || ''}
+Complete only this milestone for the current order and return the final deliverable via the callback.`
+          : `You are the ATEL executor agent. M${currentIndex - 1} has been approved.
+Original order requirements: ${orderDescription || 'not provided'}
+Next milestone M${currentIndex}: ${currentMilestone.title || ''}
+Previously approved outputs:
+${previousApprovedOutputs || 'none'}
+
+Advance the current milestone strictly based on these approved results. Do not invent missing materials or read local shared files to fill missing context. After completion, return the final deliverable via the callback.`);
       const recoveryKey = buildMilestoneHookRecoveryKey(eventType, payload);
-      log({ event: 'trade_reconcile_executor', orderId, currentMilestone: currentIndex, recoveryKey });
+      log({ event: 'trade_reconcile_executor', orderId, currentMilestone: currentIndex, phase: ms.phase, recoveryKey });
       const queued = queueAgentHook(eventType, recoveryKey, promptText, workspace.dir, payload, { recoveryKey });
-      if (queued) log({ event: 'trade_reconcile_executor_queued', orderId, currentMilestone: currentIndex, recoveryKey });
+      if (queued) log({ event: 'trade_reconcile_executor_queued', orderId, currentMilestone: currentIndex, phase: ms.phase, recoveryKey });
       return;
     }
 
@@ -3578,6 +4226,108 @@ Format:
     }
   }
 
+  endpoint.app?.post?.('/atel/v1/relay-message', async (req, res) => {
+    const body = req.body || {};
+    const senderDid = String(body.senderDid || body.from || '').trim();
+    const p2pType = typeof body.type === 'string' ? body.type.trim() : '';
+    const relaySignedMessage = extractSignedRelayEnvelope(body);
+    const relaySignedSenderDid = String(relaySignedMessage.from || senderDid || '').trim();
+
+    if (p2pType === 'friend_accept') {
+      const { requestId } = relaySignedMessage.payload || {};
+      const verified = relaySignedSenderDid ? verifyMessage(relaySignedMessage, parseDID(relaySignedSenderDid)) : { valid: false };
+      if (!verified.valid) {
+        log({ event: 'friend_accept_rejected', from: relaySignedSenderDid || body.from, reason: 'invalid_signature_via_relay' });
+        return res.json({ status: 'rejected', error: 'Invalid signature' });
+      }
+      const requests = loadFriendRequests();
+      if (!requests.outgoing) requests.outgoing = [];
+      const request = requests.outgoing.find(r => r.requestId === requestId);
+      if (!request) {
+        log({ event: 'friend_accept_ignored', from: relaySignedSenderDid, requestId, reason: 'request_not_found_via_relay' });
+        return res.json({ status: 'error', error: 'Request not found' });
+      }
+      request.status = 'accepted';
+      request.acceptedAt = new Date().toISOString();
+      saveFriendRequests(requests);
+      addFriend(relaySignedSenderDid, { addedBy: 'request', alias: '', notes: `Accepted our request ${requestId}` });
+      log({ event: 'friend_request_accepted_by_peer', from: relaySignedSenderDid, requestId, via: 'relay' });
+      return res.json({ status: 'ok', type: 'friend_accept' });
+    }
+
+    if (p2pType === 'friend_reject') {
+      const { requestId, reason } = relaySignedMessage.payload || {};
+      const verified = relaySignedSenderDid ? verifyMessage(relaySignedMessage, parseDID(relaySignedSenderDid)) : { valid: false };
+      if (!verified.valid) {
+        log({ event: 'friend_reject_ignored', from: relaySignedSenderDid || body.from, reason: 'invalid_signature_via_relay' });
+        return res.json({ status: 'rejected', error: 'Invalid signature' });
+      }
+      const requests = loadFriendRequests();
+      if (!requests.outgoing) requests.outgoing = [];
+      const request = requests.outgoing.find(r => r.requestId === requestId);
+      if (request) {
+        request.status = 'rejected';
+        request.rejectedAt = new Date().toISOString();
+        request.reason = reason || '';
+        saveFriendRequests(requests);
+      }
+      log({ event: 'friend_request_rejected_by_peer', from: relaySignedSenderDid, requestId, reason, via: 'relay' });
+      return res.json({ status: 'ok', type: 'friend_reject' });
+    }
+
+    const kind = String(body.kind || ((typeof body.msgType === 'string' && body.msgType === 'message') || typeof body.text === 'string' ? 'portal_message' : 'relay_message')).trim();
+    const text = typeof body.text === 'string' && body.text.trim()
+      ? body.text.trim()
+      : (typeof body.summary === 'string' && body.summary.trim()
+        ? body.summary.trim()
+        : (kind === 'contact_added' && senderDid ? `${senderDid} added you as a contact` : '[message]'));
+    const messageSenderDid = relaySignedSenderDid || senderDid;
+
+    if (kind === 'portal_message' && messageSenderDid && messageSenderDid !== 'did:atel:platform') {
+      if (relaySignedMessage.signature) {
+        const verified = verifyMessage(relaySignedMessage, parseDID(messageSenderDid));
+        if (!verified.valid) {
+          log({ event: 'relay_message_rejected', kind, from: messageSenderDid, reason: 'invalid_signature' });
+          return res.json({ status: 'rejected', error: 'Invalid signature', code: 'INVALID_SIGNATURE' });
+        }
+      }
+
+      const currentPolicy = loadPolicy();
+      const accessCheck = checkP2PMessageAccess(messageSenderDid, currentPolicy);
+      if (!accessCheck.allowed) {
+        log({
+          event: 'p2p_message_rejected',
+          from: messageSenderDid,
+          reason: accessCheck.reason,
+          code: accessCheck.code,
+          timestamp: new Date().toISOString()
+        });
+        return res.json({
+          status: 'rejected',
+          error: accessCheck.message || 'Access denied',
+          code: accessCheck.code,
+          hint: accessCheck.hint
+        });
+      }
+    }
+
+    log({
+      event: 'relay_message_received',
+      kind,
+      from: messageSenderDid || senderDid,
+      text,
+      timestamp: body.timestamp || new Date().toISOString(),
+    });
+
+    if (kind === 'contact_added') {
+      pushP2PNotification('p2p_contact_added', { peerDid: messageSenderDid || senderDid, alias: body.alias || '', text }).catch((e) => log({ event: 'p2p_notify_error', kind, error: e.message }));
+    } else if (kind !== 'telegram_message') {
+      pushP2PNotification('p2p_message_received', { peerDid: messageSenderDid || senderDid, text }).catch((e) => log({ event: 'p2p_notify_error', kind, error: e.message }));
+    }
+
+    res.json({ status: 'ok', kind });
+  });
+
   // Webhook notification: POST /atel/v1/notify
   // SDK only: logs, writes inbox, prints prompt. Does NOT execute any actions.
   // Agent reads inbox or webhook to decide what to do.
@@ -3638,29 +4388,6 @@ Format:
       dedupeKey: body.dedupeKey,
     });
 
-    // ── Fast-coop: auto-submit deliverable when all milestones verified ──
-    // When executor receives the final milestone_verified for a fast-coop order,
-    // sign and submit Escrow::Submit on Fast staging so the Platform can Complete.
-    if (event === 'milestone_verified' && payload.allComplete === true) {
-      const fastOrderId = body.orderId || payload.orderId || '';
-      if (fastOrderId) {
-        // Payload may not include chain — fetch order to check
-        try {
-          const _resp = await fetch(`${PLATFORM_URL}/trade/v1/order/${fastOrderId}`, { signal: AbortSignal.timeout(10000) });
-          const orderInfo = _resp.ok ? await _resp.json() : null;
-          const orderChain = orderInfo?.chain || orderInfo?.Chain || '';
-          if (orderChain === 'fast-coop') {
-            log({ event: 'fast_submit_triggered', orderId: fastOrderId, chain: orderChain });
-            submitFastDeliverable(fastOrderId, id).catch(e => {
-              log({ event: 'fast_submit_error', orderId: fastOrderId, error: e.message });
-            });
-          }
-        } catch (e) {
-          log({ event: 'fast_submit_check_error', orderId: fastOrderId, error: e.message });
-        }
-      }
-    }
-
     const dedupeKey = body.dedupeKey || `${event}:${body.orderId || payload.orderId || ''}`;
     const orderIdForCwd = body.orderId || payload.orderId || '';
     let workspace = getOrderWorkspace(orderIdForCwd, {
@@ -3875,27 +4602,34 @@ Format:
     const localHookTimeoutMs = isMilestoneHook ? 180000 : 600000;
     const preparedInvocation = prepareHookInvocation(spawnCmd, spawnArgs, hookKey, Math.ceil(localHookTimeoutMs / 1000));
     const runHook = (attempt, invocation = preparedInvocation) => {
+      const hookStartedAt = Date.now();
       execFile(invocation.cmd, invocation.args, { timeout: localHookTimeoutMs, cwd: hookCwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
         const errMsg = (err?.message || '') + (stderr || '');
+        const durationMs = Date.now() - hookStartedAt;
         const isSessionLock = errMsg.includes('session file locked') || errMsg.includes('session locked');
         const isNetworkError = err && (err.killed || err.code === 'ETIMEDOUT' || err.code === 'ECONNRESET');
 
         if (isSessionLock && attempt < MAX_ATTEMPTS) {
           // OpenClaw session still held by previous call — wait for lock release then retry
           const delay = 15000 + (attempt * 5000); // 15s, 20s, 25s, 30s
-          log({ event: 'agent_cmd_session_lock', eventType: hookEvent, attempt: attempt + 1, delayMs: delay });
+          log({ event: 'agent_cmd_session_lock', eventType: hookEvent, attempt: attempt + 1, delayMs: delay, duration_ms: durationMs });
           setTimeout(() => runHook(attempt + 1), delay);
         } else if (isNetworkError && attempt < 2) {
-          log({ event: 'agent_cmd_retry', eventType: hookEvent, attempt: attempt + 1, error: err.message });
+          log({ event: 'agent_cmd_retry', eventType: hookEvent, attempt: attempt + 1, error: err.message, duration_ms: durationMs });
           setTimeout(() => runHook(attempt + 1), 10000);
         } else if (err) {
-          log({ event: 'agent_cmd_error', eventType: hookEvent, error: err.message, stderr: (stderr || '').substring(0, 200) });
+          if (err.killed || err.code === 'ETIMEDOUT') {
+            log({ event: 'agent_cmd_timeout', eventType: hookEvent, dedupeKey: hookKey, timeout_ms: localHookTimeoutMs, duration_ms: durationMs, error: err.message, stderr: (stderr || '').substring(0, 200) });
+          } else {
+            log({ event: 'agent_cmd_error', eventType: hookEvent, dedupeKey: hookKey, error: err.message, duration_ms: durationMs, stderr: (stderr || '').substring(0, 200) });
+          }
           finishHook();
         } else if (isKnownUpstreamModelInputError(stdout)) {
           log({
             event: 'agent_cmd_upstream_input_error',
             eventType: hookEvent,
             dedupeKey: hookKey,
+            duration_ms: durationMs,
             note: 'suppressed known upstream model input-length error',
           });
           finishHook();
@@ -3926,21 +4660,21 @@ Format:
               : Promise.resolve(false);
             guardCheck.then(alreadySubmitted => {
             if (alreadySubmitted) {
-              log({ event: 'agent_cmd_done', eventType: hookEvent, mode: 'already_submitted_by_agent', dedupeKey: hookKey });
+              log({ event: 'agent_cmd_done', eventType: hookEvent, mode: 'already_submitted_by_agent', dedupeKey: hookKey, duration_ms: durationMs });
               finishHook();
               return;
             }
             executeRecommendedActionDirect(hookEvent, localAction.action, hookCwd || process.cwd(), hookKey)
               .then((execResult) => {
                 if (execResult.ok) {
-                  log({ event: 'agent_cmd_done', eventType: hookEvent, mode: 'local_stdout_action', dedupeKey: hookKey, stdout: summarizeAgentOutput(stdout, 200) });
+                  log({ event: 'agent_cmd_done', eventType: hookEvent, mode: 'local_stdout_action', dedupeKey: hookKey, duration_ms: durationMs, stdout: summarizeAgentOutput(stdout, 200) });
                 } else {
-                  log({ event: 'agent_cmd_local_action_error', eventType: hookEvent, dedupeKey: hookKey, error: execResult.error || 'local_action_failed', stdout: summarizeAgentOutput(stdout, 200) });
+                  log({ event: 'agent_cmd_local_action_error', eventType: hookEvent, dedupeKey: hookKey, error: execResult.error || 'local_action_failed', duration_ms: durationMs, stdout: summarizeAgentOutput(stdout, 200) });
                 }
                 finishHook();
               })
               .catch((e) => {
-                log({ event: 'agent_cmd_local_action_error', eventType: hookEvent, dedupeKey: hookKey, error: e.message || 'local_action_failed', stdout: summarizeAgentOutput(stdout, 200) });
+                log({ event: 'agent_cmd_local_action_error', eventType: hookEvent, dedupeKey: hookKey, error: e.message || 'local_action_failed', duration_ms: durationMs, stdout: summarizeAgentOutput(stdout, 200) });
                 finishHook();
               });
             return;
@@ -3948,7 +4682,13 @@ Format:
             return;
           }
 
-          log({ event: 'agent_cmd_done', eventType: hookEvent, stdout: summarizeAgentOutput(stdout, 300) });
+          if (localAction.skipped) {
+            log({ event: 'agent_cmd_skipped', eventType: hookEvent, dedupeKey: hookKey, reason: localAction.reason || 'skipped', duration_ms: durationMs, stdout: summarizeAgentOutput(stdout, 200) });
+            finishHook();
+            return;
+          }
+
+          log({ event: 'agent_cmd_local_parse_error', eventType: hookEvent, dedupeKey: hookKey, error: localAction.error || 'invalid_local_agent_stdout', duration_ms: durationMs, stdout: summarizeAgentOutput(stdout, 300) });
           finishHook();
         }
       });
@@ -4507,6 +5247,42 @@ Format:
       };
     }
 
+    if (payload.msgType === 'message') {
+      const text = typeof payload.text === 'string' && payload.text.trim()
+        ? payload.text.trim()
+        : (typeof payload.summary === 'string' && payload.summary.trim() ? payload.summary.trim() : '[message]');
+      const currentPolicy = loadPolicy();
+      const accessCheck = checkP2PMessageAccess(message.from, currentPolicy);
+      if (!accessCheck.allowed) {
+        log({
+          event: 'p2p_message_rejected',
+          from: message.from,
+          reason: accessCheck.reason,
+          code: accessCheck.code,
+          timestamp: new Date().toISOString()
+        });
+        return {
+          status: 'rejected',
+          error: accessCheck.message || 'Access denied',
+          code: accessCheck.code,
+          hint: accessCheck.hint
+        };
+      }
+      log({
+        event: 'relay_message_received',
+        kind: 'portal_message',
+        from: message.from,
+        text,
+        timestamp: new Date().toISOString(),
+      });
+      pushP2PNotification('p2p_message_received', { peerDid: message.from, text }).catch((e) => log({ event: 'p2p_notify_error', kind: 'portal_message', error: e.message }));
+      return {
+        status: 'ok',
+        kind: 'portal_message',
+        msgId: payload.msgId || null,
+      };
+    }
+
     // Ignore task-result messages (these are responses, not new tasks)
     if (message.type === 'task-result' || payload.status === 'completed' || payload.status === 'failed') {
       log({ event: 'result_received', type: 'task-result', from: message.from, taskId: payload.taskId, status: payload.status, proof: payload.proof || null, anchor: payload.anchor || null, execution: payload.execution || null, result: payload.result || null, timestamp: new Date().toISOString() });
@@ -4805,8 +5581,10 @@ Format:
 
   await endpoint.start();
 
-  // Auto-bind TG notifications on first start
-  try { autoBindNotifications(); } catch (e) { /* never block startup */ }
+  // Telegram notifications are opt-in by default. Only auto-bind when explicit consent was already collected.
+  if (ATEL_NOTIFY_AUTO_BIND) {
+    try { autoBindNotifications(); } catch (e) { /* never block startup */ }
+  }
 
   // Background retry for failed result pushes (durable queue)
   const flushResultPushQueue = async () => {
@@ -4945,21 +5723,30 @@ Format:
           try {
             req = typeof inner === 'string' ? JSON.parse(inner) : inner;
           } catch (e) {
-            if (m.id) failedIds.push(m.id);
-            log({ event: 'relay_message_parse_error', id: m.id, error: e.message, rawType: typeof inner });
+            if (m.id) ackedIds.push(m.id);
+            log({ event: 'relay_message_parse_error_acked', id: m.id, error: e.message, rawType: typeof inner });
             continue;
           }
 
           try {
+            if (isLegacyPassiveRelayMessage(req)) {
+              req = buildPassiveRelayRequest(req, m.sender || '');
+            }
+            if (isAckableMalformedRelayMessage(req, inner)) {
+              if (m.id) ackedIds.push(m.id);
+              log({ event: 'relay_message_invalid_acked', id: m.id, path: typeof req?.path === 'string' && req.path.trim() ? req.path.trim() : '/', note: 'empty_or_invalid_relay_message' });
+              continue;
+            }
             const method = req.method || 'POST';
-            const path = req.path || '/';
+            const path = typeof req.path === 'string' ? req.path.trim() : '';
+            const body = req.body && typeof req.body === 'object' ? req.body : {};
             const fetchOpts = {
               method,
               headers: { 'Content-Type': 'application/json' },
               signal: AbortSignal.timeout(30000),
             };
-            if (method !== 'GET' && method !== 'HEAD') fetchOpts.body = JSON.stringify(req.body || {});
-            const localUrl = `http://127.0.0.1:${p}${path}`;
+            if (method !== 'GET' && method !== 'HEAD') fetchOpts.body = JSON.stringify(body);
+            const localUrl = `http://127.0.0.1:${p}${path || '/'}`;
             const localResp = await fetch(localUrl, fetchOpts);
             const rawText = await localResp.text();
             let parsed;
@@ -5020,6 +5807,23 @@ Format:
     }, 120000);
   }
 
+  let telegramInboundBusy = false;
+  const pollTelegramInbound = async () => {
+    if (telegramInboundBusy) return;
+    telegramInboundBusy = true;
+    try {
+      await pollTelegramInboundUpdates(id.did);
+    } catch (e) {
+      log({ event: 'telegram_inbound_poll_error', did: id.did, error: e.message || 'unknown_error' });
+    } finally {
+      telegramInboundBusy = false;
+    }
+  };
+  pollTelegramInbound().catch((e) => log({ event: 'telegram_inbound_poll_bootstrap_error', did: id.did, error: e.message || 'unknown_error' }));
+  setInterval(() => {
+    pollTelegramInbound().catch((e) => log({ event: 'telegram_inbound_poll_interval_error', did: id.did, error: e.message || 'unknown_error' }));
+  }, 4000);
+
   console.log(JSON.stringify({
     status: 'listening', agent_id: id.agent_id, did: id.did,
     port: p, candidates: networkConfig.candidates || [], capabilities: capTypes,
@@ -5099,10 +5903,16 @@ Format:
 
 async function cmdInbox(count) {
   const n = parseInt(count || '20');
-  if (!existsSync(INBOX_FILE)) { console.log(JSON.stringify({ messages: [], count: 0 })); return; }
+  if (!existsSync(INBOX_FILE)) {
+    console.log(JSON.stringify({ messages: [], count: 0, total: 0, filteredOut: 0 }, null, 2));
+    return;
+  }
   const lines = readFileSync(INBOX_FILE, 'utf-8').trim().split('\n').filter(Boolean);
-  const messages = lines.slice(-n).map(l => JSON.parse(l));
-  console.log(JSON.stringify({ messages, count: messages.length, total: lines.length }, null, 2));
+  const parsed = lines.map((line) => {
+    try { return JSON.parse(line); } catch { return null; }
+  }).filter(Boolean);
+  const messages = parsed.filter(isHumanInboxEntry).slice(-n);
+  console.log(JSON.stringify({ messages, count: messages.length, total: parsed.length, filteredOut: parsed.length - messages.length }, null, 2));
 }
 
 async function cmdRegister(name, capabilities, endpointUrl) {
@@ -5857,7 +6667,8 @@ async function signedFetch(method, path, payload = {}) {
 // ─── Auth Command ────────────────────────────────────────────────
 
 async function cmdAuth(code) {
-  if (!code) {
+  const normalizedCode = (code || '').trim().toUpperCase();
+  if (!normalizedCode) {
     console.error('Usage: atel auth <code>');
     console.error('  Authorize a Dashboard session using the code displayed on the login page.');
     process.exit(1);
@@ -5867,7 +6678,7 @@ async function cmdAuth(code) {
   const { serializePayload } = await import('@lawrenceliang-btc/atel-sdk');
 
   const ts = new Date().toISOString();
-  const payload = { code: code.toUpperCase(), did: id.did, timestamp: ts };
+  const payload = { code: normalizedCode, did: id.did, timestamp: ts };
   const signable = serializePayload({ payload, did: id.did, timestamp: ts });
   const sig = Buffer.from(nacl.sign.detached(Buffer.from(signable), id.secretKey)).toString('base64');
 
@@ -5875,7 +6686,7 @@ async function cmdAuth(code) {
     const resp = await fetch(`${ATEL_PLATFORM}/auth/v1/verify`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ code: code.toUpperCase(), did: id.did, signature: sig, timestamp: ts }),
+      body: JSON.stringify({ code: normalizedCode, did: id.did, signature: sig, timestamp: ts }),
     });
     const data = await resp.json();
     if (resp.ok) {
@@ -6014,19 +6825,11 @@ async function cmdTransactions() {
 // ─── Trade Task: High-level one-shot command ────────────────────
 async function cmdTradeTask(capability, description) {
   if (!capability) { console.error('Usage: atel trade-task <capability> <description> [--budget N] [--executor DID] [--timeout 300]'); process.exit(1); }
-  if (!description || !description.trim()) {
-    console.error('Error: <description> is required and must contain the full task description.');
-    console.error('       The executor can only understand what to do via this field.');
-    console.error('       Pass the user\'s original task text verbatim, e.g.:');
-    console.error('         atel trade-task <capability> "<full user message>" --budget 5');
-    console.error('       Do NOT summarize, translate, or shorten the user\'s request.');
-    process.exit(2);
-  }
   const id = requireIdentity();
   const budget = parseFloat(rawArgs.find((a, i) => rawArgs[i-1] === '--budget') || '0');
   const executorArg = rawArgs.find((a, i) => rawArgs[i-1] === '--executor') || '';
   const timeout = parseInt(rawArgs.find((a, i) => rawArgs[i-1] === '--timeout') || '300') * 1000;
-  const desc = description;
+  const desc = description || capability;
 
   // Step 1: Find executor
   let executorDid = executorArg;
@@ -6048,7 +6851,6 @@ async function cmdTradeTask(capability, description) {
   console.error(`[trade-task] Creating order: ${capability}, budget: $${budget}...`);
   const orderData = await signedFetch('POST', '/trade/v1/order', {
     executorDid, capabilityType: capability, priceAmount: budget, priceCurrency: 'USD', pricingModel: 'per_task',
-    description: desc,
   });
   const orderId = orderData.orderId;
   console.error(`[trade-task] Order created: ${orderId}`);
@@ -6096,27 +6898,12 @@ async function cmdTradeTask(capability, description) {
 }
 
 async function cmdOrder(executorDid, capType, price) {
-  if (!executorDid || !capType || !price) { console.error('Usage: atel order <executorDid> <capabilityType> <price> --desc "task description"'); process.exit(1); }
+  if (!executorDid || !capType || !price) { console.error('Usage: atel order <executorDid> <capabilityType> <price> [--desc "task description"]'); process.exit(1); }
   // Resolve @alias to full DID
   if (executorDid.startsWith('@')) {
     try { executorDid = resolveDID(executorDid); } catch (e) { console.error(e.message); process.exit(1); }
   }
   const description = rawArgs.find((a, i) => rawArgs[i-1] === '--desc') || '';
-  // --desc is MANDATORY: the executor can only see the task via this field.
-  // An empty description would make the executor work from its own imagination
-  // (see production incident 2026-04-09, order ord-4c12a03d-ea8 where the
-  // executor generated an off-topic "system validation" milestone because
-  // orderDescription arrived empty). We fail loudly here so the caller
-  // (human or ReAct agent loop) gets an actionable error and can retry
-  // with the real task text from the user's message.
-  if (!description || !description.trim()) {
-    console.error('Error: --desc is required and must contain the full task description.');
-    console.error('       The executor can only understand what to do via --desc.');
-    console.error('       Pass the user\'s original task text verbatim, e.g.:');
-    console.error('         atel order <executorDid> <capability> <price> --desc "<full user message>"');
-    console.error('       Do NOT summarize, translate, or shorten the user\'s request.');
-    process.exit(2);
-  }
   const chainArg = rawArgs.find((a, i) => rawArgs[i-1] === '--chain') || '';
   const id = requireIdentity();
   
@@ -6191,6 +6978,7 @@ async function cmdOrder(executorDid, capType, price) {
     };
     if (chainArg) { orderBody.chain = chainArg; }
     const data = await signedFetch('POST', '/trade/v1/order', orderBody);
+    if (data?.orderId) trackOrder(data.orderId, 'requester');
     
     // For paid orders: show escrow info (chain escrow creation handled by Platform backend)
     if (data.orderId && parseFloat(price) > 0 && data.escrow?.escrowContract) {
@@ -6766,6 +7554,7 @@ async function cmdComplete(orderId, taskId) {
 async function cmdConfirm(orderId) {
   if (!orderId) { console.error('Usage: atel confirm <orderId>'); process.exit(1); }
   const data = await signedFetch('POST', `/trade/v1/order/${orderId}/confirm`);
+  rememberCurrentTelegramRoute(orderId);
   console.log(JSON.stringify(data, null, 2));
 }
 
@@ -6823,6 +7612,7 @@ async function cmdMilestoneFeedback(orderId) {
 
   const payload = approve ? { approved: true } : { approved: false, feedback };
   const data = await signedFetch('POST', `/trade/v1/order/${orderId}/milestones/feedback`, payload);
+  rememberCurrentTelegramRoute(orderId);
   console.log(JSON.stringify(data, null, 2));
 }
 
@@ -6894,6 +7684,7 @@ async function cmdMilestoneSubmit(orderId, indexStr) {
     resultSummary: resultText,
     resultHash,
   });
+  rememberCurrentTelegramRoute(orderId);
   console.log(JSON.stringify(data, null, 2));
 }
 
@@ -6943,9 +7734,11 @@ async function cmdMilestoneVerify(orderId, indexStr) {
       process.exit(1);
     }
     const data = await signedFetch('POST', `/trade/v1/order/${orderId}/milestone/${indexStr}/verify`, { passed: false, rejectReason });
+    rememberCurrentTelegramRoute(orderId);
     console.log(JSON.stringify(data, null, 2));
   } else {
     const data = await signedFetch('POST', `/trade/v1/order/${orderId}/milestone/${indexStr}/verify`, { passed: true });
+    rememberCurrentTelegramRoute(orderId);
     console.log(JSON.stringify(data, null, 2));
   }
 }
@@ -7849,35 +8642,130 @@ async function cmdFriendStatus(args) {
 // ─── P2P Send Helper ────────────────────────────────────────────
 // Resolves DID → endpoint via registry, then sends a signed message.
 // Replaces the previously undefined sendP2PMessage.
+function extractCapabilityTypes(capabilities) {
+  if (!Array.isArray(capabilities)) return [];
+  return capabilities.map((cap) => {
+    if (typeof cap === 'string') return cap.trim().toLowerCase();
+    if (cap && typeof cap === 'object' && typeof cap.type === 'string') return cap.type.trim().toLowerCase();
+    return '';
+  }).filter(Boolean);
+}
+
 async function sendP2PMessage(targetDid, signedMsg) {
   const id = loadIdentity();
   if (!id) throw new Error('No identity found');
 
   let endpoint = null;
+  let relayEndpoint = '';
   try {
     const resp = await fetch(`${REGISTRY_URL}/registry/v1/agent/${encodeURIComponent(targetDid)}`, { signal: AbortSignal.timeout(5000) });
     if (resp.ok) {
       const entry = await resp.json();
-      const candidates = entry.endpoint_candidates || [];
+      const candidates = entry.endpoint_candidates || entry.candidates || [];
+      const local  = candidates.find(c => c.type === 'local');
       const direct = candidates.find(c => c.type === 'direct');
       const relay  = candidates.find(c => c.type === 'relay');
-      endpoint = direct?.url || relay?.url || entry.endpoint;
+      endpoint = local?.url || direct?.url || relay?.url || entry.endpoint;
+      relayEndpoint = relay?.url || '';
     }
   } catch (e) {
-    throw new Error(`Registry lookup failed for ${targetDid}: ${e.message}`);
+    log({ event: 'p2p_registry_lookup_failed', to: targetDid, error: e.message });
+  }
+
+  const tryRelayFallback = async (reason) => {
+    const base = relayEndpoint || process.env.ATEL_RELAY || process.env.ATEL_PLATFORM || REGISTRY_URL;
+    if (!base) throw new Error(reason || `No reachable endpoint for ${targetDid}`);
+    const relayUrl = `${String(base).replace(/\/+$/, '')}/relay/v1/respond/${encodeURIComponent(targetDid)}`;
+    const resp = await fetch(relayUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sender: id.did, message: signedMsg }),
+      signal: AbortSignal.timeout(8000),
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      throw new Error(`${reason || 'direct_send_failed'}; relay fallback ${resp.status}: ${text || 'unknown error'}`);
+    }
+    log({ event: 'p2p_relay_fallback_ok', to: targetDid, relay: relayUrl, reason });
+    return { status: 'queued_via_relay', relay: relayUrl };
+  };
+
+  if (!endpoint) {
+    return await tryRelayFallback(`no_reachable_endpoint_for_${targetDid}`);
   }
-  if (!endpoint) throw new Error(`No reachable endpoint for ${targetDid}`);
 
   const hsManager = new HandshakeManager(id);
   const client    = new AgentClient(id);
-  return await client.sendTask(endpoint, signedMsg, hsManager);
+  try {
+    return await client.sendTask(endpoint, signedMsg, hsManager);
+  } catch (e) {
+    log({ event: 'p2p_direct_send_failed', to: targetDid, endpoint, error: e.message });
+    return await tryRelayFallback(`direct_send_failed:${e.message}`);
+  }
+}
+
+async function sendPortalMessage(targetDid, messageBody, options = {}) {
+  const id = loadIdentity();
+  if (!id) throw new Error('No identity found');
+
+  const relayEndpoint = String(options.relayEndpoint || '').trim();
+  const directEndpoint = String(options.directEndpoint || '').trim();
+  const signedEnvelope = options.signedEnvelope || null;
+
+  const tryRelayFallback = async (reason) => {
+    const base = relayEndpoint || process.env.ATEL_RELAY || process.env.ATEL_PLATFORM || REGISTRY_URL;
+    if (!base || !targetDid) throw new Error(reason || `No reachable endpoint for ${targetDid || 'target'}`);
+    const relayUrl = `${String(base).replace(/\/+$/, '')}/relay/v1/respond/${encodeURIComponent(targetDid)}`;
+    const resp = await fetch(relayUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sender: id.did, message: messageBody }),
+      signal: AbortSignal.timeout(8000),
+    });
+    const raw = await resp.text().catch(() => '');
+    let parsed = null;
+    try { parsed = raw ? JSON.parse(raw) : null; } catch {}
+    if (!resp.ok) throw new Error(`${reason || 'direct_send_failed'}; relay fallback ${resp.status}: ${raw || 'unknown error'}`);
+    log({ event: 'p2p_message_relay_fallback_ok', to: targetDid, relay: relayUrl, reason });
+    return { status: 'queued_via_relay', relay: relayUrl, result: parsed };
+  };
+
+  if (directEndpoint) {
+    const directUrl = `${String(directEndpoint).replace(/\/+$/, '')}/atel/v1/task`;
+    try {
+      const resp = await fetch(directUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(signedEnvelope || messageBody),
+        signal: AbortSignal.timeout(8000),
+      });
+      const raw = await resp.text().catch(() => '');
+      let parsed = null;
+      try { parsed = raw ? JSON.parse(raw) : null; } catch {}
+      if (!resp.ok) {
+        throw new Error(`direct_send ${resp.status}: ${raw || 'unknown error'}`);
+      }
+      if (parsed && (parsed.status === 'rejected' || parsed.status === 'error')) {
+        return { status: parsed.status, direct: directUrl, result: parsed };
+      }
+      return { status: 'delivered', direct: directUrl, result: parsed };
+    } catch (e) {
+      log({ event: 'p2p_message_direct_send_failed', to: targetDid || directEndpoint, endpoint: directEndpoint, error: e.message });
+      if (targetDid) {
+        return await tryRelayFallback(`direct_send_failed:${e.message}`);
+      }
+      throw e;
+    }
+  }
+
+  return await tryRelayFallback(`no_reachable_endpoint_for_${targetDid}`);
 }
 
 // ─── Send Command (Rich Media P2P Messaging) ─────────────────────
 
 function showSendHelp() {
   console.log(`
-atal send — Send a message (with optional rich media) to another agent
+atel send — Send a message (with optional rich media) to another agent
 
 Usage:
   atel send <did|alias|endpoint> "message text"
@@ -7900,6 +8788,10 @@ Notes:
   and ask the other side to accept with:
     atel friend accept <request-id>
 
+  Some agents do not expose the "general" capability needed for free-form
+  chat messages. If you get an "outside capability boundary" rejection,
+  enable "general" on the recipient or use atel task / atel order instead.
+
   To disable the friend requirement on your own agent, set in policy.json:
     { "relationshipPolicy": { "defaultMode": "open" } }
 
@@ -7962,6 +8854,8 @@ async function cmdSend(args) {
   // Resolve target → endpoint + remoteDid
   let remoteEndpoint = target;
   let remoteDid;
+  let registryEntry = null;
+  let remoteRelayEndpoint = '';
 
   // Resolve @alias
   try { const r = resolveDID(target); if (r !== target) remoteEndpoint = r; } catch (_) {}
@@ -7979,11 +8873,14 @@ async function cmdSend(args) {
       if (results.length > 0) entry = results[0];
     }
     if (!entry) { console.error(`Agent not found: ${target}`); process.exit(1); }
+    registryEntry = entry;
     remoteDid = entry.did;
-    const candidates = entry.endpoint_candidates || [];
+    const candidates = entry.endpoint_candidates || entry.candidates || [];
+    const local  = candidates.find(c => c.type === 'local');
     const direct = candidates.find(c => c.type === 'direct');
     const relay  = candidates.find(c => c.type === 'relay');
-    remoteEndpoint = direct?.url || relay?.url || entry.endpoint;
+    remoteRelayEndpoint = relay?.url || '';
+    remoteEndpoint = local?.url || direct?.url || (entry.endpoint && entry.endpoint !== remoteRelayEndpoint ? entry.endpoint : '');
   } else {
     remoteDid = target.startsWith('did:') ? target : undefined;
     // Try to get remoteDid from handshake cache for direct endpoints
@@ -8001,14 +8898,38 @@ async function cmdSend(args) {
     process.exit(1);
   }
 
+  // IM-style messages are relationship-gated, not capability-gated.
+
   // Send
   try {
-    const hsManager = new HandshakeManager(id);
-    const client    = new AgentClient(id);
-    const msg       = createMessage({ type: 'task', from: id.did, to: remoteDid || remoteEndpoint, payload, secretKey: id.secretKey });
-    const result    = await client.sendTask(remoteEndpoint, msg, hsManager);
+    const messagePayload = {
+      msgType: 'message',
+      msgId,
+      text,
+      images: payload.images,
+      attachments: payload.attachments,
+      timestamp: payload.timestamp,
+    };
+    const msg = createMessage({
+      type: 'task_delegate',
+      from: id.did,
+      to: remoteDid || remoteEndpoint,
+      payload: messagePayload,
+      secretKey: id.secretKey,
+    });
+    const messageBody = {
+      ...messagePayload,
+      from: msg.from,
+      to: msg.to,
+      type: msg.type,
+      payload: msg.payload,
+      nonce: msg.nonce,
+      envelope: msg.envelope,
+      signature: msg.signature,
+      timestamp: msg.timestamp,
+    };
+    const result = await sendPortalMessage(remoteDid, messageBody, { directEndpoint: remoteEndpoint, relayEndpoint: remoteRelayEndpoint, signedEnvelope: msg });
 
-    // Surface friendly errors
     const inner = result?.result;
     if (inner?.code === 'NOT_FRIEND' || inner?.error?.includes('NOT_FRIEND') || inner?.error?.includes('not a friend')) {
       if (isJson) {
@@ -8020,19 +8941,28 @@ async function cmdSend(args) {
       }
       process.exit(1);
     }
-    if (inner?.status === 'rejected') {
+    if (inner?.status === 'rejected' || result?.status === 'rejected') {
+      const rejectionMessage = inner?.error || 'Message rejected';
       if (isJson) {
-        console.log(JSON.stringify({ status: 'error', message: inner.error || 'Message rejected', result }));
+        console.log(JSON.stringify({
+          status: 'error',
+          code: inner?.code,
+          message: rejectionMessage,
+          hint: inner?.hint,
+          result
+        }));
       } else {
-        console.error(`✗ Message rejected: ${inner.error || 'unknown reason'}`);
+        console.error('✗ Message rejected: ' + rejectionMessage);
+        if (inner?.hint) console.error('  ' + inner.hint);
       }
       process.exit(1);
     }
 
     if (isJson) {
-      console.log(JSON.stringify({ status: 'sent', msgId, to: remoteDid || remoteEndpoint, attachments: (payload.images?.length || 0) + (payload.attachments?.length || 0), result }, null, 2));
+      console.log(JSON.stringify({ status: 'sent', msgId, to: remoteDid || remoteEndpoint, attachments: (payload.images?.length || 0) + (payload.attachments?.length || 0), delivery: result }, null, 2));
     } else {
-      console.log(`✓ Message sent to ${remoteDid || remoteEndpoint}`);
+      const deliveryLabel = result?.status === 'queued_via_relay' ? 'queued via relay' : 'sent';
+      console.log(`✓ Message ${deliveryLabel} to ${remoteDid || remoteEndpoint}`);
       if (payload.images?.length)      console.log(`  Images:      ${payload.images.length}`);
       if (payload.attachments?.length) console.log(`  Attachments: ${payload.attachments.length}`);
     }
@@ -8392,130 +9322,6 @@ async function cmdAliasRemove(args) {
 
 // ─── Main ────────────────────────────────────────────────────────
 
-// ── Fast-coop: Executor auto-submit deliverable to Fast escrow ──────
-// Called when executor receives milestone_verified with allComplete=true
-// for a fast-coop order. Signs Escrow::Submit with the agent's DID
-// private key (= Fast Ed25519 account key).
-async function submitFastDeliverable(orderId, identity) {
-  try {
-    // 1. Get order info
-    const orderResp = await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}`, { signal: AbortSignal.timeout(10000) });
-    if (!orderResp.ok) throw new Error(`order fetch failed: ${orderResp.status}`);
-    const orderInfo = await orderResp.json();
-    const chain = orderInfo.chain || orderInfo.Chain || '';
-    if (chain !== 'fast-coop') return;
-
-    // 2. Find escrow job_id from chain-records
-    const recordsResp = await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}`, {
-      signal: AbortSignal.timeout(10000),
-    });
-    // The job_id is stored in the on_chain_records by the Platform.
-    // We need to get it from the order or from the chain-records endpoint.
-    // For now, compute it the same way Platform does: keccak256(orderId)
-    const { createHash } = await import('node:crypto');
-
-    // 3. Get the agent's Fast account info
-    const FAST_RPC = process.env.ATEL_FASTCOOP_RPC_URL || 'https://staging.api.fast.xyz/proxy-rest';
-    const pubKeyHex = Buffer.from(identity.publicKey).toString('hex');
-
-    const accountResp = await fetch(`${FAST_RPC}/v1/accounts/${pubKeyHex}`, {
-      signal: AbortSignal.timeout(10000),
-    });
-    if (!accountResp.ok) throw new Error(`Fast account query failed: ${accountResp.status}`);
-    const accountData = (await accountResp.json()).data;
-    const nonce = accountData.next_nonce;
-
-    // 4. Find escrow job for this order (query by provider)
-    const jobsResp = await fetch(`${FAST_RPC}/v1/escrow-jobs?provider=${pubKeyHex}&status=Funded`, {
-      signal: AbortSignal.timeout(10000),
-    });
-    if (!jobsResp.ok) throw new Error(`escrow jobs query failed: ${jobsResp.status}`);
-    const jobs = (await jobsResp.json()).data || [];
-    const job = jobs.find(j => j.description && j.description.includes(orderId));
-    if (!job) {
-      log({ event: 'fast_submit_no_job', orderId, note: 'no Funded escrow job found for this order' });
-      return;
-    }
-
-    // 5. Build Escrow::Submit transaction
-    // deliverable = keccak256(orderId) as 32-byte hash
-    const deliverableHash = createHash('sha3-256').update(orderId).digest('hex');
-
-    // BCS encode: Operation::Escrow(12) → Escrow::Submit(2) → jobId(32) + deliverable(32)
-    const jobIdBytes = Buffer.from(job.job_id, 'hex');
-    const deliverableBytes = Buffer.from(deliverableHash, 'hex');
-
-    // Build minimal BCS by hand (matching Go implementation):
-    // ULEB128(12) = 0x0c, ULEB128(2) = 0x02, then 32+32 bytes
-    const claimBytes = Buffer.concat([
-      Buffer.from([0x0c]),        // Operation::Escrow variant 12
-      Buffer.from([0x02]),        // Escrow::Submit variant 2
-      jobIdBytes.subarray(0, 32), // job_id 32 bytes
-      deliverableBytes.subarray(0, 32), // deliverable 32 bytes
-    ]);
-
-    // Transaction BCS: VersionedTransaction variant 1 (Release20260407)
-    const networkId = process.env.ATEL_FASTCOOP_NETWORK_ID || 'fast:devnet';
-    const senderBytes = Buffer.from(identity.publicKey);
-    const tsNanos = BigInt(Date.now()) * 1000000n;
-
-    // ULEB128 encoder
-    const uleb128 = (v) => {
-      const buf = [];
-      do { let b = Number(v & 0x7fn); v >>= 7n; if (v > 0n) b |= 0x80; buf.push(b); } while (v > 0n);
-      return Buffer.from(buf.length ? buf : [0]);
-    };
-    const u64le = (v) => { const b = Buffer.alloc(8); b.writeBigUInt64LE(BigInt(v)); return b; };
-    const u128le = (v) => { const b = Buffer.alloc(16); b.writeBigUInt64LE(v & 0xffffffffffffffffn); b.writeBigUInt64LE(v >> 64n, 8); return b; };
-    const bcsString = (s) => { const b = Buffer.from(s, 'utf-8'); return Buffer.concat([uleb128(BigInt(b.length)), b]); };
-
-    // Transaction body
-    const txBody = Buffer.concat([
-      bcsString(networkId),
-      senderBytes.subarray(0, 32),
-      u64le(nonce),
-      u128le(tsNanos),
-      uleb128(1n), // claims vector length = 1
-      claimBytes,
-      Buffer.from([0x00]), // archival = false
-      Buffer.from([0x00]), // fee_token = None
-    ]);
-
-    // VersionedTransaction = enum variant 1
-    const versionedTx = Buffer.concat([uleb128(1n), txBody]);
-
-    // 6. Sign
-    const { default: nacl } = await import('tweetnacl');
-    const sigMessage = Buffer.concat([Buffer.from('VersionedTransaction::'), versionedTx]);
-    const signature = nacl.sign.detached(sigMessage, identity.secretKey);
-
-    // SignatureOrMultiSig::Signature = variant 0 + 64 bytes
-    const bcsSig = Buffer.concat([Buffer.from([0x00]), Buffer.from(signature)]);
-
-    // 7. Submit to Fast
-    const submitResp = await fetch(`${FAST_RPC}/v1/submit-transaction`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        transaction: versionedTx.toString('hex'),
-        signature: bcsSig.toString('hex'),
-      }),
-      signal: AbortSignal.timeout(15000),
-    });
-
-    const submitResult = await submitResp.json();
-    if (submitResult.error) {
-      throw new Error(`Fast submit failed: ${submitResult.error.message || JSON.stringify(submitResult.error)}`);
-    }
-
-    log({ event: 'fast_submit_success', orderId, jobId: job.job_id, nonce });
-    console.log(`⚡ [Fast] Deliverable submitted for ${orderId} (job: ${job.job_id.substring(0, 16)}...)`);
-  } catch (e) {
-    log({ event: 'fast_submit_error', orderId, error: e.message });
-    console.error(`⚠️  [Fast] Submit failed for ${orderId}: ${e.message}`);
-  }
-}
-
 const [,, cmd, ...rawArgs] = process.argv;
 const args = rawArgs.filter(a => !a.startsWith('--'));
 const commands = {
@@ -8726,6 +9532,7 @@ const commands = {
         createdAt: new Date().toISOString(), lastUsedAt: null,
       });
       saveNotifyTargets(targets);
+      rememberTelegramRoute(chatId, botToken || undefined);
       console.log(`✅ Bound TG chat ${chatId} as notification target (id: ${id})`);
       if (!botToken) console.log('⚠️  No bot token found. Set TELEGRAM_BOT_TOKEN or use --bot-token');
       return;
@@ -8845,7 +9652,7 @@ Protocol Commands:
   setup [port]                         Configure network (detect IP, UPnP, verify)
   verify                               Verify port reachability
   start [port]                         Start endpoint (auto network + auto register)
-  inbox [count]                        Show received messages (default: 20)
+  inbox [count]                        Show received messages / notifications (default: 20)
   register [name] [caps] [endpoint]    Register on public registry (caps: "type1:price1,type2:price2" or "type1,type2" for free)
   search <capability>                  Search registry for agents (shows pricing info)
   handshake <endpoint> [did]           Handshake with remote agent