@clawcard/cli 2.1.7 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawcard/cli",
-  "version": "2.1.7",
+  "version": "3.0.0",
   "description": "The ClawCard CLI — manage your agent keys, billing, and setup from the terminal",
   "bin": {
     "clawcard": "./bin/clawcard.mjs"

package/skill/SKILL.md

@@ -1,17 +1,25 @@
 ---
 name: clawcard
-description: Email, SMS, virtual cards, and credential vault for autonomous agents. Run clawcard agent commands to interact with your resources.
+description: Email, SMS, virtual cards, crypto wallet, and credential vault for autonomous agents. Run clawcard agent commands to interact with your resources.
 ---
 
 You have access to ClawCard via the `clawcard` CLI. All commands support `--json` for machine-readable output. Always pass `--json` when calling these commands.
 
-## Step 1: Check your identity
+## CRITICAL: Know Your Resources Before Acting
+
+**BEFORE creating cards, sending USDC, or spending money, ALWAYS check what you already have:**
 
 ```
-clawcard agent info --json
+clawcard agent info --json        # Your identity, email, phone, wallet, budget
+clawcard agent cards --json       # Your existing cards (check BEFORE creating new ones!)
+clawcard agent wallet --json      # Your wallet (check BEFORE creating a new one!)
+clawcard agent budget --json      # Your remaining FIAT budget
+clawcard agent creds --json       # Your stored credentials
 ```
 
-Returns your agent name, email address, phone number, and remaining budget.
+**You MUST list existing cards before every purchase.** If you already have an open `merchant_locked` card for the same merchant, REUSE IT — do not create a new one. Cards are limited and creating duplicates wastes budget.
+
+---
 
 ## Email
 
@@ -44,22 +52,38 @@ clawcard agent sms send --to "+15551234567" --body "Message" --json
 
 ## Virtual Cards
 
-IMPORTANT: Always list cards first. Reuse open merchant_locked cards for the same merchant.
+### MANDATORY: Check existing cards FIRST
+
+**Before EVERY payment, run this:**
+```
+clawcard agent cards --json
+```
+
+Look at the response. For each card, check:
+- `status`: Is it `open`? (If `paused` or `closed`, skip it)
+- `type`: Is it `merchant_locked`? (If so, it can be reused at the same merchant)
+- `memo`: Does the description match the merchant/service you're paying?
+- `spendLimitCents`: Does it have enough budget remaining?
+
+**If you find an open merchant_locked card for the same merchant — USE IT. Do NOT create a new card.**
+
+### Card types
 
-⚠️ SUBSCRIPTION WARNING: ClawCard cards cannot be topped up after creation. If you are about to pay for a recurring subscription (monthly SaaS, hosting, etc.), STOP and tell the user:
-"This looks like a subscription. ClawCard cards have a fixed budget and can't be topped up — the renewal will fail when the budget runs out. Consider using a personal card for subscriptions, or create a merchant_locked card with enough budget to cover several months."
-Only proceed if the user explicitly confirms.
+- `single_use`: Auto-closes after one charge. Use for one-time purchases (domains, invoices, one-off payments). **This is the default.**
+- `merchant_locked`: Locks to first merchant, allows repeat charges. Use ONLY when the user explicitly needs multiple purchases at the same merchant.
 
-Card types (REQUIRED — you must specify one):
-- single_use: auto-closes after one charge. Use for one-time purchases (domains, invoices, one-off payments). THIS IS THE DEFAULT — use this unless the user specifically asks for a recurring card.
-- merchant_locked: locks to first merchant, allows repeat charges. Use ONLY when the user explicitly needs to make multiple purchases at the same merchant. NOT recommended for subscriptions since the card budget cannot be refilled.
+### Subscription warning
+
+Cards CANNOT be topped up. If you are about to pay for a recurring subscription (monthly SaaS, hosting, etc.), STOP and warn the user: "This card has a fixed budget and can't be refilled — the renewal will fail when the budget runs out. Consider using a personal card for subscriptions."
+
+### Commands
 
 List cards:
 ```
 clawcard agent cards --json
 ```
 
-Create card:
+Create card (ONLY after confirming no existing card works):
 ```
 clawcard agent cards create --amount <cents> --type <single_use|merchant_locked> --memo "description" --json
 ```
@@ -74,6 +98,93 @@ Close card:
 clawcard agent cards close <card-id> --json
 ```
 
+## Stablecoin Wallet (USDC on Base)
+
+Your agent can have a USDC wallet for crypto payments, agent-to-agent transfers, and x402 API access.
+
+**Use wallet for:** x402 APIs (HTTP 402 responses), crypto transfers, micropayments
+**Use cards for:** traditional merchant checkouts, websites with payment forms
+
+### Setup
+
+Check if you have a wallet:
+```
+clawcard agent wallet --json
+```
+
+If you get `"No wallet found"`, create one via the API or run `clawcard agent wallet` interactively.
+
+### Commands
+
+Check balance (shows USDC + FIAT spending power):
+```
+clawcard agent wallet balance --json
+```
+
+Send USDC to an address:
+```
+clawcard agent wallet send --to 0xADDRESS --amount 5.00 --json
+```
+
+Pay a URL via x402 (default — when a service returns HTTP 402):
+```
+clawcard agent wallet send --url https://api.example.com/data --json
+```
+
+Pay a URL via MPP (Machine Payments Protocol — Stripe/Tempo):
+```
+clawcard agent wallet send --url https://api.example.com/data --protocol mpp --json
+```
+
+View transaction history:
+```
+clawcard agent wallet transactions --json
+```
+
+Fund your wallet from your FIAT balance (2% conversion fee):
+```
+clawcard agent wallet fund --amount 10.00 --json
+```
+
+Or send USDC directly to your wallet address on Base. Check your address with `clawcard agent wallet --json`.
+
+## Discover Services
+
+**When you need a capability you don't have** (web search, data enrichment, image generation, etc.), search the x402 ecosystem:
+
+```
+clawcard agent discover --query "web search" --json
+```
+
+This returns paid API services you can access with your wallet. To use one:
+
+```
+clawcard agent wallet send --url https://discovered-service.com/endpoint --json
+```
+
+The wallet handles payment automatically via the x402 protocol. No API keys or subscriptions needed — just USDC micropayments.
+
+Browse all available services:
+```
+clawcard agent discover --json
+```
+
+## On-Chain Identity (ERC-8004)
+
+Your agent can have a verifiable on-chain identity — an NFT on Base that proves who the agent is, what it can do, and links to its wallet address.
+
+Register or view identity:
+```
+clawcard agent identity --json
+```
+
+## A2A Agent Card
+
+View your agent's discovery card (used by other agents to find and interact with you):
+```
+clawcard agent card --json
+```
+
 ## Credentials
 
 Store and retrieve secrets. Use consistent lowercase naming.
@@ -119,34 +230,56 @@ clawcard agent billing-address --json
 ```
 
 Returns: name, line1, line2, city, state, zip, country.
-Use these values to fill billing/address fields on checkout pages.
 
 ## Paying on Checkout Pages
 
-When you reach a payment form:
-1. Get billing info: `clawcard agent billing-address --json`
-2. Fill all non-payment fields yourself (name, email, address, zip) using the billing address
-3. Create a card if needed:
+**FOLLOW THESE STEPS IN ORDER:**
+
+1. **Check existing cards FIRST:**
+   ```
+   clawcard agent cards --json
+   ```
+   Look for an open card that matches this merchant. If found, skip to step 4.
+
+2. **Check budget:**
+   ```
+   clawcard agent budget --json
    ```
-   clawcard agent cards create --amount <cents> --type single_use --memo "desc" --json
+
+3. **Create a card ONLY if no existing card works:**
    ```
-3. Try filling card fields yourself first (card number, expiry, CVC)
-4. If you can't access the card fields (iframe/cross-origin), run:
+   clawcard agent cards create --amount <cents> --type single_use --memo "description of purchase" --json
+   ```
+
+4. **Get billing address:**
+   ```
+   clawcard agent billing-address --json
+   ```
+
+5. **Fill non-payment fields** (name, email, address, zip) using the billing address.
+
+6. **Get card details:**
+   ```
+   clawcard agent cards details <card-id> --json
+   ```
+
+7. **Fill card fields** (card number, expiry, CVC) yourself if possible.
+
+8. **If card fields are in iframes you can't reach**, use the browser extension:
    ```
    clawcard agent pay --card-id <card-id> --json
    ```
-   This sends the card details to the ClawCard browser extension which
-   fills payment form fields that are inside iframes you can't reach.
-5. If the extension is not installed, this will return an error —
-   fall back to telling the user they need the extension installed.
-6. After running pay, wait a moment then verify the fields are filled
-   before clicking the submit/pay button.
+
+9. **Verify fields are filled**, then submit the payment.
 
 ## Tips
 
-- Always run `clawcard agent info --json` first to verify your identity.
-- Check budget before creating cards: `clawcard agent budget --json`
-- Default to single_use cards for everything. They auto-close after one charge.
-- Only use merchant_locked if the user explicitly needs repeat charges at the same merchant.
-- NEVER silently pay for a subscription. Always warn the user that card budgets are fixed and renewals will fail.
-- Store credentials in the vault with consistent naming so you can find them later.
+- **ALWAYS check existing resources before creating new ones** — cards, wallet, credentials.
+- Check budget before spending: `clawcard agent budget --json`
+- For API payments that return HTTP 402, use the wallet: `clawcard agent wallet send --url <url> --json`
+- For traditional checkouts, use cards. For crypto/x402, use the wallet.
+- Default to `single_use` cards. Only use `merchant_locked` for repeat purchases at the same merchant.
+- NEVER silently pay for a subscription. Always warn the user first.
+- Store credentials with consistent naming so you can find them later.
+- If you need a capability (search, enrichment, scraping, etc.), discover it: `clawcard agent discover --query "..." --json`
+- If a service returns HTTP 402, your wallet can pay for it automatically.

package/src/agent-api.js

@@ -113,3 +113,61 @@ export const listActivity = (agentId, params = {}) => {
   const query = qs.toString();
   return agentRequest(`/api/agents/${agentId}/activity${query ? "?" + query : ""}`);
 };
+
+// Wallet
+export const getWallet = (agentId) =>
+  agentRequest(`/api/agents/${agentId}/wallet`);
+
+export const createWallet = (agentId) =>
+  agentRequest(`/api/agents/${agentId}/wallet`, {
+    method: "POST",
+    body: JSON.stringify({}),
+  });
+
+export const walletAction = (agentId, action) =>
+  agentRequest(`/api/agents/${agentId}/wallet`, {
+    method: "PATCH",
+    body: JSON.stringify({ action }),
+  });
+
+export const walletFund = (agentId, amount) =>
+  agentRequest(`/api/agents/${agentId}/wallet/fund`, {
+    method: "POST",
+    body: JSON.stringify({ amount }),
+  });
+
+export const walletSend = (agentId, data) =>
+  agentRequest(`/api/agents/${agentId}/wallet/send`, {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+
+export const walletTransactions = (agentId, params = {}) => {
+  const qs = new URLSearchParams();
+  if (params.limit) qs.set("limit", params.limit);
+  const query = qs.toString();
+  return agentRequest(`/api/agents/${agentId}/wallet/transactions${query ? "?" + query : ""}`);
+};
+
+// Discovery
+export const discoverServices = (params = {}) => {
+  const qs = new URLSearchParams();
+  if (params.query) qs.set("q", params.query);
+  if (params.limit) qs.set("limit", params.limit);
+  const query = qs.toString();
+  return agentRequest(`/api/discover${query ? "?" + query : ""}`);
+};
+
+// On-Chain Identity (ERC-8004)
+export const getOnChainIdentity = (agentId) =>
+  agentRequest(`/api/agents/${agentId}/identity`);
+
+export const registerOnChainIdentity = (agentId, data = {}) =>
+  agentRequest(`/api/agents/${agentId}/identity`, {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+
+// A2A Agent Card
+export const getAgentCard = (agentId) =>
+  agentRequest(`/api/agents/${agentId}/agent-card`);

package/src/commands/agent.js

@@ -15,6 +15,16 @@ import {
   getCredential,
   getBudget,
   listActivity,
+  getWallet,
+  createWallet as createWalletApi,
+  walletAction,
+  walletFund,
+  walletSend,
+  walletTransactions as walletTransactionsApi,
+  discoverServices,
+  getOnChainIdentity,
+  registerOnChainIdentity,
+  getAgentCard,
 } from "../agent-api.js";
 
 const orange = chalk.hex("#FF6B35");
@@ -38,10 +48,24 @@ export async function agentInfoCmd(options) {
   if (options.json) return output(me, true);
 
   const budget = await getBudget(me.keyId);
+
+  let wallet = null;
+  try {
+    wallet = await getWallet(me.keyId);
+  } catch {
+    // No wallet — that's fine
+  }
+
   console.log();
   console.log(`  Name:    ${orange.bold(me.name || "unnamed")}`);
   console.log(`  Email:   ${me.email || "-"}`);
   console.log(`  Phone:   ${me.phone || "-"}`);
+  if (wallet) {
+    console.log(`  Wallet:  ${orange(wallet.address)} ${chalk.dim("(Base)")}`);
+    console.log(`  USDC:    ${chalk.green(wallet.balanceUsdc + " USDC")}`);
+  } else {
+    console.log(`  Wallet:  ${chalk.dim("none — run: clawcard agent wallet")}`);
+  }
   console.log(`  Key ID:  ${chalk.dim(me.keyId)}`);
   console.log(`  Budget:  ${chalk.green("$" + ((budget.budgetCents || 0) / 100).toFixed(2))}`);
   console.log();
@@ -376,3 +400,362 @@ export async function agentPayCmd(options) {
     console.log(`  Error: ${result.error}`);
   }
 }
+
+// ── Wallet ──
+
+export async function agentWalletCmd(options) {
+  const agentId = await getAgentId();
+
+  // Try to get existing wallet
+  try {
+    const wallet = await getWallet(agentId);
+    if (options.json) return output(wallet, true);
+
+    console.log();
+    console.log(`  Address:  ${orange(wallet.address)}`);
+    console.log(`  Network:  Base`);
+    console.log(`  Balance:  ${chalk.green(wallet.balanceUsdc + " USDC")}`);
+    console.log(`  Status:   ${wallet.status}`);
+    console.log();
+    return;
+  } catch (err) {
+    // No wallet — prompt to create
+    if (!err.message.includes("No wallet found") && !err.message.includes("404")) {
+      if (options.json) return output({ error: err.message }, true);
+      console.log(`  Error: ${err.message}`);
+      return;
+    }
+  }
+
+  if (options.json) {
+    return output({ error: "No wallet found" }, true);
+  }
+
+  // Interactive prompt to create
+  const prompts = await import("@clack/prompts");
+  const shouldCreate = await prompts.confirm({
+    message: "No wallet detected. Create a USDC wallet on Base?",
+  });
+
+  if (prompts.isCancel(shouldCreate) || !shouldCreate) {
+    console.log("  Wallet creation cancelled.");
+    return;
+  }
+
+  try {
+    const wallet = await createWalletApi(agentId);
+    console.log();
+    console.log(`  ${chalk.green("Wallet created!")}`);
+    console.log();
+    console.log(`  Address:  ${orange(wallet.address)}`);
+    console.log(`  Network:  Base`);
+    console.log(`  Balance:  ${wallet.balanceUsdc} USDC`);
+    console.log(`  Status:   ${wallet.status}`);
+    console.log();
+    console.log(chalk.dim("  Fund via FIAT balance or send USDC directly to the address above."));
+    console.log();
+  } catch (err) {
+    console.log(`  Error creating wallet: ${err.message}`);
+  }
+}
+
+export async function agentWalletBalanceCmd(options) {
+  const agentId = await getAgentId();
+
+  try {
+    const wallet = await getWallet(agentId);
+    const budget = await getBudget(agentId);
+    const fiatBudget = (budget.budgetCents || 0) / 100;
+    const usdcBalance = parseFloat(wallet.balanceUsdc);
+    const effective = usdcBalance + fiatBudget;
+
+    if (options.json) return output({ ...wallet, fiatBudgetCents: budget.budgetCents, effectiveUsdc: effective.toFixed(2) }, true);
+
+    console.log();
+    console.log(`  USDC Balance:  ${chalk.green(wallet.balanceUsdc + " USDC")}`);
+    console.log(`  FIAT Budget:   ${chalk.green("$" + fiatBudget.toFixed(2))} ${chalk.dim("(available for auto-conversion)")}`);
+    console.log(`  Effective:     ${chalk.green("~$" + effective.toFixed(2))} ${chalk.dim("total spending power")}`);
+    console.log();
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+export async function agentWalletSendCmd(options) {
+  // Validate input before making any API calls
+  if (options.to && options.url) {
+    const err = "Cannot use both --to and --url. Use --to for direct sends, --url for x402.";
+    if (options.json) return output({ success: false, error: err }, true);
+    console.log(`  Error: ${err}`);
+    return;
+  }
+  if (options.to && !options.amount) {
+    const err = "--to requires --amount";
+    if (options.json) return output({ success: false, error: err }, true);
+    console.log(`  Error: ${err}`);
+    return;
+  }
+  if (options.amount && !options.to) {
+    const err = "--amount requires --to";
+    if (options.json) return output({ success: false, error: err }, true);
+    console.log(`  Error: ${err}`);
+    return;
+  }
+  if (!options.to && !options.url) {
+    const err = "Provide --to <address> --amount <usdc> or --url <x402-url>";
+    if (options.json) return output({ success: false, error: err }, true);
+    console.log(`  Error: ${err}`);
+    return;
+  }
+
+  const agentId = await getAgentId();
+
+  const data = {};
+  if (options.to) {
+    data.to = options.to;
+    data.amountUsdc = options.amount;
+  } else if (options.url) {
+    data.url = options.url;
+    if (options.protocol) data.protocol = options.protocol;
+  }
+
+  if (options.memo) data.memo = options.memo;
+
+  try {
+    const result = await walletSend(agentId, data);
+    if (options.json) return output(result, true);
+
+    if (result.success) {
+      console.log();
+      console.log(`  ${chalk.green("Sent!")} ${result.amountUsdc} USDC → ${result.to}`);
+      console.log(`  TX:       ${chalk.dim(result.txHash)}`);
+      console.log(`  Protocol: ${result.protocol}`);
+      if (result.fiatConverted) {
+        console.log(`  Converted: ${result.fiatConverted} from FIAT budget`);
+      }
+      console.log();
+    } else {
+      console.log(`  Error: ${result.error}`);
+    }
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+export async function agentWalletTransactionsCmd(options) {
+  const agentId = await getAgentId();
+
+  try {
+    const result = await walletTransactionsApi(agentId, { limit: options.limit });
+    if (options.json) return output(result, true);
+
+    const txns = result.transactions || [];
+    if (!txns.length) {
+      console.log("  No wallet transactions");
+      return;
+    }
+
+    console.log();
+    for (const t of txns) {
+      const dir = t.type === "receive" ? chalk.green("←") : t.type === "send" ? chalk.blue("→") : chalk.yellow("⟳");
+      const date = new Date(t.createdAt).toLocaleString();
+      console.log(`  ${dir}  ${t.amountUsdc} USDC  ${chalk.dim(t.counterparty || "")}  ${chalk.dim(t.protocol)}  ${chalk.dim(date)}`);
+    }
+    console.log();
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+export async function agentWalletFundCmd(options) {
+  if (!options.amount) {
+    const err = "--amount is required (in dollars, e.g., 10.00)";
+    if (options.json) return output({ success: false, error: err }, true);
+    console.log(`  Error: ${err}`);
+    return;
+  }
+
+  const agentId = await getAgentId();
+  try {
+    const result = await walletFund(agentId, options.amount);
+    if (options.json) return output(result, true);
+
+    if (result.success) {
+      console.log();
+      console.log(`  ${chalk.green("Funded!")} ${result.funded} USDC added to wallet`);
+      console.log(`  Cost:    $${(result.costCents / 100).toFixed(2)} (includes $${(result.feeCents / 100).toFixed(2)} fee)`);
+      console.log(`  TX:      ${chalk.dim(result.txHash)}`);
+      console.log(`  Budget:  $${(result.newFiatBudgetCents / 100).toFixed(2)} remaining`);
+      console.log();
+    } else {
+      console.log(`  Error: ${result.error}`);
+    }
+  } catch (err) {
+    if (options.json) return output({ success: false, error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+export async function agentWalletActionCmd(action, options) {
+  const agentId = await getAgentId();
+  try {
+    const result = await walletAction(agentId, action);
+    if (options.json) return output(result, true);
+    console.log(`  Wallet ${action}: ${result.status}`);
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+// ── On-Chain Identity (ERC-8004) ──
+
+export async function agentIdentityCmd(options) {
+  const agentId = await getAgentId();
+
+  // Try to get existing on-chain identity
+  try {
+    const identity = await getOnChainIdentity(agentId);
+    if (options.json) return output(identity, true);
+
+    console.log();
+    console.log(`  ${orange.bold("On-Chain Identity (ERC-8004)")}`);
+    console.log();
+    if (identity.metadata) {
+      console.log(`  Name:       ${identity.metadata.name}`);
+      console.log(`  Address:    ${orange(identity.walletAddress)}`);
+      console.log(`  Network:    ${identity.network}`);
+      console.log(`  Token ID:   ${chalk.dim(identity.tokenId)}`);
+      if (identity.metadata.properties) {
+        const caps = identity.metadata.properties.capabilities || [];
+        console.log(`  Capabilities: ${caps.join(", ") || "none"}`);
+      }
+    } else {
+      console.log(`  Wallet:     ${orange(identity.walletAddress)}`);
+      console.log(`  Token ID:   ${identity.tokenId}`);
+      console.log(`  URI:        ${chalk.dim(identity.metadataURI)}`);
+    }
+    console.log();
+    return;
+  } catch (err) {
+    // No identity found — offer to register
+    if (!err.message.includes("No on-chain identity") && !err.message.includes("No wallet") && !err.message.includes("404")) {
+      if (options.json) return output({ error: err.message }, true);
+      console.log(`  Error: ${err.message}`);
+      return;
+    }
+  }
+
+  // No identity found
+  if (options.json) {
+    // In JSON mode, try to register automatically
+    try {
+      const result = await registerOnChainIdentity(agentId, {});
+      return output(result, true);
+    } catch (err) {
+      return output({ error: err.message }, true);
+    }
+  }
+
+  // Interactive prompt to register
+  const prompts = await import("@clack/prompts");
+  const shouldRegister = await prompts.confirm({
+    message: "No on-chain identity found. Register one now?",
+  });
+
+  if (prompts.isCancel(shouldRegister) || !shouldRegister) {
+    console.log("  Registration cancelled.");
+    return;
+  }
+
+  try {
+    const result = await registerOnChainIdentity(agentId, {});
+    console.log();
+    console.log(`  ${chalk.green("Identity prepared!")}`);
+    console.log();
+    console.log(`  Wallet:       ${orange(result.walletAddress)}`);
+    console.log(`  Network:      ${result.network}`);
+    console.log(`  Standard:     ERC-8004`);
+    if (result.metadata?.properties?.capabilities) {
+      console.log(`  Capabilities: ${result.metadata.properties.capabilities.join(", ")}`);
+    }
+    console.log();
+    if (result.note) {
+      console.log(chalk.dim(`  ${result.note}`));
+      console.log();
+    }
+  } catch (err) {
+    console.log(`  Error registering identity: ${err.message}`);
+  }
+}
+
+// ── A2A Agent Card ──
+
+export async function agentCardCmd(options) {
+  const agentId = await getAgentId();
+
+  try {
+    const card = await getAgentCard(agentId);
+    if (options.json) return output(card, true);
+
+    console.log();
+    console.log(`  ${orange.bold("A2A Agent Card")}`);
+    console.log();
+    console.log(`  Name:        ${card.name}`);
+    console.log(`  Description: ${card.description}`);
+    console.log(`  URL:         ${chalk.dim(card.url)}`);
+    console.log(`  Version:     ${card.version}`);
+    console.log(`  Provider:    ${card.provider.organization}`);
+    console.log();
+    console.log(`  ${orange("Skills:")}`);
+    for (const skill of card.skills || []) {
+      console.log(`    - ${chalk.bold(skill.name)} ${chalk.dim(`[${skill.tags.join(", ")}]`)}`);
+      console.log(`      ${skill.description}`);
+    }
+    console.log();
+    console.log(`  Auth:        ${(card.authentication?.schemes || []).join(", ")}`);
+    console.log(`  Input:       ${(card.defaultInputModes || []).join(", ")}`);
+    console.log(`  Output:      ${(card.defaultOutputModes || []).join(", ")}`);
+    console.log();
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}
+
+// ── Discovery ──
+
+export async function agentDiscoverCmd(options) {
+  try {
+    const result = await discoverServices({
+      query: options.query,
+      limit: options.limit,
+    });
+    if (options.json) return output(result, true);
+
+    const services = result.services || [];
+    if (!services.length) {
+      console.log(`  No services found${options.query ? ` for "${options.query}"` : ""}`);
+      console.log(chalk.dim("  The x402 ecosystem is growing — try a broader search or check back later."));
+      return;
+    }
+
+    console.log();
+    console.log(`  ${chalk.green(services.length)} services found${options.query ? ` for "${options.query}"` : ""}`);
+    console.log();
+    for (const s of services) {
+      console.log(`  ${orange(s.url)}`);
+      console.log(`    ${s.description}`);
+      console.log(`    Price: ${chalk.green(s.priceUsdc + " USDC")}  Network: ${chalk.dim(s.network)}`);
+      console.log();
+    }
+    console.log(chalk.dim("  Pay for any service: clawcard agent wallet send --url <url> --json"));
+    console.log();
+  } catch (err) {
+    if (options.json) return output({ error: err.message }, true);
+    console.log(`  Error: ${err.message}`);
+  }
+}

package/src/commands/signup.js

@@ -72,28 +72,41 @@ export async function signupCommand() {
         message: "Payment complete?",
       });
 
-      if (p.isCancel(ready) || !ready) return;
+      if (!p.isCancel(ready) && ready) {
+        // Step 2: Create key
+        const createKey = await p.confirm({
+          message: "Create your agent key now?",
+        });
 
-      // Step 2: Create key
-      const createKey = await p.confirm({
-        message: "Create your agent key now?",
-      });
+        if (!p.isCancel(createKey) && createKey) {
+          const { keysCreateCommand } = await import("./keys.js");
+          await keysCreateCommand();
 
-      if (!p.isCancel(createKey) && createKey) {
-        const { keysCreateCommand } = await import("./keys.js");
-        await keysCreateCommand();
+          // Step 3: Setup
+          const runSetup = await p.confirm({
+            message: "Set up your agent now?",
+          });
 
-        // Step 3: Setup
-        const runSetup = await p.confirm({
-          message: "Set up your agent now?",
-        });
-
-        if (!p.isCancel(runSetup) && runSetup) {
-          const { setupCommand } = await import("./setup.js");
-          await setupCommand();
+          if (!p.isCancel(runSetup) && runSetup) {
+            const { setupCommand } = await import("./setup.js");
+            await setupCommand();
+          }
         }
       }
     }
+
+    // Always show next steps so the user knows where to go
+    p.note(
+      [
+        `${orange.bold("claw topup")}        ${chalk.dim("Top up your balance")}`,
+        `${orange.bold("claw keys create")}  ${chalk.dim("Create an agent key")}`,
+        `${orange.bold("claw setup")}        ${chalk.dim("Set up your agent")}`,
+        `${orange.bold("claw dashboard")}    ${chalk.dim("Open the portal")}`,
+        "",
+        chalk.dim(`Or visit: ${BASE_URL}/dashboard`),
+      ].join("\n"),
+      "You can pick up where you left off anytime"
+    );
   } catch (err) {
     s.stop("Signup failed");
     p.log.error(err.message);

package/src/index.js

@@ -208,6 +208,78 @@ agentCards
     await agentCardsActionCmd(cardId, "resume", options);
   });
 
+// Agent wallet
+const agentWallet = agent.command("wallet").description("Stablecoin wallet (USDC on Base)");
+agentWallet
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletCmd } = await import("./commands/agent.js");
+    await agentWalletCmd(options);
+  });
+agentWallet
+  .command("balance")
+  .description("Check wallet balance + effective spending power")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletBalanceCmd } = await import("./commands/agent.js");
+    await agentWalletBalanceCmd(options);
+  });
+agentWallet
+  .command("send")
+  .description("Send USDC to an address or pay an x402/MPP URL")
+  .option("--to <address>", "Recipient 0x address")
+  .option("--amount <usdc>", "Amount in USDC (e.g., 5.00)")
+  .option("--url <url>", "URL to pay for access (x402 or MPP)")
+  .option("--protocol <protocol>", "Payment protocol: x402 (default) or mpp")
+  .option("--memo <memo>", "Optional memo")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletSendCmd } = await import("./commands/agent.js");
+    await agentWalletSendCmd(options);
+  });
+agentWallet
+  .command("transactions")
+  .description("View wallet transaction history")
+  .option("--limit <n>", "Max results", "50")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletTransactionsCmd } = await import("./commands/agent.js");
+    await agentWalletTransactionsCmd(options);
+  });
+agentWallet
+  .command("fund")
+  .description("Fund wallet with USDC from FIAT balance")
+  .requiredOption("--amount <dollars>", "Amount in dollars to convert (e.g., 10.00)")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletFundCmd } = await import("./commands/agent.js");
+    await agentWalletFundCmd(options);
+  });
+agentWallet
+  .command("freeze")
+  .description("Freeze wallet (block all sends)")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletActionCmd } = await import("./commands/agent.js");
+    await agentWalletActionCmd("freeze", options);
+  });
+agentWallet
+  .command("unfreeze")
+  .description("Unfreeze wallet")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletActionCmd } = await import("./commands/agent.js");
+    await agentWalletActionCmd("unfreeze", options);
+  });
+agentWallet
+  .command("close")
+  .description("Permanently close wallet")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentWalletActionCmd } = await import("./commands/agent.js");
+    await agentWalletActionCmd("close", options);
+  });
+
 // Agent credentials
 const agentCreds = agent.command("creds").description("Credential vault");
 agentCreds
@@ -278,6 +350,38 @@ agent
     await agentBillingAddressCmd(options);
   });
 
+// Agent on-chain identity (ERC-8004)
+agent
+  .command("identity")
+  .description("Register or view ERC-8004 on-chain identity")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentIdentityCmd } = await import("./commands/agent.js");
+    await agentIdentityCmd(options);
+  });
+
+// Agent A2A card
+agent
+  .command("card")
+  .description("View A2A agent card (discovery document)")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentCardCmd } = await import("./commands/agent.js");
+    await agentCardCmd(options);
+  });
+
+// Agent discover (x402 service discovery)
+agent
+  .command("discover")
+  .description("Discover paid services in the x402 ecosystem")
+  .option("--query <query>", "Search term (e.g., 'web search', 'enrichment')")
+  .option("--limit <n>", "Max results", "20")
+  .option("--json", "Output as JSON")
+  .action(async (options) => {
+    const { agentDiscoverCmd } = await import("./commands/agent.js");
+    await agentDiscoverCmd(options);
+  });
+
 // Settings
 program
   .command("settings")