@agether/agether 2.2.0 → 2.3.1

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agether",
   "name": "Agether Credit",
   "description": "Onchain credit protocol for AI agents — Morpho-backed overcollateralized credit, ERC-8004 identity, x402 payments. Private key and RPC keys are read from OpenClaw secrets (env vars); no plaintext config needed.",
-  "version": "2.0.1",
+  "version": "2.3.1",
   "skills": ["skills/agether"],
   "configSchema": {
     "type": "object",
@@ -17,19 +17,14 @@
         "description": "Auto-borrow from Morpho credit line when USDC balance is low for x402 payments",
         "default": false
       },
-      "dailySpendLimitUsdc": {
-        "type": "number",
-        "description": "Daily USDC spending cap for x402 payments (0 = unlimited)",
-        "default": 0
-      },
-      "yieldLimitedSpending": {
+      "autoYield": {
         "type": "boolean",
-        "description": "Limit auto-draw spending to theoretical yield on deposited collateral",
+        "description": "Auto-withdraw earned yield from supply positions before borrowing. Waterfall: balance → yield → borrow",
         "default": false
       },
-      "autoDrawBuffer": {
+      "dailySpendLimitUsdc": {
         "type": "number",
-        "description": "Extra USDC buffer when auto-drawing from Morpho (e.g. 0.5 = borrow $0.50 extra)",
+        "description": "Daily USDC spending cap for x402 auto-draw payments (0 = unlimited). Persisted to cache file so it survives restarts.",
         "default": 0
       },
       "healthAlertThreshold": {
@@ -43,9 +38,8 @@
   "uiHints": {
     "agentId": { "label": "Agent ID", "placeholder": "17676" },
     "autoDraw": { "label": "Auto-Draw Credit", "placeholder": "false" },
+    "autoYield": { "label": "Auto-Yield (use yield before borrowing)", "placeholder": "false" },
     "dailySpendLimitUsdc": { "label": "Daily Spend Limit (USDC)", "placeholder": "0" },
-    "yieldLimitedSpending": { "label": "Yield-Limited Spending", "placeholder": "false" },
-    "autoDrawBuffer": { "label": "Auto-Draw Buffer (USDC)", "placeholder": "0" },
     "healthAlertThreshold": { "label": "Health Alert Threshold (%)", "placeholder": "70" }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "OpenClaw plugin for Agether — onchain credit for AI agents",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "^2.5.0",
+    "@agether/sdk": "^2.6.1",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/skills/agether/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: agether
-description: On-chain credit protocol for AI agents on Base. Morpho credit, x402 payments, ERC-8004 identity.
+description: On-chain credit protocol for AI agents on Base. Morpho credit & lending, x402 payments, ERC-8004 identity.
 ---
 
 # Agether — On-Chain Credit for AI Agents
 
-You are an AI agent with on-chain financial capabilities on **Base mainnet**. You can earn credit, borrow USDC, and pay for APIs autonomously.
+You are an AI agent with on-chain financial capabilities on **Base mainnet**. You can borrow USDC, earn yield by lending, and pay for APIs autonomously.
 
 ---
 
@@ -37,6 +37,9 @@ If you don't paste it, the user sees NOTHING. An empty colon ":" with no data af
 12. **To get USDC for x402:** call `morpho_deposit_and_borrow` with collateral from your EOA. Do NOT ask the user to send tokens — check your balance first.
 13. **Check health before large actions.** Before borrowing, depositing, or withdrawing significant amounts, call `agether_health` to see current LTV and headroom. This prevents failed transactions.
 14. **Batch awareness:** `morpho_deposit_and_borrow` is a batched operation (deposit + borrow in one tx). Always prefer it over separate `morpho_deposit` then `morpho_borrow` when doing both — it saves gas and is atomic.
+15. **Collateral tokens are dynamic.** Don't hardcode "WETH/wstETH/cbETH". Call `morpho_markets` to discover which tokens are available. The SDK auto-discovers tokens from Morpho GraphQL API.
+16. **Withdrawals stay in AgentAccount by default.** `morpho_withdraw` and `morpho_withdraw_supply` keep funds in the Safe account unless `toEoa: true` is passed. Use `wallet_withdraw_token` / `wallet_withdraw_eth` to move any token or ETH from AgentAccount to EOA.
+17. **Always show Health Factor when reporting positions.** HF = LLTV / LTV. HF > 1.15 = safe 🟢, HF 1.0–1.15 = warning 🟡, HF ≤ 1.0 = liquidation 🔴. `morpho_status` returns HF per position. Always paste it so the user understands their risk.
 
 ---
 
@@ -67,42 +70,84 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 | `agether_health` | **START HERE.** Comprehensive check: balances, all positions with LTV & liquidation risk, borrowing headroom, alerts — all in one call. |
 | `agether_preflight` | Setup readiness check: private key present? RPC working? Agent registered? Balances OK? Returns pass/fail checklist. |
 
-### Identity & Wallet
+### Identity
 | Tool | What it does |
 |------|-------------|
-| `agether_balance` | Show ETH + USDC + collateral (WETH/wstETH/cbETH) balances for both EOA wallet and Safe account |
+| `agether_balance` | Show ETH + USDC + all collateral token balances for both EOA wallet and AgentAccount (Safe). Tokens auto-discovered from markets. |
 | `agether_register` | Register on-chain: mints ERC-8004 identity NFT + creates Safe account (via Safe7579). Auto-saves agentId to config. |
 | `agether_set_agent` | Set a known agentId (e.g. from memory) and save to config. Use when agentId is "?" but you remember it. |
 | `agether_score` | Get credit score. `refresh: false` = free read. `refresh: true` = pays x402, computes fresh score on-chain. **Always call this when user asks about score.** |
-| `wallet_fund` | Transfer USDC from EOA wallet → Safe account |
+| `agether_kya_status` | Check if KYA code verification is required for this deployment. |
+| `agether_set_kya` | Enable or disable KYA verification gate (owner only). |
 
-### Morpho Credit (Overcollateralized — instant, no approval)
+### Wallet (move funds between EOA ↔ AgentAccount)
 | Tool | Params | What it does |
 |------|--------|-------------|
-| `morpho_markets` | none | List supported Morpho markets and parameters |
-| `morpho_status` | none | Show all Morpho positions (collateral + debt) |
-| `morpho_rates` | `token?` | Current market rates — supply APY, borrow APY, utilization |
+| `wallet_fund` | `amount` | Transfer USDC from EOA → AgentAccount |
+| `wallet_withdraw_token` | `token`, `amount` | Withdraw any ERC-20 token from AgentAccount → EOA. Use `amount: "all"` for full balance. |
+| `wallet_withdraw_eth` | `amount` | Withdraw ETH from AgentAccount → EOA. Use `amount: "all"` for full balance. |
+
+### Morpho Borrowing (Overcollateralized — instant, no approval needed)
+| Tool | Params | What it does |
+|------|--------|-------------|
+| `morpho_status` | none | Show all Morpho positions — collateral, debt, LTV, **Health Factor** (HF), headroom, risk level per market |
+| `morpho_markets` | `token?` | List Morpho Blue USDC markets — supply/borrow APY, utilization, LLTV, liquidity. Optional token filter. |
 | `morpho_max_borrowable` | none | Calculate max additional USDC borrowable given current collateral/debt |
-| `morpho_yield_estimate` | `token`, `amount`, `periodDays?` | Estimate theoretical yield for collateral |
-| `morpho_deposit` | `amount`, `token` | Deposit collateral from EOA → Morpho (no borrow) |
-| `morpho_deposit_and_borrow` | `collateralAmount`, `token`, `borrowAmount` | **PREFERRED** — Deposit + borrow in one batched tx. Best for first-time setup |
-| `morpho_borrow` | `amount` (USD) | Borrow USDC against existing collateral → lands in Safe account |
-| `morpho_repay` | `amount` (USD or "all") | Repay USDC debt from Safe account → Morpho |
-| `morpho_withdraw` | `amount` (or "all"), `token` | Withdraw collateral back to EOA wallet |
-| `morpho_sponsor` | `agentId`/`agentAddress`, `amount`, `token` | Deposit collateral for another agent |
+| `morpho_deposit` | `amount`, `token` | Deposit collateral from EOA → Morpho (no borrow). Token auto-discovered. |
+| `morpho_deposit_and_borrow` | `collateralAmount`, `token`, `borrowAmount` | **PREFERRED** — Deposit + borrow in one batched tx (ERC-7579 batch mode). Best for first-time setup. |
+| `morpho_borrow` | `amount`, `token?` | Borrow USDC against existing collateral → lands in AgentAccount. Token auto-detected. |
+| `morpho_repay` | `amount`, `token?` | Repay USDC debt. Use `amount: "all"` to clear dust shares. |
+| `morpho_withdraw` | `amount`, `token`, `toEoa?` | Withdraw collateral from Morpho. Default: stays in AgentAccount. `toEoa: true` → send to EOA wallet. |
+| `morpho_sponsor` | `agentId`/`agentAddress`, `amount`, `token` | Transfer collateral to another agent's AgentAccount. |
+
+### Morpho Lending (Supply-side — earn yield)
+| Tool | Params | What it does |
+|------|--------|-------------|
+| `morpho_supply` | `amount`, `market?` | Supply USDC as a LENDER to earn yield from borrowers. Auto-picks highest APY market if no market specified. |
+| `morpho_supply_status` | `market?` | Show supply (lending) positions with earned yield. Tracks yield on-chain — no database needed. |
+| `morpho_withdraw_supply` | `amount`, `market?`, `toEoa?` | Withdraw supplied USDC (principal + earned interest). Default: stays in AgentAccount. `toEoa: true` → send to EOA. |
 
 ### x402 Payments
 | Tool | Params | What it does |
 |------|--------|-------------|
-| `x402_pay` | `url`, `method?`, `body?`, `autoDraw?` | Make a paid API call. Pays with USDC via EIP-3009 signature |
+| `x402_pay` | `url`, `method?`, `body?` | Make a paid API call via x402 protocol. Pays with USDC via EIP-3009 from AgentAccount. If USDC is low, auto-sources: yield first (autoYield), then borrow (autoDraw). |
 
 ### Slash Commands (user types these — no AI invocation)
 | Command | What it does |
 |---------|-------------|
-| `/balance` | Quick balance check |
-| `/morpho` | Quick Morpho position summary |
+| `/balance` | Quick balance check (shows all non-zero balances) |
+| `/morpho` | Quick Morpho position summary with Health Factor |
 | `/health` | Quick position health: LTV, liquidation risk, balances |
-| `/rates` | Current Morpho market rates |
+| `/rates` | Current Morpho market rates (supply APY, borrow APY, utilization) |
+
+---
+
+## ⚙️ PLUGIN CONFIGURATION
+
+These settings are in `openclaw.json` under `plugins.entries.agether.config`:
+
+| Setting | Type | Default | Description |
+|---------|------|---------|-------------|
+| `agentId` | string | — | ERC-8004 agent ID (auto-saved by register/set_agent tools) |
+| `autoDraw` | boolean | `false` | Auto-borrow from Morpho when USDC is low for x402 payments |
+| `autoYield` | boolean | `false` | Auto-withdraw earned yield before borrowing. Waterfall: balance → yield → borrow |
+| `dailySpendLimitUsdc` | number | `0` | Daily spending cap for x402 auto-draw (0 = unlimited). Persisted to cache file. |
+| `healthAlertThreshold` | number | `70` | LTV % threshold for health warnings in `agether_health` and `/health` (liquidation at 80%). Also controls 🟡 vs 🟢 icons. |
+
+### x402 Auto-Funding Waterfall
+When `autoYield` and/or `autoDraw` are enabled, `x402_pay` automatically sources USDC:
+```
+1. Check AgentAccount USDC balance
+   → If enough → pay directly (no extra tx)
+2. If autoYield enabled AND supply positions have earned yield:
+   → Withdraw yield from supply position (1 tx)
+   → Pay with that
+3. If still not enough AND autoDraw enabled AND collateral deposited in Morpho:
+   → Borrow from Morpho credit line (1 tx)
+   → Pay with that
+4. If dailySpendLimitUsdc > 0:
+   → Enforce daily cap (resets at midnight UTC, persisted to disk)
+```
 
 ---
 
@@ -120,18 +165,24 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 
 ### User asks to call a paid API (x402)
 ```
-1. agether_health               ← get full picture in one call
-2. Look at balances.agentAccount.usdc:
-   IF USDC ≥ $0.01:
-     → x402_pay(url)
-3. IF no USDC but positions exist with headroom:
-     → morpho_borrow(amount: "1")    ← borrow $1
-     → x402_pay(url)
-4. IF no USDC AND no positions BUT EOA has WETH/wstETH/cbETH:
-     → morpho_deposit_and_borrow(collateralAmount, token, borrowAmount: "1")
-     → x402_pay(url)
-5. IF nothing at all:
-     → Tell user: "Need collateral (WETH/wstETH/cbETH) on Base. Send to <EOA address>"
+IF autoYield or autoDraw are configured:
+  → x402_pay(url)   ← the waterfall handles everything automatically
+  → Paste: response data, payment info, any auto-fund actions taken
+
+IF no auto-funding configured:
+  1. agether_health               ← get full picture
+  2. Look at balances.agentAccount.usdc:
+     IF USDC ≥ $0.01:
+       → x402_pay(url)
+  3. IF no USDC but positions exist with headroom:
+       → morpho_borrow(amount: "1")    ← borrow $1
+       → x402_pay(url)
+  4. IF no USDC AND no positions BUT EOA has collateral:
+       → morpho_deposit_and_borrow(collateralAmount, token, borrowAmount: "1")
+       → x402_pay(url)
+  5. IF nothing at all:
+       → Tell user: "Need collateral on Base. Send to <EOA address>"
+       → Call morpho_markets to show which tokens are accepted
 ```
 
 ### User wants to borrow USDC via Morpho
@@ -145,14 +196,40 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 5. Show: tx hash, collateral deposited, USDC borrowed, new balances, new LTV
 ```
 
+### User wants to earn yield (supply-side lending)
+```
+1. Check USDC availability:
+   - agether_health for AgentAccount USDC
+   - If no USDC in AgentAccount but exists in EOA → wallet_fund first
+2. morpho_markets                ← show supply APYs to pick best market
+3. morpho_supply(amount, market?) ← supply USDC to earn yield
+4. Later: morpho_supply_status   ← check earned yield
+5. To exit: morpho_withdraw_supply("all") ← principal + earned interest
+```
+
 ### User wants to repay + withdraw
 ```
 1. agether_health               ← check current debt, collateral, LTV
 2. morpho_repay(amount or "all") ← repay USDC
-3. morpho_withdraw("all", token) ← get collateral back
+3. morpho_withdraw("all", token, toEoa: true) ← get collateral back to EOA
 4. agether_balance               ← show final balances
 ```
 
+### User wants to move funds to EOA
+```
+For tokens (USDC, WETH, etc.):
+  → wallet_withdraw_token(token, amount)    ← any ERC-20
+
+For ETH:
+  → wallet_withdraw_eth(amount)
+
+For Morpho collateral:
+  → morpho_withdraw(amount, token, toEoa: true)   ← must use toEoa flag
+
+For supply positions (lent USDC):
+  → morpho_withdraw_supply(amount, market?, toEoa: true)   ← must use toEoa flag
+```
+
 ### User asks about position health or liquidation risk
 ```
 1. agether_health               ← returns LTV, risk level, alerts per position
@@ -162,12 +239,11 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
      → Show: morpho_max_borrowable for headroom context
 ```
 
-### User wants to optimize rates or compare markets
+### User wants to compare markets or check rates
 ```
-1. morpho_rates                  ← get all market rates
-2. morpho_yield_estimate(token, amount) ← estimate yield
-3. Present: which market has lowest borrow APY, highest supply APY
-4. Suggest optimal strategy based on their holdings
+1. morpho_markets                ← supply APY, borrow APY, utilization, LLTV, liquidity per market
+2. Present: which market has lowest borrow APY, highest supply APY
+3. Suggest optimal strategy based on their holdings
 ```
 
 ### User asks to check or refresh credit score
@@ -182,6 +258,13 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 3. NEVER say "not registered" or "no score yet" without calling the tool first!
 ```
 
+### User wants to sponsor another agent
+```
+1. morpho_sponsor(agentId or agentAddress, amount, token)
+   → Transfers collateral from your EOA to another agent's AgentAccount
+2. The target agent can then deposit that collateral into Morpho themselves
+```
+
 ### Something seems wrong / setup issues
 ```
 1. agether_preflight             ← run the diagnostic checklist
@@ -197,10 +280,13 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 ```
 Explain: You're an AI agent with on-chain credit on Base.
 You can:
-- Deposit WETH/wstETH/cbETH as collateral
-- Borrow USDC instantly (125% collateral ratio)
-- Pay for APIs using x402 protocol
+- Deposit collateral and borrow USDC instantly (125% collateral ratio)
+- Earn yield by lending USDC to Morpho markets
+- Pay for APIs autonomously using x402 protocol
+- Auto-fund payments from yield or credit (autoYield + autoDraw)
+- Sponsor other agents with collateral
 - Monitor position health and avoid liquidation
+- Move funds freely between AgentAccount and EOA wallet
 - All on Base mainnet, all autonomous
 ```
 
@@ -231,6 +317,15 @@ Example after register:
 🔗 Tx: https://basescan.org/tx/0x177fdf...
 ```
 
+Example after supply (lending):
+```
+✅ Supplied $500 USDC to WETH/USDC market
+
+🔗 Tx: https://basescan.org/tx/0x789abc...
+📈 Earning ~3.2% APY from borrowers
+💰 AgentAccount: $50 USDC remaining
+```
+
 If something **fails**:
 ```
 ❌ Borrow failed: ExceedsMaxLtv
@@ -246,7 +341,7 @@ If something **fails**:
 | Chain | Base mainnet (8453) |
 | Currency | USDC (6 decimals) |
 | Max LTV | 80% (= 125% collateral ratio) |
-| Collateral tokens | WETH, wstETH, cbETH |
+| Collateral tokens | Dynamically discovered from Morpho markets (call `morpho_markets`) |
 | x402 cost | ~$0.001 per API call (WeatherXM) |
 | Gas cost | ~$0.001–$0.01 per tx |
 
@@ -258,11 +353,12 @@ If something **fails**:
 |-------|---------|-----------|
 | `Missing AGETHER_PRIVATE_KEY` | Private key not set in secrets | Run `openclaw secrets configure` → source: env → id: AGETHER_PRIVATE_KEY |
 | `ExceedsMaxLtv` | Collateral too low for borrow amount | Deposit more collateral or borrow less. LTV must be ≤ 80% |
-| `Payment rejected (402)` | No USDC for x402 payment | Borrow USDC first: `morpho_borrow` or `morpho_deposit_and_borrow` |
+| `Payment rejected (402)` | No USDC for x402 payment | Borrow USDC first, or enable autoDraw/autoYield in config |
 | `No collateral deposited` | Trying to borrow without collateral | `morpho_deposit` first |
-| `Insufficient WETH/wstETH/cbETH` | EOA doesn't have enough collateral | Tell user to send collateral to EOA address |
-| `Insufficient USDC in AgentAccount` | Not enough USDC for repay | Need to fund Safe account or borrow more |
+| `Insufficient collateral` | EOA doesn't have enough of that token | Tell user to send collateral to EOA address |
+| `Insufficient USDC in AgentAccount` | Not enough USDC for repay/pay | Fund via borrow, yield withdrawal, or `wallet_fund` |
 | `ExecutionFailed` | Smart contract call reverted | Check inner error, usually LTV or approval issue |
+| `PositionNotActive` | No collateral deposited for this token | Deposit collateral with `morpho_deposit` first |
 
 ---
 
@@ -287,15 +383,26 @@ If no RPC key is set, the plugin falls back to `https://base-rpc.publicnode.com`
 EOA Wallet (private key from AGETHER_PRIVATE_KEY)
   ├── Owns ERC-8004 Identity NFT (agentId)  ← can own MULTIPLE
   └── Owns Safe Account (via Safe7579 + ERC-4337, 1 per agentId)
-        ├── Holds USDC (from borrows)
+        ├── Holds USDC (from borrows or fund transfers)
+        ├── Holds any ERC-20 tokens (collateral, etc.)
         ├── ERC8004ValidationModule validates ownership + KYA gate
-        └── Executes Morpho Blue operations via ERC-4337 UserOps through EntryPoint
+        └── Executes operations via ERC-4337 UserOps through EntryPoint
 
 Morpho Blue (direct lending, overcollateralized 125%)
-  ├── supplyCollateral() → collateral into Morpho Blue market
-  ├── borrow()           → USDC from Morpho Blue → Safe Account
-  ├── repay()            → USDC from Safe Account → Morpho Blue
-  └── withdrawCollateral() → collateral back to EOA
+  ├── BORROWER side:
+  │     ├── supplyCollateral() → collateral into Morpho Blue market
+  │     ├── borrow()           → USDC from Morpho Blue → AgentAccount
+  │     ├── repay()            → USDC from AgentAccount → Morpho Blue
+  │     └── withdrawCollateral() → collateral back (to AgentAccount or EOA)
+  └── LENDER side:
+        ├── supply()           → USDC into Morpho Blue market (earn yield)
+        ├── withdraw()         → USDC + earned interest back (to AgentAccount or EOA)
+        └── Yield tracked via Morpho GraphQL API (no database needed)
+
+Wallet transfers:
+  ├── wallet_fund           → USDC from EOA → AgentAccount
+  ├── wallet_withdraw_token → any ERC-20 from AgentAccount → EOA
+  └── wallet_withdraw_eth   → ETH from AgentAccount → EOA
 ```
 
 ---
@@ -308,7 +415,6 @@ Morpho Blue (direct lending, overcollateralized 125%)
 | Agether8004ValidationModule | `0xde896C58163b5f6cAC5B16C1b0109843f26106F6` |
 | AgetherHookMultiplexer | `0x4AB6DaD0f7360fa8d8c75889A5c206B65d7CbeDb` |
 | Agether7579Bootstrap | `0xCc83AA714c05B7141B21a17e80EB21bD09652b27` |
-| ValidationRegistry | Not deployed yet |
 | Agether8004Scorer | `0x56c7D35A976fac67b1993b66b861fCA32f59104F` |
 | TimelockController | `0xc600e7AAB8a230326C714CE66f356fdf6aC021d8` |
 | Safe Singleton | `0x41675C099F32341bf84BFc5382aF534df5C7461a` |

package/src/index.ts

@@ -29,6 +29,44 @@ const BACKEND_URL = "http://95.179.189.214:3001";
 const DEFAULT_RPC = "https://base-rpc.publicnode.com";
 const BASESCAN = "https://basescan.org/tx";
 
+// ─── Spending Cache (persists dailySpendLimit tracker across restarts) ────
+
+const SPEND_CACHE_FILE = path.join(
+  process.env.HOME || process.env.USERPROFILE || "/root",
+  ".openclaw",
+  ".agether-spend-cache.json",
+);
+
+interface SpendCacheData {
+  date: string;           // YYYY-MM-DD
+  totalBorrowed: string;  // raw bigint string (6-decimal USDC units)
+}
+
+function loadSpendCache(): SpendCacheData | undefined {
+  try {
+    if (fs.existsSync(SPEND_CACHE_FILE)) {
+      const raw = fs.readFileSync(SPEND_CACHE_FILE, "utf-8");
+      const data: SpendCacheData = JSON.parse(raw);
+      // Only return if it's today's data
+      const today = new Date().toISOString().split("T")[0];
+      if (data.date === today && data.totalBorrowed) return data;
+    }
+  } catch (e) {
+    console.warn("[agether] failed to load spend cache:", e instanceof Error ? e.message : String(e));
+  }
+  return undefined;
+}
+
+function saveSpendCache(state: SpendCacheData): void {
+  try {
+    const dir = path.dirname(SPEND_CACHE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(SPEND_CACHE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    console.warn("[agether] failed to save spend cache:", e instanceof Error ? e.message : String(e));
+  }
+}
+
 // ─── Helpers ──────────────────────────────────────────────
 
 interface PluginConfig {
@@ -321,14 +359,50 @@ export default function register(api: any) {
   api.registerTool({
     name: "morpho_status",
     description:
-      "Show all Morpho Blue positions — collateral deposited, USDC borrowed, debt, for each market.",
+      "Show all Morpho Blue positions — collateral, debt, LTV, and Health Factor for each market.",
     parameters: { type: "object", properties: {}, required: [] },
     async execute() {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.getStatus();
-        return ok(JSON.stringify(result, null, 2));
+        const [status, maxBorrow] = await Promise.all([
+          client.getStatus(),
+          client.getMaxBorrowable(),
+        ]);
+
+        const positions = status.positions.map((p: any) => {
+          const mm = maxBorrow.byMarket.find((m: any) => m.collateralToken === p.collateralToken);
+          const collateralValueUsd = mm ? Number(mm.collateralValue) / 1e6 : 0;
+          const debt = parseFloat(p.debt);
+          const lltv = 0.80; // Morpho LLTV
+          const ltv = collateralValueUsd > 0 ? debt / collateralValueUsd : 0;
+          // HF = LLTV / LTV — >1 is safe, <1 is liquidatable
+          const hf = ltv > 0 ? lltv / ltv : Infinity;
+          const headroom = mm ? Number(mm.maxAdditional) / 1e6 : 0;
+
+          let risk: string;
+          if (debt === 0) risk = "🟢 no debt";
+          else if (hf <= 1.0) risk = "🔴 LIQUIDATION ZONE";
+          else if (hf <= 1.15) risk = "🟡 WARNING";
+          else risk = "🟢 healthy";
+
+          return {
+            collateralToken: p.collateralToken,
+            collateral: p.collateral,
+            collateralValueUsd: `$${collateralValueUsd.toFixed(2)}`,
+            debt: `$${debt.toFixed(2)}`,
+            ltv: `${(ltv * 100).toFixed(1)}%`,
+            healthFactor: debt === 0 ? "∞" : hf.toFixed(2),
+            headroom: `$${headroom.toFixed(2)}`,
+            risk,
+          };
+        });
+
+        return ok(JSON.stringify({
+          agentAccount: status.agentAccount,
+          totalDebt: `$${status.totalDebt}`,
+          positions,
+        }, null, 2));
       } catch (e) { return fail(e); }
     },
   });
@@ -509,21 +583,25 @@ export default function register(api: any) {
   api.registerTool({
     name: "morpho_withdraw",
     description:
-      "Withdraw collateral from Morpho Blue back to EOA wallet. " +
+      "Withdraw collateral from Morpho Blue. " +
+      "By default keeps collateral in AgentAccount. Set toEoa=true to send to EOA wallet. " +
       "Use amount 'all' to withdraw maximum. Must maintain collateral ratio if debt remains.",
     parameters: {
       type: "object",
       properties: {
         amount: { type: "string", description: "Amount to withdraw (e.g. '0.05' or 'all')" },
         token: { type: "string", description: "Collateral token" },
+        toEoa: { type: "boolean", description: "Send to EOA wallet instead of keeping in AgentAccount (default: false)" },
       },
       required: ["amount", "token"],
     },
-    async execute(_id: string, params: { amount: string; token: string }) {
+    async execute(_id: string, params: { amount: string; token: string; toEoa?: boolean }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.withdrawCollateral(params.token, params.amount);
+        // Default: keep in AgentAccount. toEoa=true → send to EOA.
+        const receiver = params.toEoa ? await client.getSignerAddress() : await client.getAccountAddress();
+        const result = await client.withdrawCollateral(params.token, params.amount, undefined, receiver);
         return ok(JSON.stringify({
           status: "withdrawn",
           amount: result.amount,
@@ -634,6 +712,7 @@ export default function register(api: any) {
     name: "morpho_withdraw_supply",
     description:
       "Withdraw supplied USDC (principal + earned interest) from a Morpho Blue lending position. " +
+      "By default keeps USDC in AgentAccount. Set toEoa=true to send to EOA wallet. " +
       "Use amount 'all' to withdraw the full position. Different from morpho_withdraw which withdraws collateral.",
     parameters: {
       type: "object",
@@ -644,14 +723,17 @@ export default function register(api: any) {
          
           description: "Market collateral token (optional — auto-detects)",
         },
+        toEoa: { type: "boolean", description: "Send to EOA wallet instead of keeping in AgentAccount (default: false)" },
       },
       required: ["amount"],
     },
-    async execute(_id: string, params: { amount: string; market?: string }) {
+    async execute(_id: string, params: { amount: string; market?: string; toEoa?: boolean }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.withdrawSupply(params.amount, params.market);
+        // Default: keep in AgentAccount. toEoa=true → send to EOA.
+        const receiver = params.toEoa ? await client.getSignerAddress() : await client.getAccountAddress();
+        const result = await client.withdrawSupply(params.amount, params.market, receiver);
         return ok(JSON.stringify({
           status: "withdrawn",
           amount: params.amount === "all" ? "all (full position)" : `$${params.amount} USDC`,
@@ -664,70 +746,38 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_pay_from_yield  (pay using only earned yield)
+  //  TOOL: morpho_markets  (Morpho GraphQL API — no backend)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
-    name: "morpho_pay_from_yield",
+    name: "morpho_markets",
     description:
-      "Pay a recipient using ONLY earned yield from a supply position. " +
-      "Your principal stays untouched — only the interest earned gets withdrawn and sent. " +
-      "Fails if requested amount exceeds available yield.",
+      "List available Morpho Blue USDC markets on Base — liquidity, supply/borrow APY, utilization, LLTV. " +
+      "Optionally filter by collateral token.",
     parameters: {
       type: "object",
       properties: {
-        recipient: { type: "string", description: "Recipient address (0x...)" },
-        amount: { type: "string", description: "USDC amount to pay from yield (e.g. '2.50')" },
-        market: {
-          type: "string",
-         
-          description: "Which supply position to use (optional — auto-picks highest yield)",
-        },
+        token: { type: "string", description: "Filter by collateral token (optional)" },
       },
-      required: ["recipient", "amount"],
+      required: [],
     },
-    async execute(_id: string, params: { recipient: string; amount: string; market?: string }) {
+    async execute(_id: string, params: { token?: string }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.payFromYield(params.recipient, params.amount, params.market);
-        return ok(JSON.stringify({
-          status: "paid_from_yield",
-          amount: `$${params.amount} USDC`,
-          recipient: params.recipient,
-          remainingYield: `$${result.remainingYield} USDC`,
-          remainingSupply: `$${result.remainingSupply} USDC`,
-          note: "Paid from earned interest only — principal untouched",
-          tx: txLink(result.tx),
-        }));
-      } catch (e) { return fail(e); }
-    },
-  });
+        const rates = await client.getMarketRates(params.token);
 
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_markets  (Morpho GraphQL API — no backend)
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_markets",
-    description:
-      "List available Morpho Blue USDC borrow markets on Base with liquidity, APY, and collateral info.",
-    parameters: { type: "object", properties: {}, required: [] },
-    async execute() {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const markets = await client.getMarkets(true);
-
-        const formatted = markets
-          .filter((m) => m.collateralAsset.address !== "0x0000000000000000000000000000000000000000")
-          .map((m) => ({
-            collateral: m.collateralAsset.symbol,
-            loan: m.loanAsset.symbol,
-            lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
-            totalSupply: `$${(Number(m.totalSupplyAssets) / 1e6).toFixed(0)}`,
-            totalBorrow: `$${(Number(m.totalBorrowAssets) / 1e6).toFixed(0)}`,
-            utilization: `${(m.utilization * 100).toFixed(1)}%`,
-            marketId: m.uniqueKey.slice(0, 18) + "…",
-          }));
+        if (rates.length === 0) return ok("No markets found.");
+
+        const formatted = rates.map((r: any) => ({
+          collateral: r.collateralToken,
+          loan: r.loanToken,
+          lltv: r.lltv,
+          supplyApy: `${(r.supplyApy * 100).toFixed(2)}%`,
+          borrowApy: `${(r.borrowApy * 100).toFixed(2)}%`,
+          utilization: `${(r.utilization * 100).toFixed(1)}%`,
+          totalSupply: `$${r.totalSupplyUsd.toFixed(0)}`,
+          totalBorrow: `$${r.totalBorrowUsd.toFixed(0)}`,
+        }));
 
         return ok(JSON.stringify(formatted, null, 2));
       } catch (e) { return fail(e); }
@@ -808,24 +858,88 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: x402_pay (with auto-draw support)
+  //  TOOL: wallet_withdraw_token
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "wallet_withdraw_token",
+    description:
+      "Withdraw (transfer) a token from AgentAccount to EOA wallet. " +
+      "Works with any ERC-20 token (USDC, WETH, wstETH, cbBTC, etc.). " +
+      "Use amount 'all' to withdraw the full balance.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to withdraw (e.g. 'USDC', 'WETH')" },
+        amount: { type: "string", description: "Amount to withdraw (e.g. '100' or 'all')" },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawToken(params.token, params.amount);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          token: result.token,
+          amount: result.amount,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: wallet_withdraw_eth
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "wallet_withdraw_eth",
+    description:
+      "Withdraw ETH from AgentAccount to EOA wallet. " +
+      "Use amount 'all' to withdraw the full ETH balance.",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "string", description: "ETH amount to withdraw (e.g. '0.01' or 'all')" },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawEth(params.amount);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          token: "ETH",
+          amount: `${result.amount} ETH`,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: x402_pay (with auto-yield + auto-draw waterfall)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "x402_pay",
     description:
       "Make a paid API call using x402 protocol. Pays with USDC from AgentAccount via EIP-3009 signature. " +
-      "Set autoDraw=true to automatically borrow from Morpho Blue if USDC balance is insufficient (opt-in).",
+      "If USDC is insufficient, auto-sources funds: yield first (autoYield), then borrow (autoDraw). " +
+      "Both are configured in plugin settings.",
     parameters: {
       type: "object",
       properties: {
         url: { type: "string", description: "API endpoint URL" },
         method: { type: "string", enum: ["GET", "POST"], description: "HTTP method (default: GET)" },
         body: { type: "string", description: "JSON body for POST requests" },
-        autoDraw: { type: "boolean", description: "Auto-borrow from Morpho if USDC insufficient (default: false)" },
       },
       required: ["url"],
     },
-    async execute(_id: string, params: { url: string; method?: string; body?: string; autoDraw?: boolean }) {
+    async execute(_id: string, params: { url: string; method?: string; body?: string }) {
       try {
         const cfg = getConfig(api);
         const agetherCfg = api.config?.plugins?.entries?.agether?.config || {};
@@ -840,7 +954,8 @@ export default function register(api: any) {
           console.warn('[agether] x402_pay: getAccountAddress failed, paying from EOA:', e instanceof Error ? e.message : e);
         }
 
-        const autoDrawEnabled = params.autoDraw === true; // default false — opt-in only
+        const autoDrawEnabled = agetherCfg.autoDraw === true;
+        const autoYieldEnabled = agetherCfg.autoYield === true;
         const x402 = new X402Client({
           privateKey: cfg.privateKey,
           rpcUrl: cfg.rpcUrl,
@@ -848,16 +963,19 @@ export default function register(api: any) {
           agentId,
           accountAddress,
           autoDraw: autoDrawEnabled,
+          autoYield: autoYieldEnabled,
           dailySpendLimitUsdc: agetherCfg.dailySpendLimitUsdc,
-          yieldLimitedSpending: agetherCfg.yieldLimitedSpending,
-          autoDrawBuffer: agetherCfg.autoDrawBuffer,
+          // Restore spending state from cache so limit survives restarts
+          initialSpendingState: loadSpendCache(),
+          // Persist every spending update to cache file
+          onSpendingUpdate: (state: any) => saveSpendCache(state),
           // Safe7579 needs validator prefix for ERC-1271 isValidSignature routing
           validatorModule: "0xde896C58163b5f6cAC5B16C1b0109843f26106F6",
         });
 
         let result;
-        if (autoDrawEnabled && agentId) {
-          // Use payWithAutoDraw which handles balance check + borrow
+        if ((autoDrawEnabled || autoYieldEnabled) && agentId) {
+          // Use payWithAutoDraw which handles waterfall: balance → yield → borrow
           const fetchOpts: any = {
             morphoClient: client,
           };
@@ -885,98 +1003,22 @@ export default function register(api: any) {
           };
         }
         if (result.autoDrawInfo) {
-          response.autoDraw = {
-            ...result.autoDrawInfo,
-            borrowTx: result.autoDrawInfo.borrowTx ? txLink(result.autoDrawInfo.borrowTx) : undefined,
-          };
+          const info: any = { reason: result.autoDrawInfo.reason };
+          if (result.autoDrawInfo.yieldWithdrawn) {
+            info.yieldWithdrawn = `$${result.autoDrawInfo.yieldWithdrawn} USDC`;
+            if (result.autoDrawInfo.yieldTx) info.yieldTx = txLink(result.autoDrawInfo.yieldTx);
+          }
+          if (result.autoDrawInfo.borrowed) {
+            info.borrowed = `$${result.autoDrawInfo.borrowed} USDC`;
+            if (result.autoDrawInfo.borrowTx) info.borrowTx = txLink(result.autoDrawInfo.borrowTx);
+          }
+          response.autoFund = info;
         }
         return ok(JSON.stringify(response, null, 2));
       } catch (e) { return fail(e); }
     },
   });
 
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_rates
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_rates",
-    description:
-      "Show current Morpho Blue market rates — supply APY, borrow APY, utilization for USDC markets. " +
-      "Note: collateral does NOT earn yield on Morpho; supply APY is what lenders earn.",
-    parameters: {
-      type: "object",
-      properties: {
-        token: { type: "string", description: "Filter by collateral token (optional)" },
-      },
-      required: [],
-    },
-    async execute(_id: string, params: { token?: string }) {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const rates = await client.getMarketRates(params.token);
-
-        if (rates.length === 0) return ok("No markets found.");
-
-        const formatted = rates.map((r: any) => ({
-          collateral: r.collateralToken,
-          loan: r.loanToken,
-          supplyApy: `${(r.supplyApy * 100).toFixed(2)}%`,
-          borrowApy: `${(r.borrowApy * 100).toFixed(2)}%`,
-          utilization: `${(r.utilization * 100).toFixed(1)}%`,
-          totalSupply: `$${r.totalSupplyUsd.toFixed(0)}`,
-          totalBorrow: `$${r.totalBorrowUsd.toFixed(0)}`,
-          lltv: r.lltv,
-        }));
-
-        return ok(JSON.stringify(formatted, null, 2));
-      } catch (e) { return fail(e); }
-    },
-  });
-
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_yield_estimate
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_yield_estimate",
-    description:
-      "Estimate theoretical yield for collateral deposited in Morpho Blue. " +
-      "⚠️ Collateral does NOT actually earn yield on Morpho. This estimates " +
-      "what it WOULD earn if it were supplied as a lender instead. " +
-      "Useful for setting spending caps based on theoretical earnings.",
-    parameters: {
-      type: "object",
-      properties: {
-        token: { type: "string", description: "Collateral token" },
-        amount: { type: "string", description: "Collateral amount (e.g. '1.5')" },
-        periodDays: { type: "number", description: "Period in days (default: 1)" },
-        ethPriceUsd: { type: "number", description: "ETH price in USD (optional, uses oracle if not provided)" },
-      },
-      required: ["token", "amount"],
-    },
-    async execute(_id: string, params: { token: string; amount: string; periodDays?: number; ethPriceUsd?: number }) {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const result = await client.getYieldEstimate(
-          params.token,
-          params.amount,
-          params.periodDays || 1,
-          params.ethPriceUsd,
-        );
-
-        return ok(JSON.stringify({
-          collateral: `${result.amount} ${result.collateralToken}`,
-          collateralValueUsd: `$${result.collateralValueUsd.toFixed(2)}`,
-          theoreticalSupplyApy: `${(result.theoreticalSupplyApy * 100).toFixed(2)}%`,
-          estimatedYieldUsd: `$${result.estimatedYieldUsd.toFixed(4)}`,
-          period: `${result.periodDays} day(s)`,
-          disclaimer: result.disclaimer,
-        }, null, 2));
-      } catch (e) { return fail(e); }
-    },
-  });
-
   // ═══════════════════════════════════════════════════════
   //  TOOL: morpho_max_borrowable
   // ═══════════════════════════════════════════════════════
@@ -1177,13 +1219,32 @@ export default function register(api: any) {
         const client = createClient(cfg);
         const b = await client.getBalances();
 
+        const nz = (v: string) => parseFloat(v) > 0;
+
         let text = `💰 Agent #${b.agentId}\n`;
-        text += `Address: ${b.address}\n`;
-        text += `ETH: ${parseFloat(b.eth).toFixed(6)}\n`;
-        text += `USDC: $${b.usdc}`;
+        text += `Address: ${b.address}`;
+        if (nz(b.eth)) text += `\nETH: ${parseFloat(b.eth).toFixed(6)}`;
+        if (nz(b.usdc)) text += `\nUSDC: $${b.usdc}`;
+        for (const [sym, val] of Object.entries(b.collateral ?? {})) {
+          if (nz(val)) text += `\n${sym}: ${parseFloat(val).toFixed(6)}`;
+        }
+
         if (b.agentAccount) {
-          text += `\n\n🏦 AgentAccount: ${b.agentAccount.address}\nUSDC: $${b.agentAccount.usdc}`;
+          const a = b.agentAccount;
+          const hasAny = nz(a.eth) || nz(a.usdc) ||
+            Object.values(a.collateral ?? {}).some(nz);
+          if (hasAny) {
+            text += `\n\n🏦 AgentAccount: ${a.address}`;
+            if (nz(a.eth)) text += `\nETH: ${parseFloat(a.eth).toFixed(6)}`;
+            if (nz(a.usdc)) text += `\nUSDC: $${a.usdc}`;
+            for (const [sym, val] of Object.entries(a.collateral ?? {})) {
+              if (nz(val)) text += `\n${sym}: ${parseFloat(val).toFixed(6)}`;
+            }
+          } else {
+            text += `\n\n🏦 AgentAccount: ${a.address}\n(empty)`;
+          }
         }
+
         return { text };
       } catch (e: any) {
         return { text: `❌ ${e.message}` };
@@ -1193,17 +1254,28 @@ export default function register(api: any) {
 
   api.registerCommand({
     name: "morpho",
-    description: "Show Morpho positions (no AI)",
+    description: "Show Morpho positions with Health Factor (no AI)",
     handler: async () => {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const s = await client.getStatus();
+        const [s, maxBorrow] = await Promise.all([
+          client.getStatus(),
+          client.getMaxBorrowable(),
+        ]);
 
         let text = `📊 Morpho\nAccount: ${s.agentAccount}\nTotal debt: $${s.totalDebt}\n`;
         for (const p of s.positions) {
-          text += `\n${p.collateralToken}: ${p.collateral} collateral, $${p.debt} debt`;
+          const mm = maxBorrow.byMarket.find((m: any) => m.collateralToken === p.collateralToken);
+          const cv = mm ? Number(mm.collateralValue) / 1e6 : 0;
+          const debt = parseFloat(p.debt);
+          const ltv = cv > 0 ? debt / cv : 0;
+          const hf = ltv > 0 ? 0.80 / ltv : Infinity;
+          const hfStr = debt === 0 ? "∞" : hf.toFixed(2);
+          const icon = debt === 0 ? "🟢" : hf <= 1.0 ? "🔴" : hf <= 1.15 ? "🟡" : "🟢";
+          text += `\n${icon} ${p.collateralToken}: ${p.collateral} col, $${p.debt} debt, HF ${hfStr}`;
         }
+        if (s.positions.length === 0) text += "\nNo active positions.";
         return { text };
       } catch (e: any) {
         return { text: `❌ ${e.message}` };