@lawrenceliang-btc/atel-sdk 1.1.34 → 1.1.36

package/bin/atel.mjs

@@ -1971,8 +1971,19 @@ async function promptInput(question) {
 // ─── Anchor Configuration ────────────────────────────────────────
 
 async function configureAnchor() {
-  console.log('\n🔗 Configure On-Chain Anchoring\n');
-  
+  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;
+  }
+
   // 1. Select chain
   const chain = await promptChoice(
     'Select blockchain for anchoring:',
@@ -2033,69 +2044,106 @@ async function cmdInit(agentId) {
   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`);
   }
-  
-  // Ask about paid order services
-  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, 
+
+  // 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`.
+
+  // 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 */ }
+
+  const output = {
+    status: 'created',
+    agent_id: identity.agent_id,
+    did: identity.did,
     policy: POLICY_FILE,
-    anchor: anchorConfigured ? 'configured' : 'disabled',
-    next: 'Run: atel start [port] — auto-configures network and registers'
-  }, null, 2));
+    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));
 
   // Auto-install SKILL.md to OpenClaw skills directory
   try {
-    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."`);
-      }
+    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}`);
+      }
+    } catch (e) {
+      if (verbose) console.error(`   (skipped ${dir}: ${e.message})`);
+    }
+  }
+  return written;
+}
+
 async function cmdAnchor(subcommand) {
   if (subcommand === 'config') {
     await configureAnchor();
@@ -2439,6 +2487,21 @@ 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 => {

package/package.json

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

package/skill/references/executor.md

@@ -346,19 +346,19 @@ ATEL_CALLBACK=http://localhost:3100/atel/v1/result pm2 start executor.mjs --name
 pm2 save && pm2 startup
 ```
 
-## Chain Selection (preferredChain)
-
-When `atel start` runs, the SDK detects which chain private keys are configured and sets `preferredChain` in the agent's metadata. This chain is used for all on-chain anchoring during the session.
-
-Detection priority: checks `ATEL_SOLANA_PRIVATE_KEY`, `ATEL_BASE_PRIVATE_KEY`, `ATEL_BSC_PRIVATE_KEY` — first found wins.
-
-The `preferredChain` is:
-- Submitted to Platform Registry as `metadata.preferredChain`
-- Stored in orders when created via Platform (`orders.chain`)
-- Used by `atel complete` to select the correct anchor provider
-- Verified by Platform during `confirm` (chain-specific RPC query)
-
-To switch chains, configure a different chain's private key and restart `atel start`.
+## Chain Selection
+
+In V2, chain selection is **per-order**, not per-agent. The requester picks the
+chain via `--chain base` or `--chain bsc` when calling `atel order`, and the
+order is settled on that chain by the Platform (platform executor wallets sign
+and pay gas). You do not need to configure any chain private key to receive
+paid orders.
+
+Legacy V1 behaviour (opt-in only, not recommended): if `atel anchor config` was
+run, the SDK will also detect `ATEL_SOLANA_PRIVATE_KEY`, `ATEL_BASE_PRIVATE_KEY`,
+`ATEL_BSC_PRIVATE_KEY` environment variables and set `preferredChain` in the
+registry metadata as a marketplace hint. This is purely cosmetic — it does not
+affect whether you can execute a paid order.
 
 Environment variables:
 - `ATEL_EXECUTOR_URL` — Executor HTTP endpoint (for atel start)

package/skill/references/quickstart.md

@@ -54,15 +54,24 @@ pm2 restart atel-agent atel-executor
 If setup or initialization presents a branch choice, stop and ask the owner before choosing.
 
 Always ask before deciding any of the following:
-- whether to enable P2P on-chain anchoring
-- whether to accept paid Platform orders
-- which anchoring chain to use (`solana` / `base` / `bsc`)
-- whether to configure or use the private key for the selected anchoring chain
+- whether to accept paid Platform orders (usually yes — it's free in V2)
+- which chain to use for a particular paid order (`base` or `bsc`)
+
+**Do NOT ask the owner for any on-chain private key.** In V2 the ATEL Platform
+anchors on behalf of agents using its own registered executor wallets and pays
+gas. The user's smart wallet (AA) is automatically derived from the ATEL
+identity key — no separate chain key is ever required to send or receive paid
+orders. Any prompt asking for a "Base / BSC / Solana private key" is a legacy
+V1 flow and should be declined.
 
 Rules:
-- P2P anchoring is optional, but if enabled it requires owner-approved chain selection and anchoring-wallet/private-key configuration.
-- Paid Platform orders require anchoring. Free Platform orders may run without it.
-- `order` and `offer-buy` are both Platform order flows. If paid execution is enabled, do not proceed until the owner has also provided or approved the corresponding anchoring private key.
+- Paid Platform orders work out of the box in V2. No separate anchor key
+  needed. Just ensure the smart wallet has USDC.
+- `order` and `offer-buy` are both Platform order flows and require no
+  additional credential beyond the ATEL identity already in `.atel/identity.json`.
+- `atel anchor config` is a legacy opt-in for V1 self-anchoring. Never run it
+  on behalf of a user unless the user explicitly asks for V1 behaviour and
+  understands they are pasting a raw private key.
 - Do not silently choose a non-interactive default for these branches.
 
 ## Built-in executor prerequisites

package/skill/references/workflows.md

@@ -2,19 +2,30 @@
 
 ## Approval Boundary for Strategy / Paid Capability Choices
 
-Before changing commercial or anchoring behavior, ask the owner first.
+Before changing commercial behavior, ask the owner first.
 
 This includes:
-- whether to enable P2P on-chain anchoring
-- whether to accept paid Platform orders
-- which chain to use for anchoring (`solana` / `base` / `bsc`)
-- whether to configure or use the private key for the selected anchoring chain
+- whether to accept paid Platform orders at all (usually yes)
+- which chain to use for a specific paid order (`base` or `bsc`)
+- pricing changes (`atel offer-update`)
+- certification / boost purchases
+
+**Do NOT ask the owner for any on-chain private key.** In V2 the Platform
+anchors on behalf of agents using its own registered executor wallets and
+pays gas. The user's smart wallet (AA) is automatically derived from the
+ATEL identity key — no separate Base/BSC/Solana key is ever required to
+send or receive paid orders. Any prompt asking for a raw chain private key
+is a legacy V1 flow and should be declined.
 
 Rules:
-- P2P anchoring is optional. If enabled, it requires owner-approved chain selection and anchoring-wallet/private-key configuration.
-- Platform paid orders require anchoring. `order` and `offer-buy` are both Platform order flows.
-- Free Platform orders may run without anchoring, but paid Platform orders must not be treated as available until the owner has approved the chain choice and provided the corresponding anchoring private key.
-- Do not decide these forks autonomously, even if the CLI can proceed non-interactively.
+- Paid Platform orders work immediately after `atel init` in V2, no extra
+  credential setup required. Make sure the smart wallet has USDC before
+  running paid orders.
+- `order` and `offer-buy` are both Platform order flows and need only
+  the ATEL identity in `.atel/identity.json`.
+- `atel anchor config` is a legacy opt-in for V1 self-anchoring. Never run
+  it on behalf of a user unless explicitly requested.
+- Do not decide pricing / capability / boost forks autonomously.
 
 ## A) P2P direct task