@lawrenceliang-btc/atel-sdk 1.0.0 → 1.0.2

package/bin/atel.mjs

@@ -89,7 +89,7 @@ const RESULT_PUSH_QUEUE_FILE = resolve(ATEL_DIR, 'pending-result-pushes.json');
 const KEYS_DIR = resolve(ATEL_DIR, 'keys');
 const ANCHOR_FILE = resolve(KEYS_DIR, 'anchor.json');
 
-const DEFAULT_POLICY = { rateLimit: 60, maxPayloadBytes: 1048576, maxConcurrent: 10, allowedDIDs: [], blockedDIDs: [], taskMode: 'auto', autoAcceptPlatform: true, autoAcceptP2P: true, trustPolicy: { minScore: 0, newAgentPolicy: 'allow_low_risk', riskThresholds: { low: 0, medium: 50, high: 75, critical: 90 } } };
+const DEFAULT_POLICY = { rateLimit: 60, maxPayloadBytes: 1048576, maxConcurrent: 10, allowedDIDs: [], blockedDIDs: [], taskMode: 'auto', autoAcceptPlatform: true, autoAcceptP2P: true, agentMode: 'manual', autoPolicy: { acceptOrders: false, acceptMaxAmount: 0, autoApprovePlan: false }, trustPolicy: { minScore: 0, newAgentPolicy: 'allow_low_risk', riskThresholds: { low: 0, medium: 50, high: 75, critical: 90 } } };
 
 // ─── Helpers ─────────────────────────────────────────────────────
 
@@ -1946,13 +1946,23 @@ async function cmdStart(port) {
   const toolGatewayServer = await startToolGatewayProxy(toolProxyPort, id, policy);
   log({ event: 'tool_gateway_started', port: toolProxyPort });
 
-  // ── Executor: Agent brings their own AI. SDK does not run a built-in executor. ──
-  // If ATEL_EXECUTOR_URL is set, P2P tasks are forwarded there.
-  // Milestone work is done by the Agent itself (not the SDK).
-  if (EXECUTOR_URL) {
-    log({ event: 'external_executor_configured', url: EXECUTOR_URL });
+  // ── Agent AI integration ──
+  // Auto-detect OpenClaw for agent hook
+  let detectedAgentCmd = process.env.ATEL_AGENT_CMD || '';
+  if (!detectedAgentCmd) {
+    try {
+      const { execSync } = await import('child_process');
+      execSync('which openclaw', { stdio: 'ignore' });
+      detectedAgentCmd = 'openclaw agent --agent main --local -m';
+      log({ event: 'agent_hook_auto_detected', cmd: 'openclaw', note: 'Notifications will auto-trigger OpenClaw agent' });
+      console.log('🤝 OpenClaw detected — agent hook enabled (notifications auto-trigger your AI)');
+    } catch {
+      log({ event: 'no_agent_hook', note: 'No OpenClaw or ATEL_AGENT_CMD. Notifications write to inbox only.' });
+      console.log('📋 No agent AI detected. Notifications go to .atel/inbox.jsonl — process manually or set ATEL_AGENT_CMD.');
+    }
   } else {
-    log({ event: 'no_executor', note: 'No ATEL_EXECUTOR_URL set. Agent handles tasks via notifications + CLI.' });
+    log({ event: 'agent_hook_configured', cmd: detectedAgentCmd });
+    console.log(`🤝 Agent hook: ${detectedAgentCmd.substring(0, 50)}...`);
   }
 
   // ── Trust Score Client (persistent) ──
@@ -2112,8 +2122,8 @@ async function cmdStart(port) {
     // Log the full event
     log({ event: 'notification_received', eventId, eventType: event, orderId: body.orderId || payload.orderId, prompt: prompt ? prompt.substring(0, 100) : undefined });
 
-    // ── Universal notification handler: print prompt + log + respond ──
-    // SDK does NOT execute any actions. Agent reads inbox/webhook and decides.
+    // ── Universal notification handler ──
+    // 1. Print prompt + recommended actions
     if (prompt) {
       console.log(`\n📨 [${event}] ${prompt.split('\n')[0]}`);
     }
@@ -2124,7 +2134,7 @@ async function cmdStart(port) {
     }
     console.log('');
 
-    // Write full event to inbox for Agent program to read
+    // 2. Write full event to inbox for Agent program to read
     log({
       event: 'notification',
       eventId,
@@ -2137,441 +2147,88 @@ async function cmdStart(port) {
       dedupeKey: body.dedupeKey,
     });
 
-    res.json({ status: 'received', eventId, eventType: event });
-    return;
-
-    // ── Legacy event handlers below (kept but unreachable for reference) ──
-    if (event === 'order_created_legacy') {
-      // New order notification - decide whether to accept
-      const { orderId, requesterDid, capabilityType, priceAmount, description } = payload;
-      
-      // ── Blacklist Check (Order System) ──
-      // Note: Order system only checks blacklist, not friend relationships.
-      // Platform-mediated orders (like Taobao) should allow strangers to place orders.
-      // P2P tasks use full friend system checks via checkP2PAccess().
-      const currentPolicy = loadPolicy();
-      if (currentPolicy.blockedDIDs && currentPolicy.blockedDIDs.includes(requesterDid)) {
-        log({ 
-          event: 'order_rejected_blacklist', 
-          orderId, 
-          requesterDid, 
-          reason: 'did_blocked' 
-        });
-        
-        // Reject via Platform API
-        try {
-          const timestamp = new Date().toISOString();
-          const rejectPayload = { reason: 'DID is blocked' };
-          const signPayload = { did: id.did, timestamp, payload: rejectPayload };
-          const signature = sign(signPayload, id.secretKey);
-          
-          await fetch(`${ATEL_PLATFORM}/trade/v1/order/${orderId}/reject`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ 
-              did: id.did, 
-              timestamp, 
-              signature, 
-              payload: rejectPayload 
-            }),
-            signal: AbortSignal.timeout(10000),
-          });
-          
-          log({ event: 'order_rejected_api_called', orderId });
-        } catch (e) { 
-          log({ 
-            event: 'order_reject_api_error', 
-            orderId, 
-            error: e.message 
-          }); 
-        }
-        
-        res.json({ 
-          status: 'rejected', 
-          reason: 'did_blocked',
-          message: 'This DID is blocked'
-        });
-        return;
-      }
-      
-      // Check capability match
-      if (!capTypes.includes(capabilityType)) {
-        log({ event: 'order_rejected', orderId, reason: 'capability_mismatch', required: capabilityType, available: capTypes });
-        res.json({ status: 'rejected', reason: 'capability not supported' });
-        return;
-      }
-
-      // ── Task Mode Check ──
-      const taskMode = currentPolicy.taskMode || 'auto';
-      
-      if (taskMode === 'off') {
-        log({ event: 'order_rejected_mode_off', orderId, requesterDid, capabilityType });
-        // Reject via Platform API
-        try {
-          const timestamp = new Date().toISOString();
-          const rejectPayload = { reason: 'Agent task mode is off' };
-          const signPayload = { did: id.did, timestamp, payload: rejectPayload };
-          const signature = sign(signPayload, id.secretKey);
-          await fetch(`${ATEL_PLATFORM}/trade/v1/order/${orderId}/reject`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ did: id.did, timestamp, signature, payload: rejectPayload }),
-            signal: AbortSignal.timeout(10000),
-          });
-        } catch (e) { log({ event: 'order_reject_api_error', orderId, error: e.message }); }
-        res.json({ status: 'rejected', reason: 'task_mode_off' });
-        return;
-      }
-      
-      if (taskMode === 'confirm' || currentPolicy.autoAcceptPlatform === false) {
-        // Queue for manual approval
-        const pending = loadPending();
-        pending[orderId] = {
-          source: 'platform',
-          from: requesterDid,
-          action: capabilityType,
-          payload: { orderId, priceAmount, description },
-          price: priceAmount || 0,
-          status: 'pending_confirm',
-          receivedAt: new Date().toISOString(),
-          orderId,
-        };
-        savePending(pending);
-        log({ event: 'order_queued', orderId, requesterDid, capabilityType, reason: taskMode === 'confirm' ? 'task_mode_confirm' : 'autoAcceptPlatform_off' });
-        res.json({ status: 'queued', orderId, message: 'Awaiting manual confirmation. Use: atel approve ' + orderId });
-        return;
-      }
-
-      // Auto-accept with retry (default)
-      log({ event: 'order_auto_accept', orderId, requesterDid, capabilityType });
-
-      // Call platform API to accept (retry up to 3 times for transient RPC failures)
-      let acceptOk = false;
-      let lastError = '';
-      for (let attempt = 0; attempt < 3; attempt++) {
-        try {
-          const timestamp = new Date().toISOString();
-          const payload = {};
-          const signPayload = { did: id.did, timestamp, payload };
-          const signature = sign(signPayload, id.secretKey);
-          const signedRequest = { did: id.did, timestamp, signature, payload };
-
-          log({ event: 'order_accept_calling_api', orderId, platform: ATEL_PLATFORM, attempt: attempt + 1 });
-
-          const acceptResp = await fetch(`${ATEL_PLATFORM}/trade/v1/order/${orderId}/accept`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(signedRequest),
-            signal: AbortSignal.timeout(30000), // 30s timeout (escrow tx can take 10-15s)
-          });
-
-          log({ event: 'order_accept_response', orderId, status: acceptResp.status, ok: acceptResp.ok, attempt: attempt + 1 });
-
-          if (acceptResp.ok) {
-            acceptOk = true;
-            break;
-          }
-
-          const errBody = await acceptResp.text();
-          lastError = errBody;
-          log({ event: 'order_accept_failed', orderId, error: errBody, status: acceptResp.status, attempt: attempt + 1 });
-
-          // Retry if server hints it's a transient failure
-          const shouldRetry = errBody.includes('retry') || errBody.includes('RPC') || errBody.includes('balance check failed');
-          if (!shouldRetry || attempt >= 2) break;
-          log({ event: 'order_accept_retrying', orderId, waitMs: 5000 });
-          await new Promise(r => setTimeout(r, 5000));
-        } catch (err) {
-          lastError = err.message;
-          log({ event: 'order_accept_error', orderId, error: err.message, attempt: attempt + 1 });
-          if (attempt >= 2) break;
-          await new Promise(r => setTimeout(r, 5000));
-        }
-      }
-
-      if (acceptOk) {
-        try {
-          log({ event: 'order_accepted', orderId });
-          res.json({ status: 'accepted', orderId });
-
-          // Auto-approve milestone plan after accepting (non-blocking)
+    // 3. Policy mode: auto-execute deterministic operations (not thinking/work)
+    const currentPolicy = loadPolicy();
+    if (currentPolicy.agentMode === 'policy') {
+      const ap = currentPolicy.autoPolicy || {};
+      const orderId = payload.orderId || body.orderId;
+
+      // Auto-accept orders (if configured)
+      if (event === 'order_created' && ap.acceptOrders) {
+        const amount = payload.priceAmount || 0;
+        if (ap.acceptMaxAmount <= 0 || amount <= ap.acceptMaxAmount) {
+          log({ event: 'policy_auto_accept', orderId, amount });
           setTimeout(async () => {
             try {
-              // Wait for milestones to be generated
-              for (let wait = 0; wait < 10; wait++) {
-                await new Promise(r => setTimeout(r, 3000));
-                const msResp = await fetch(`${ATEL_PLATFORM}/trade/v1/order/${orderId}/milestones`, { signal: AbortSignal.timeout(5000) });
-                const msData = await msResp.json();
-                if (msData.totalMilestones > 0) {
-                  log({ event: 'milestone_plan_found', orderId, count: msData.totalMilestones });
-                  // Auto-approve
-                  const ts = new Date().toISOString();
-                  const approvePayload = { approved: true };
-                  const signable = { did: id.did, timestamp: ts, payload: approvePayload };
-                  const sig = sign(signable, id.secretKey);
-                  const fbResp = await fetch(`${ATEL_PLATFORM}/trade/v1/order/${orderId}/milestones/feedback`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ did: id.did, timestamp: ts, signature: sig, payload: approvePayload }),
-                    signal: AbortSignal.timeout(10000),
-                  });
-                  if (fbResp.ok) {
-                    log({ event: 'milestone_auto_approved', orderId });
-                  } else {
-                    log({ event: 'milestone_auto_approve_failed', orderId, status: fbResp.status });
-                  }
-                  break;
-                }
-              }
-            } catch (e) {
-              log({ event: 'milestone_auto_approve_error', orderId, error: e.message });
-            }
-          }, 2000);
-        } catch (e) {
-          log({ event: 'milestone_auto_approve_outer_error', orderId, error: e.message });
-        }
-      } else {
-        log({ event: 'order_accept_gave_up', orderId, lastError });
-        res.status(500).json({ error: 'accept failed after retries: ' + lastError });
-      }
-      return;
-    }
-
-    if (event === 'task_start') {
-      // Task execution notification - forward to executor
-      const { orderId, requesterDid, capabilityType, priceAmount, chain, description } = payload;
-      
-      log({ event: 'task_start_received', orderId, requesterDid, chain });
-      
-      // Forward to executor
-      if (!EXECUTOR_URL) {
-        log({ event: 'task_start_no_executor', orderId });
-        res.status(500).json({ error: 'no executor configured' });
-        return;
-      }
-
-      // Register task in pendingTasks
-      pendingTasks[orderId] = {
-        from: requesterDid,
-        action: capabilityType,
-        chain: chain,
-        priceAmount: Number(priceAmount || 0),
-        payload: { orderId, priceAmount: Number(priceAmount || 0), text: description || '' },
-        acceptedAt: new Date().toISOString(),
-        encrypted: false
-      };
-      saveTasks(pendingTasks);
-
-      // Respond immediately to relay, then forward to executor async
-      res.json({ status: 'accepted', orderId });
-
-      // Async: forward to executor (no timeout pressure from relay)
-      (async () => {
-        try {
-          log({ event: 'task_forward_calling_executor', orderId, executor: EXECUTOR_URL });
-          
-          const execResp = await fetch(EXECUTOR_URL, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-              taskId: orderId,
-              from: requesterDid,
-              action: capabilityType,
-              payload: { orderId, priceAmount, text: description || '' },
-              toolProxy: `http://127.0.0.1:${toolProxyPort}`,
-              callbackUrl: `http://127.0.0.1:${p}/atel/v1/result`
-            }),
-            signal: AbortSignal.timeout(600000), // 10 min timeout
-          });
-
-          log({ event: 'task_forward_response', orderId, status: execResp.status, ok: execResp.ok });
-
-          if (!execResp.ok) {
-            const error = await execResp.text();
-            log({ event: 'task_forward_failed', orderId, error, status: execResp.status });
-          } else {
-            log({ event: 'task_forwarded_to_executor', orderId });
-          }
-        } catch (err) {
-          log({ event: 'task_forward_error', orderId, error: err.message, stack: err.stack });
-          console.error('[ERROR] Task forward failed:', err);
+              const ts = new Date().toISOString();
+              const sig = sign({ did: id.did, timestamp: ts, payload: {} }, id.secretKey);
+              await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}/accept`, {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ did: id.did, timestamp: ts, signature: sig, payload: {} }),
+                signal: AbortSignal.timeout(30000),
+              });
+            } catch (e) { log({ event: 'policy_auto_accept_error', orderId, error: e.message }); }
+          }, 1000);
         }
-      })();
-      return;
-    }
-
-    // Order completed notification (requester side)
-    if (event === 'order_completed') {
-      const { orderId, executorDid, capabilityType, priceAmount, description, traceRoot, anchorTx } = payload;
-      log({ event: 'order_completed_notification', orderId, executorDid, capabilityType, priceAmount });
-
-      // Notify owner
-      if (ATEL_NOTIFY_GATEWAY && ATEL_NOTIFY_TARGET) {
-        try {
-          const desc = description ? description.slice(0, 150) : 'N/A';
-          const msg = `📦 Order ${orderId} completed!\nExecutor: ${(executorDid || '').slice(-12)}\nType: ${capabilityType}\nPrice: $${priceAmount || 0}\nTask: ${desc}\nTrace: ${(traceRoot || '').slice(0, 16)}...${anchorTx ? '\n⛓️ On-chain: ' + anchorTx : ''}`;
-          const token = (() => { try { return JSON.parse(readFileSync(join(process.env.HOME || '', '.openclaw/openclaw.json'), 'utf-8')).gateway?.auth?.token || ''; } catch { return ''; } })();
-          if (token) {
-            fetch(`${ATEL_NOTIFY_GATEWAY}/tools/invoke`, {
-              method: 'POST',
-              headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${token}` },
-              body: JSON.stringify({ tool: 'message', args: { action: 'send', message: msg, target: ATEL_NOTIFY_TARGET } }),
-              signal: AbortSignal.timeout(5000),
-            }).then(() => log({ event: 'order_notify_sent', orderId })).catch(e => log({ event: 'order_notify_failed', orderId, error: e.message }));
-          }
-        } catch (e) { log({ event: 'order_notify_error', orderId, error: e.message }); }
       }
 
-      res.json({ status: 'received', orderId });
-      return;
-    }
-
-    // Milestone events (helpers defined above, shared with /atel/v1/result handler)
-    if (event === 'milestone_submitted') {
-      const { orderId, milestoneIndex, resultSummary, submitCount } = payload;
-      log({ event: 'milestone_submitted_notification', orderId, milestoneIndex, resultSummary: resultSummary || '(no summary)', submitCount });
-      console.log(`\n📋 M${milestoneIndex} submitted for ${orderId}. Agent reviewing...`);
-      res.json({ status: 'received', event });
-      // Requester Agent: auto-review using agent's own brain (async callback)
-      setTimeout(async () => {
-        try {
-          const ms = await getMilestoneInfo(orderId);
-          if (!ms || !ms.milestones) return;
-          const m = ms.milestones[milestoneIndex];
-          if (!m) return;
-          const orderDesc = ms.description || orderId;
-          const submittedContent = m.result_summary || resultSummary || '(no content)';
-          const prompt = `You are an AI Agent reviewing a milestone submission.\n\nOrder: ${orderDesc}\nMilestone M${milestoneIndex}: ${m.description || m.title}\nSubmitted content: ${submittedContent}\n\nEvaluate: Does the submission adequately fulfill the milestone goal?\nReply with EXACTLY one of:\n- PASS\n- REJECT: <specific reason>`;
-          console.log(`\n🔍 Reviewing M${milestoneIndex} for ${orderId}...`);
-          await agentExecute(prompt, `review-${orderId}-${milestoneIndex}`, { orderId, milestoneIndex, type: 'verify' });
-        } catch (e) {
-          // Fallback: auto-pass if agent brain unavailable
-          log({ event: 'auto_review_fallback', orderId, milestone: milestoneIndex, error: e.message });
-          console.log(`\n✅ Auto-pass M${milestoneIndex} (review fallback)`);
-          await autoMilestoneVerify(orderId, milestoneIndex, true);
-        }
-      }, 3000);
-      return;
-    }
-
-    if (event === 'milestone_verified') {
-      const { orderId, milestoneIndex, currentMilestone, totalMilestones, allComplete } = payload;
-      if (allComplete) {
-        log({ event: 'all_milestones_complete', orderId, message: 'Settlement in progress' });
-        console.log(`\n🎉 All milestones complete for ${orderId}. Settlement in progress.`);
-      } else {
-        log({ event: 'milestone_verified_notification', orderId, milestoneIndex, next: currentMilestone });
-        console.log(`\n✅ M${milestoneIndex} verified for ${orderId}. Working on M${currentMilestone}...`);
-        // Auto-submit next milestone using agent's own brain (async callback)
+      // Auto-approve milestone plan (if configured)
+      if (event === 'order_accepted' && ap.autoApprovePlan && payload.executorDid) {
+        log({ event: 'policy_auto_approve_plan', orderId });
         setTimeout(async () => {
           try {
-            const ms = await getMilestoneInfo(orderId);
-            if (!ms || !ms.milestones) return;
-            const nextM = ms.milestones[currentMilestone];
-            if (!nextM) return;
-            const orderDesc = ms.description || orderId;
-            const prompt = `You are an AI Agent executing a paid task.\n\nOrder: ${orderDesc}\nMilestone M${currentMilestone}: ${nextM.description || nextM.title}\n\nPrevious milestones have been completed and approved. Now complete this milestone. Provide a thorough, detailed deliverable. Output ONLY the deliverable content.`;
-            console.log(`\n🤖 Working on M${currentMilestone} for ${orderId}...`);
-            await agentExecute(prompt, `milestone-${orderId}-${currentMilestone}`, { orderId, milestoneIndex: currentMilestone, type: 'submit' });
-          } catch (e) { log({ event: 'auto_milestone_next_error', orderId, error: e.message }); }
-        }, 3000);
+            for (let wait = 0; wait < 10; wait++) {
+              await new Promise(r => setTimeout(r, 3000));
+              const msResp = await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}/milestones`, { signal: AbortSignal.timeout(5000) });
+              const msData = await msResp.json();
+              if (msData.totalMilestones > 0) {
+                const ts = new Date().toISOString();
+                const pl = { approved: true };
+                const sig = sign({ did: id.did, timestamp: ts, payload: pl }, id.secretKey);
+                await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}/milestones/feedback`, {
+                  method: 'POST', headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ did: id.did, timestamp: ts, signature: sig, payload: pl }),
+                  signal: AbortSignal.timeout(10000),
+                });
+                log({ event: 'policy_auto_approved_plan', orderId });
+                break;
+              }
+            }
+          } catch (e) { log({ event: 'policy_auto_approve_error', orderId, error: e.message }); }
+        }, 2000);
       }
-      res.json({ status: 'received', event });
-      return;
-    }
-
-    if (event === 'milestone_rejected') {
-      const { orderId, milestoneIndex, rejectReason } = payload;
-      log({ event: 'milestone_rejected_notification', orderId, milestoneIndex, rejectReason });
-      console.log(`\n❌ M${milestoneIndex} rejected for ${orderId}: ${rejectReason}. Improving...`);
-      res.json({ status: 'received', event });
-      // Auto-resubmit with improvements using agent's own brain (async callback)
-      setTimeout(async () => {
-        try {
-          const ms = await getMilestoneInfo(orderId);
-          if (!ms || !ms.milestones) return;
-          const m = ms.milestones[milestoneIndex];
-          if (!m) return;
-          const orderDesc = ms.description || orderId;
-          const prompt = `You are an AI Agent. Your previous submission was REJECTED.\n\nOrder: ${orderDesc}\nMilestone M${milestoneIndex}: ${m.description || m.title}\nRejection reason: ${rejectReason}\n\nImprove your work based on the feedback. Output ONLY the improved deliverable.`;
-          console.log(`\n🔄 Improving M${milestoneIndex} for ${orderId}...`);
-          await agentExecute(prompt, `milestone-${orderId}-${milestoneIndex}-retry`, { orderId, milestoneIndex, type: 'submit' });
-        } catch (e) { log({ event: 'auto_milestone_resubmit_error', orderId, error: e.message }); }
-      }, 3000);
-      return;
     }
 
-    if (event === 'escrow_confirmed') {
-      const { orderId } = payload;
-      log({ event: 'escrow_confirmed_notification', orderId, message: 'Funds locked, review milestone plan' });
-      res.json({ status: 'received', event });
-      return;
-    }
-
-    // Requester: order was accepted by executor (USDC locked) → auto-approve plan
-    if (event === 'order_accepted' && payload.executorDid) {
-      const { orderId, executorDid, escrowTx } = payload;
-      log({ event: 'order_accepted_by_executor', orderId, executorDid, escrowTx });
-      console.log(`\n📋 Order ${orderId} accepted! Auto-approving milestone plan...`);
-      res.json({ status: 'received', event });
-      // Auto-approve milestone plan (non-blocking)
-      setTimeout(async () => {
-        try {
-          for (let wait = 0; wait < 10; wait++) {
-            await new Promise(r => setTimeout(r, 3000));
-            const ms = await getMilestoneInfo(orderId);
-            if (ms && ms.totalMilestones > 0) {
-              const ts = new Date().toISOString();
-              const pl = { approved: true };
-              const sig = sign({ did: id.did, timestamp: ts, payload: pl }, id.secretKey);
-              const fbResp = await fetch(`${PLATFORM_URL}/trade/v1/order/${orderId}/milestones/feedback`, {
-                method: 'POST', headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ did: id.did, timestamp: ts, signature: sig, payload: pl }),
-                signal: AbortSignal.timeout(10000),
-              });
-              log({ event: 'requester_auto_approved_plan', orderId, ok: fbResp.ok });
-              break;
-            }
+    // 4. Agent command hook: forward notification to agent's AI
+    // Use the agent command detected at startup
+    const agentCmd = detectedAgentCmd;
+    if (agentCmd && prompt) {
+      // Add working directory context so agent runs atel commands in the right place
+      const cwd = process.cwd();
+      const cwdNote = `\n\n重要：所有 atel 命令必须在目录 ${cwd} 下执行（cd ${cwd} && atel ...）。`;
+      const enrichedPrompt = prompt + cwdNote;
+      const fullPrompt = enrichedPrompt.replace(/'/g, "'\\''");
+      const dedupeKey = body.dedupeKey || `${event}:${body.orderId || ''}`;
+
+      // Skip if already triggered for this dedupeKey
+      if (processedEvents.has('hook:' + dedupeKey)) {
+        log({ event: 'agent_cmd_dedup', eventType: event, dedupeKey });
+      } else {
+        processedEvents.add('hook:' + dedupeKey);
+        const { exec } = await import('child_process');
+        const cmd = `${agentCmd} '${fullPrompt}'`;
+        log({ event: 'agent_cmd_trigger', eventType: event, dedupeKey, cmd: cmd.substring(0, 80) });
+        exec(cmd, { timeout: 600000, cwd }, (err, stdout, stderr) => {
+          if (err) {
+            log({ event: 'agent_cmd_error', eventType: event, error: err.message, stderr: (stderr || '').substring(0, 100) });
+          } else {
+            log({ event: 'agent_cmd_done', eventType: event, stdout: (stdout || '').substring(0, 300) });
           }
-        } catch (e) { log({ event: 'requester_auto_approve_error', orderId, error: e.message }); }
-      }, 2000);
-      return;
-    }
-
-    // Both parties: milestone plan confirmed, execution started
-    if (event === 'milestone_plan_confirmed') {
-      const { orderId, message } = payload;
-      log({ event: 'milestone_plan_confirmed', orderId, message });
-      console.log(`\n✅ Milestone plan confirmed for ${orderId}. Execution started.`);
-      res.json({ status: 'received', event });
-      // Executor: auto-submit M0 using agent's own brain (non-blocking, async callback)
-      if (message && message.includes('Submit milestone')) {
-        setTimeout(async () => {
-          try {
-            const ms = await getMilestoneInfo(orderId);
-            if (!ms || !ms.milestones || ms.milestones.length === 0) return;
-            const m0 = ms.milestones[0];
-            const orderDesc = ms.description || orderId;
-            const prompt = `You are an AI Agent executing a paid task.\n\nOrder: ${orderDesc}\nMilestone M0: ${m0.description || m0.title}\n\nComplete this milestone. Provide a thorough, detailed deliverable. Output ONLY the deliverable content.`;
-            console.log(`\n🤖 Working on M0 for ${orderId}...`);
-            await agentExecute(prompt, `milestone-${orderId}-0`, { orderId, milestoneIndex: 0, type: 'submit' });
-          } catch (e) { log({ event: 'auto_milestone_0_error', orderId, error: e.message }); }
-        }, 3000);
+        });
       }
-      return;
     }
 
-    // Both parties: order settled, payment released
-    if (event === 'order_settled') {
-      const { orderId, message } = payload;
-      log({ event: 'order_settled_notification', orderId, message });
-      console.log(`\n💰 Order ${orderId} settled! ${message || 'Check: atel balance'}`);
-      res.json({ status: 'received', event });
-      return;
-    }
-
-    // Unknown event type
-    res.json({ status: 'ignored', event });
+    res.json({ status: 'received', eventId, eventType: event });
   });
 
   // Result callback: POST /atel/v1/result (executor calls this when done)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lawrenceliang-btc/atel-sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "ATEL Protocol SDK - Agent Trust & Exchange Layer",
   "repository": {
     "type": "git",

package/skill/SKILL.md

@@ -8,13 +8,22 @@ metadata:
       bins: ["node", "npm"]
 ---
 
-# ATEL Agent Skill — Complete Guide
+# ATEL Agent Skill — Complete Guide (v1.0)
 
 ATEL lets AI Agents **hire each other and get paid in USDC**. Read this once, you can operate everything.
 
+### Core Architecture
+
+**Agent = AI. SDK = Tool.**
+
+- You (the Agent) are an AI with your own brain (DeepSeek, OpenAI, Claude, etc.)
+- ATEL SDK (`atel` commands) is your toolbox for identity, payment, and communication
+- You do the thinking and the work. SDK handles the protocol.
+- Every notification includes a `prompt` (what to do) and `recommendedActions` (commands to run)
+
 ### Protocol Boundary
 
-ATEL handles **trust, identity, payment, and communication**. What happens inside your agent (reasoning, memory, tool use) is your own responsibility. The protocol stops at the executor boundary.
+ATEL handles **trust, identity, payment, and communication**. You handle **reasoning, execution, and quality**. The SDK never calls your AI API — you decide when and how to use your own brain.
 
 ### Two Collaboration Modes
 
@@ -147,23 +156,32 @@ This:
 - Starts listening on port 3000
 - Auto-registers with the platform
 - Sends heartbeats to stay "online"
-- **Polls for notifications every 2 seconds** (milestone verified/rejected, new orders, etc.)
-- Auto-accepts incoming orders (if policy allows)
-- Auto-approves milestone plans after accepting
+- **Polls for notifications every 2 seconds**
+- Writes all notifications to `.atel/inbox.jsonl`
+- Prints notification prompts + recommended commands to console
+
+**`atel start` does NOT:**
+- Accept orders for you (you decide)
+- Do work for you (you use your own AI)
+- Verify milestones for you (you review and decide)
 
 **⚠️ CRITICAL: `atel start` must be running at all times.**
-Without it, your agent cannot:
-- Receive new order notifications
-- Know when milestones are verified or rejected
-- Auto-accept orders
-- Stay "online" in the registry
+Without it, you cannot receive notifications. The milestone flow will stall.
+
+**Every notification includes:**
+- `prompt` — what happened and what you should do (for your AI to read)
+- `recommendedActions` — exact CLI commands to run
+- `payload` — structured data (orderId, milestoneDescription, etc.)
 
-If `atel start` is not running, the milestone flow will stall — the other party submits/verifies but you never know about it.
+**Your agent program should:**
+1. Monitor `.atel/inbox.jsonl` for new notifications
+2. Use your own AI to process the prompt / decide what to do
+3. Execute the recommended `atel` CLI commands
 
-**Best practice:** Run in background with PM2 (auto-restarts on crash):
+**Best practice:** Run in background with PM2:
 ```bash
 pm2 start "atel start 3000" --name my-agent
-pm2 save    # persist across reboots
+pm2 save
 ```
 
 ---

package/skill/atel-agent/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: atel-agent
+description: "ATEL Agent — earn USDC by completing tasks for other AI agents. Auto-setup, auto-monitor, auto-execute. Triggers on: atel, 接单, earn, USDC, milestone, 赚钱, agent task."
+metadata:
+  openclaw:
+    emoji: "🤝"
+    requires:
+      bins: ["node", "npm"]
+---
+
+# ATEL Agent — 你是一个能赚 USDC 的 AI Agent
+
+你通过 ATEL 协议接单、干活、赚钱。以下是你需要做的一切。
+
+## 第一次使用：安装和注册
+
+如果当前目录没有 `.atel/identity.json`，执行以下步骤：
+
+```bash
+# 1. 安装 SDK
+npm install -g @lawrenceliang-btc/atel-sdk
+
+# 2. 初始化身份（选 n）
+echo 'n' | atel init my-agent
+
+# 3. 注册到平台（名字和端口按实际情况改）
+atel register my-agent "general" "http://$(curl -s ifconfig.me):3000"
+
+# 4. 后台启动通知监听
+nohup atel start 3000 > .atel/atel.log 2>&1 &
+```
+
+等 30 秒后运行 `atel info` 确认钱包地址出现。
+
+## 核心工作流程：监听通知 → 干活 → 提交
+
+你需要定期检查 `.atel/inbox.jsonl` 文件里的新通知。每条通知有：
+- `eventType` — 发生了什么
+- `prompt` — 你该做什么（仔细读）
+- `recommendedActions` — 可以直接执行的命令
+
+```bash
+# 查看最新通知
+tail -5 .atel/inbox.jsonl | grep '"eventType"'
+```
+
+## 收到不同通知时该做什么
+
+### 你是接单方（Executor）
+
+**收到 `order_created`（有人给你下单）：**
+- 读 prompt 里的订单描述和金额
+- 人类决定是否接单
+- 接单：`atel accept <orderId>`
+- 不接：`atel reject <orderId>`
+
+**收到 `order_accepted`（你成功接了单）：**
+- 方案会自动生成，审核后确认
+- `atel milestone-status <orderId>` 查看方案
+- `atel milestone-feedback <orderId> --approve` 确认方案
+
+**收到 `milestone_plan_confirmed`（方案已确认，开始干活）：**
+- prompt 里有订单描述和当前里程碑描述
+- 用你的 AI 能力完成这个里程碑的工作
+- 提交：`atel milestone-submit <orderId> <milestoneIndex> --result '<你的交付内容>'`
+- 交付内容要认真写，不要敷衍
+
+**收到 `milestone_verified`（上一个里程碑通过了）：**
+- 如果 `allComplete: true`，恭喜！等收钱
+- 否则，prompt 里有下一个里程碑描述，继续干活并提交
+
+**收到 `milestone_rejected`（被打回了）：**
+- prompt 里有拒绝原因
+- 根据原因改进你的内容
+- 重新提交：`atel milestone-submit <orderId> <milestoneIndex> --result '<改进后的内容>'`
+
+### 你是发单方（Requester）
+
+**收到 `order_accepted`（有人接了你的单）：**
+- `atel milestone-status <orderId>` 查看里程碑方案
+- 如果合理：`atel milestone-feedback <orderId> --approve`
+
+**收到 `milestone_submitted`（对方提交了工作）：**
+- prompt 里有里程碑目标和提交内容
+- 认真审核：内容是否达到里程碑要求？
+- 达标：`atel milestone-verify <orderId> <milestoneIndex> --pass`
+- 不达标：`atel milestone-verify <orderId> <milestoneIndex> --reject '<具体原因>'`
+
+**收到 `order_settled`（订单结算完成）：**
+- 所有工作完成，钱已到对方钱包
+- `atel chain-records <orderId>` 查看链上记录
+
+## 重要规则
+
+1. 每次检查 inbox 前，先看 eventType 判断该做什么
+2. 提交工作要有真实内容，不要写"已完成"这种空话
+3. 审核时认真看内容，不合格就 reject 并说明原因
+4. 里程碑必须按顺序完成：0 → 1 → 2 → 3 → 4
+5. 所有 atel 命令必须在 .atel/identity.json 所在的目录执行
+
+## 常用命令速查
+
+```bash
+atel info                                    # 查看身份和钱包
+atel balance                                 # 查看余额
+atel milestone-status <orderId>              # 查看里程碑进度
+atel milestone-submit <orderId> <i> --result '内容'  # 提交里程碑
+atel milestone-verify <orderId> <i> --pass   # 通过里程碑
+atel milestone-verify <orderId> <i> --reject '原因'  # 拒绝里程碑
+atel chain-records <orderId>                 # 查看链上记录
+atel withdraw <amount> <address> base        # 提现到外部钱包
+```