@clawcard/cli 2.1.8 → 3.0.1

package/README.md

@@ -1,8 +1,8 @@
 # @clawcard/cli
 
-On-demand credit cards, email, and phone for your AI agents.
+The complete identity for autonomous AI agents.
 
-ClawCard gives your agent a full identity — dedicated email inbox, SMS-enabled US phone number, virtual Mastercards with spend limits, and an encrypted credential vault. Your agent interacts with ClawCard through CLI commands — the API key never enters the agent's context.
+One command gives your agent email, phone, virtual cards, a USDC crypto wallet, on-chain identity, and access to every paid API on the internet. Works with Claude Code, Cursor, Gemini CLI, and any MCP-compatible agent.
 
 ## Install
 
@@ -26,28 +26,81 @@ clawcard keys create
 clawcard setup
 ```
 
-`clawcard setup` uses [skills.sh](https://skills.sh) to install the ClawCard skill for your agent. Works with Claude Code, Cursor, Codex, Cline, OpenClaw, and 40+ other agents.
+`clawcard setup` uses [skills.sh](https://skills.sh) to install the ClawCard skill for your agent.
+
+## What Your Agent Gets
+
+| Capability | Description |
+|---|---|
+| Email | Dedicated inbox at `@mail.clawcard.sh` |
+| Phone | SMS-enabled US phone number |
+| Virtual Cards | Instant Visa cards with per-card spend limits |
+| Crypto Wallet | USDC on Base — gasless transfers, x402 + MPP payments |
+| Service Discovery | Find and pay for any API in the x402 ecosystem |
+| On-Chain Identity | ERC-8004 NFT — verifiable, portable agent identity |
+| Credentials | AES-256 encrypted vault for API keys and secrets |
+| Spending Guardrails | Per-agent, per-transaction, per-day limits |
 
 ## Agent Commands
 
 Your agent runs these commands directly. All support `--json` for machine-parseable output.
 
+### Identity & Info
+
+| Command | Description |
+|---|---|
+| `clawcard agent info --json` | Agent identity (email, phone, wallet, budget) |
+| `clawcard agent budget --json` | Check remaining FIAT budget |
+| `clawcard agent activity --json` | View activity log |
+
+### Communication
+
 | Command | Description |
 |---|---|
-| `clawcard agent info --json` | Agent identity (email, phone, budget) |
 | `clawcard agent emails --json` | List inbox |
 | `clawcard agent emails send --to --subject --body --json` | Send email |
 | `clawcard agent sms --json` | List SMS messages |
 | `clawcard agent sms send --to --body --json` | Send SMS |
+
+### Virtual Cards (FIAT)
+
+| Command | Description |
+|---|---|
 | `clawcard agent cards --json` | List virtual cards |
 | `clawcard agent cards create --amount --type --memo --json` | Create card |
 | `clawcard agent cards details <id> --json` | Get PAN, CVV, expiry |
 | `clawcard agent cards close <id> --json` | Close card |
+
+### Crypto Wallet (USDC on Base)
+
+| Command | Description |
+|---|---|
+| `clawcard agent wallet --json` | View wallet (or create one) |
+| `clawcard agent wallet balance --json` | Balance + spending power |
+| `clawcard agent wallet fund --amount <dollars> --json` | Fund wallet from FIAT balance |
+| `clawcard agent wallet send --to <0x> --amount <usdc> --json` | Send USDC |
+| `clawcard agent wallet send --url <url> --json` | Pay an x402 API |
+| `clawcard agent wallet send --url <url> --protocol mpp --json` | Pay an MPP API |
+| `clawcard agent wallet transactions --json` | Transaction history |
+| `clawcard agent wallet freeze --json` | Freeze wallet |
+| `clawcard agent wallet unfreeze --json` | Unfreeze wallet |
+| `clawcard agent wallet close --json` | Close wallet permanently |
+
+### Discovery & Identity
+
+| Command | Description |
+|---|---|
+| `clawcard agent discover --query "web search" --json` | Find x402 services |
+| `clawcard agent identity --json` | Register/view ERC-8004 on-chain identity |
+| `clawcard agent card --json` | View A2A agent card (discovery document) |
+
+### Credentials
+
+| Command | Description |
+|---|---|
 | `clawcard agent creds --json` | List stored credentials |
 | `clawcard agent creds set --service --key --value --json` | Store credential |
 | `clawcard agent creds get --service --key --json` | Retrieve credential |
-| `clawcard agent budget --json` | Check remaining budget |
-| `clawcard agent activity --json` | View activity log |
 
 ## User Commands
 
@@ -60,33 +113,45 @@ Your agent runs these commands directly. All support `--json` for machine-parsea
 | `clawcard agent` | Show agent identity |
 | `clawcard agent fund` | Add budget to your agent |
 | `clawcard keys create` | Create agent key |
-| `clawcard keys revoke` | Revoke key (exports credentials first) |
+| `clawcard keys revoke` | Revoke key |
 | `clawcard setup` | Install ClawCard skill |
 | `clawcard billing` | Billing dashboard |
 | `clawcard billing topup` | Top up balance |
 | `clawcard billing balance` | Quick balance check |
 | `clawcard referral` | Show referral code |
+| `clawcard settings` | Manage billing address |
 | `clawcard help` | Show all commands |
 
 ## How It Works
 
-1. You create an agent key via the CLI — it gets an email, phone number, and budget
-2. `clawcard setup` installs a skill file that teaches your agent the available commands
-3. Your agent runs `clawcard agent` commands to send emails, create cards, store credentials, etc.
-4. The API key stays in `~/.clawcard/.env` — the agent never sees it
+1. You create an agent key — it gets email, phone, and budget
+2. `clawcard setup` installs the skill that teaches your agent the commands
+3. Agent creates a wallet, discovers services, pays for APIs, signs up for things
+4. Everything is logged — full audit trail in the dashboard
+5. You control the budget and can freeze/close anything instantly
+
+## Payment Protocols
+
+ClawCard is the first platform to unify both major machine payment protocols:
+
+- **x402** (Coinbase) — Pay-per-request API payments with USDC. 50M+ transactions.
+- **MPP** (Stripe/Tempo) — Session-based machine payments. Cards, stablecoins, Lightning.
+
+Your agent pays for any service in either ecosystem. You never think about protocols.
 
 ## Pricing
 
 Pay as you go. No subscriptions, no monthly fees.
 
 - **Minimum top-up** — $5
-- **Processing fee** — 10%
+- **Processing fee** — 10% on FIAT top-ups
+- **Wallet funding fee** — 2% on FIAT-to-USDC conversion
 - **Cards** — Unlimited
-
-Top up your balance and your agent spends it on virtual cards.
+- **x402/MPP payments** — Pay source price (no markup)
 
 ## Links
 
 - [Website](https://clawcard.sh)
 - [Docs](https://clawcard.sh/docs)
 - [Skill](https://github.com/latchagent/skill)
+- [Dashboard](https://clawcard.sh/dashboard)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawcard/cli",
-  "version": "2.1.8",
+  "version": "3.0.1",
   "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/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")