@agether/sdk 1.4.1 → 1.5.1

package/dist/cli.js

@@ -30,6 +30,807 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/types/index.ts
+var AgetherError;
+var init_types = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    AgetherError = class extends Error {
+      constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "AgetherError";
+      }
+    };
+  }
+});
+
+// src/utils/abis.ts
+var IDENTITY_REGISTRY_ABI, ACCOUNT_FACTORY_ABI, AGENT_ACCOUNT_ABI, AGENT_REPUTATION_ABI, MORPHO_BLUE_ABI, ERC20_ABI;
+var init_abis = __esm({
+  "src/utils/abis.ts"() {
+    "use strict";
+    IDENTITY_REGISTRY_ABI = [
+      "function ownerOf(uint256 agentId) view returns (address)",
+      "function balanceOf(address owner) view returns (uint256)",
+      "function totalSupply() view returns (uint256)",
+      "function exists(uint256 agentId) view returns (bool)",
+      "function register() returns (uint256 agentId)",
+      "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
+    ];
+    ACCOUNT_FACTORY_ABI = [
+      "function getAccount(uint256 agentId) view returns (address)",
+      "function accountExists(uint256 agentId) view returns (bool)",
+      "function predictAddress(uint256 agentId) view returns (address)",
+      "function totalAccounts() view returns (uint256)",
+      "function getAgentId(address account) view returns (uint256)",
+      "function createAccount(uint256 agentId) returns (address account)",
+      "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
+    ];
+    AGENT_ACCOUNT_ABI = [
+      "function agentId() view returns (uint256)",
+      "function owner() view returns (address)",
+      "function factory() view returns (address)",
+      "function validationRegistry() view returns (address)",
+      "function identityRegistry() view returns (address)",
+      "function balanceOf(address token) view returns (uint256)",
+      "function ethBalance() view returns (uint256)",
+      "function execute(address target, uint256 value, bytes data) payable returns (bytes)",
+      "function executeBatch(address[] targets, uint256[] values, bytes[] datas) payable returns (bytes[])",
+      "function fund(address token, uint256 amount)",
+      "function withdraw(address token, uint256 amount, address to)",
+      "function withdrawETH(uint256 amount, address to)",
+      "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
+    ];
+    AGENT_REPUTATION_ABI = [
+      "function getCreditScore(uint256 agentId) view returns (uint256)",
+      "function getAttestation(uint256 agentId) view returns (tuple(uint256 score, uint256 timestamp, address signer))",
+      "function isScoreFresh(uint256 agentId) view returns (bool fresh, uint256 age)",
+      "function isEligible(uint256 agentId, uint256 minScore) view returns (bool eligible, uint256 currentScore)",
+      "function oracleSigner() view returns (address)",
+      "function submitScore(uint256 agentId, uint256 score_, uint256 timestamp_, bytes signature)",
+      "function setOracleSigner(address signer_)",
+      "event ScoreUpdated(uint256 indexed agentId, uint256 score, uint256 timestamp, address signer)"
+    ];
+    MORPHO_BLUE_ABI = [
+      // Supply & Withdraw (lending side)
+      "function supply(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsSupplied, uint256 sharesSupplied)",
+      "function withdraw(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn)",
+      // Collateral
+      "function supplyCollateral(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, bytes data)",
+      "function withdrawCollateral(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, address onBehalf, address receiver)",
+      // Borrow & Repay
+      "function borrow(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsBorrowed, uint256 sharesBorrowed)",
+      "function repay(tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv) marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsRepaid, uint256 sharesRepaid)",
+      // Authorization
+      "function setAuthorization(address authorized, bool newIsAuthorized)",
+      "function isAuthorized(address authorizer, address authorized) view returns (bool)",
+      // Views
+      "function position(bytes32 id, address user) view returns (uint256 supplyShares, uint128 borrowShares, uint128 collateral)",
+      "function market(bytes32 id) view returns (uint128 totalSupplyAssets, uint128 totalSupplyShares, uint128 totalBorrowAssets, uint128 totalBorrowShares, uint128 lastUpdate, uint128 fee)",
+      "function idToMarketParams(bytes32 id) view returns (tuple(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv))"
+    ];
+    ERC20_ABI = [
+      "function balanceOf(address account) view returns (uint256)",
+      "function allowance(address owner, address spender) view returns (uint256)",
+      "function approve(address spender, uint256 amount) returns (bool)",
+      "function transfer(address to, uint256 amount) returns (bool)",
+      "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+      "function decimals() view returns (uint8)",
+      "function symbol() view returns (string)",
+      "function name() view returns (string)"
+    ];
+  }
+});
+
+// src/utils/config.ts
+function getDefaultConfig(chainId) {
+  return {
+    chainId,
+    rpcUrl: RPC_URLS[chainId],
+    contracts: CONTRACT_ADDRESSES[chainId],
+    scoringEndpoint: SCORING_ENDPOINTS[chainId]
+  };
+}
+var CONTRACT_ADDRESSES, RPC_URLS, SCORING_ENDPOINTS;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    init_types();
+    CONTRACT_ADDRESSES = {
+      [1 /* Ethereum */]: {
+        accountFactory: "0x0000000000000000000000000000000000000000",
+        validationRegistry: "0x0000000000000000000000000000000000000000",
+        agentReputation: "0x0000000000000000000000000000000000000000",
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+        morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
+      },
+      [8453 /* Base */]: {
+        accountFactory: "0x7D5D56416bAEA06a9DCBe3092eF335724C6320a0",
+        validationRegistry: "0xd196C32D2149270F56E209ba7aEE67CE9ceD2001",
+        agentReputation: "0x65c9cA1211809D3CF3A2707558198eb2b2bE623c",
+        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+        morphoBlue: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb"
+      },
+      [84532 /* BaseSepolia */]: {
+        accountFactory: "0x0000000000000000000000000000000000000000",
+        validationRegistry: "0x0000000000000000000000000000000000000000",
+        agentReputation: "0x0000000000000000000000000000000000000000",
+        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+        morphoBlue: "0x0000000000000000000000000000000000000000"
+      },
+      [11155111 /* Sepolia */]: {
+        accountFactory: "0x0000000000000000000000000000000000000000",
+        validationRegistry: "0x0000000000000000000000000000000000000000",
+        agentReputation: "0x0000000000000000000000000000000000000000",
+        usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+        identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+        morphoBlue: "0x0000000000000000000000000000000000000000"
+      },
+      [31337 /* Hardhat */]: {
+        accountFactory: "0x0000000000000000000000000000000000000000",
+        validationRegistry: "0x0000000000000000000000000000000000000000",
+        agentReputation: "0x0000000000000000000000000000000000000000",
+        usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
+        identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+        morphoBlue: "0x0000000000000000000000000000000000000000"
+      }
+    };
+    RPC_URLS = {
+      [1 /* Ethereum */]: "https://ethereum-rpc.publicnode.com",
+      [8453 /* Base */]: "https://base-rpc.publicnode.com",
+      [84532 /* BaseSepolia */]: "https://sepolia.base.org",
+      [11155111 /* Sepolia */]: "https://rpc.sepolia.org",
+      [31337 /* Hardhat */]: "http://127.0.0.1:8545"
+    };
+    SCORING_ENDPOINTS = {
+      [1 /* Ethereum */]: "https://scoring.agether.ai/v1",
+      [8453 /* Base */]: "http://95.179.189.214:3001",
+      [84532 /* BaseSepolia */]: "http://95.179.189.214:3001",
+      [11155111 /* Sepolia */]: "https://scoring-testnet.agether.ai/v1",
+      [31337 /* Hardhat */]: "http://127.0.0.1:3001"
+    };
+  }
+});
+
+// src/clients/MorphoClient.ts
+var MorphoClient_exports = {};
+__export(MorphoClient_exports, {
+  MorphoClient: () => MorphoClient
+});
+var import_ethers, import_axios, BASE_COLLATERALS, MORPHO_API_URL, morphoIface, erc20Iface, MorphoClient;
+var init_MorphoClient = __esm({
+  "src/clients/MorphoClient.ts"() {
+    "use strict";
+    import_ethers = require("ethers");
+    import_axios = __toESM(require("axios"));
+    init_types();
+    init_abis();
+    init_config();
+    BASE_COLLATERALS = {
+      WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
+      wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
+      cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
+    };
+    MORPHO_API_URL = "https://api.morpho.org/graphql";
+    morphoIface = new import_ethers.ethers.Interface(MORPHO_BLUE_ABI);
+    erc20Iface = new import_ethers.ethers.Interface(ERC20_ABI);
+    MorphoClient = class {
+      constructor(config) {
+        this._marketCache = /* @__PURE__ */ new Map();
+        this._discoveredAt = 0;
+        const chainId = config.chainId ?? 8453 /* Base */;
+        const defaultCfg = getDefaultConfig(chainId);
+        this.config = defaultCfg;
+        this.agentId = config.agentId;
+        this.provider = new import_ethers.ethers.JsonRpcProvider(config.rpcUrl || defaultCfg.rpcUrl);
+        this.wallet = new import_ethers.ethers.Wallet(config.privateKey, this.provider);
+        const addrs = { ...defaultCfg.contracts, ...config.contracts };
+        this.accountFactory = new import_ethers.Contract(addrs.accountFactory, ACCOUNT_FACTORY_ABI, this.wallet);
+        this.morphoBlue = new import_ethers.Contract(addrs.morphoBlue, MORPHO_BLUE_ABI, this.provider);
+        this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this.provider);
+        this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this.provider);
+      }
+      // ════════════════════════════════════════════════════════
+      //  Account Management
+      // ════════════════════════════════════════════════════════
+      /** Resolve the AgentAccount address (cached). */
+      async getAccountAddress() {
+        if (this._accountAddress) return this._accountAddress;
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        const addr = await this.accountFactory.getAccount(BigInt(this.agentId));
+        if (addr === import_ethers.ethers.ZeroAddress) {
+          throw new AgetherError("No AgentAccount found. Call register() first.", "NO_ACCOUNT");
+        }
+        this._accountAddress = addr;
+        return addr;
+      }
+      getAgentId() {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        return this.agentId;
+      }
+      getWalletAddress() {
+        return this.wallet.address;
+      }
+      /**
+       * Register: create ERC-8004 identity + AgentAccount in one flow.
+       * If already registered, returns existing state.
+       */
+      async register(_name) {
+        const eoaAddr = this.wallet.address;
+        if (this.agentId) {
+          const exists = await this.accountFactory.accountExists(BigInt(this.agentId));
+          if (exists) {
+            const acct = await this.accountFactory.getAccount(BigInt(this.agentId));
+            this._accountAddress = acct;
+            return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true };
+          }
+        }
+        const balance = await this.identityRegistry.balanceOf(eoaAddr);
+        let agentId;
+        if (balance > 0n && this.agentId) {
+          agentId = BigInt(this.agentId);
+        } else if (balance > 0n) {
+          throw new AgetherError(
+            "Wallet already has an ERC-8004 identity but agentId is unknown. Pass agentId in config.",
+            "AGENT_ID_UNKNOWN"
+          );
+        } else {
+          const regTx = await this.identityRegistry.register();
+          const regReceipt = await regTx.wait();
+          agentId = 0n;
+          for (const log of regReceipt.logs) {
+            try {
+              const parsed = this.identityRegistry.interface.parseLog({ topics: log.topics, data: log.data });
+              if (parsed?.name === "Transfer") {
+                agentId = parsed.args[2];
+                break;
+              }
+            } catch {
+              continue;
+            }
+          }
+          if (agentId === 0n) throw new AgetherError("Failed to parse agentId from registration", "PARSE_ERROR");
+        }
+        this.agentId = agentId.toString();
+        const acctExists = await this.accountFactory.accountExists(agentId);
+        let txHash;
+        if (!acctExists) {
+          const tx = await this.accountFactory.createAccount(agentId);
+          const receipt = await tx.wait();
+          txHash = receipt.hash;
+        }
+        const acctAddr = await this.accountFactory.getAccount(agentId);
+        this._accountAddress = acctAddr;
+        return {
+          agentId: this.agentId,
+          address: eoaAddr,
+          agentAccount: acctAddr,
+          alreadyRegistered: acctExists,
+          tx: txHash
+        };
+      }
+      /** Get ETH / USDC balances for EOA and AgentAccount. */
+      async getBalances() {
+        const eoaAddr = this.wallet.address;
+        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
+        const ethBal = await this.provider.getBalance(eoaAddr);
+        const usdcBal = await usdc.balanceOf(eoaAddr);
+        const result = {
+          agentId: this.agentId || "?",
+          address: eoaAddr,
+          eth: import_ethers.ethers.formatEther(ethBal),
+          usdc: import_ethers.ethers.formatUnits(usdcBal, 6)
+        };
+        try {
+          const acctAddr = await this.getAccountAddress();
+          const acctEth = await this.provider.getBalance(acctAddr);
+          const acctUsdc = await usdc.balanceOf(acctAddr);
+          result.agentAccount = {
+            address: acctAddr,
+            eth: import_ethers.ethers.formatEther(acctEth),
+            usdc: import_ethers.ethers.formatUnits(acctUsdc, 6)
+          };
+        } catch {
+        }
+        return result;
+      }
+      /** Transfer USDC from EOA to AgentAccount. */
+      async fundAccount(usdcAmount) {
+        const acctAddr = await this.getAccountAddress();
+        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.wallet);
+        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
+        const tx = await usdc.transfer(acctAddr, amount);
+        const receipt = await tx.wait();
+        return { tx: receipt.hash, amount: usdcAmount, agentAccount: acctAddr };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Market Discovery (Morpho GraphQL API)
+      // ════════════════════════════════════════════════════════
+      /**
+       * Fetch USDC borrow markets on Base from Morpho API.
+       * Caches results for 5 minutes.
+       */
+      async getMarkets(forceRefresh = false) {
+        if (!forceRefresh && this._discoveredMarkets && Date.now() - this._discoveredAt < 3e5) {
+          return this._discoveredMarkets;
+        }
+        const chainId = this.config.chainId;
+        const usdcAddr = this.config.contracts.usdc.toLowerCase();
+        const query = `{
+      markets(
+        first: 50
+        orderBy: SupplyAssetsUsd
+        orderDirection: Desc
+        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"] }
+      ) {
+        items {
+          uniqueKey
+          lltv
+          oracleAddress
+          irmAddress
+          loanAsset { address symbol decimals }
+          collateralAsset { address symbol decimals }
+          state {
+            borrowAssets
+            supplyAssets
+            utilization
+          }
+        }
+      }
+    }`;
+        try {
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+          const items = resp.data?.data?.markets?.items ?? [];
+          this._discoveredMarkets = items.map((m) => ({
+            uniqueKey: m.uniqueKey,
+            loanAsset: m.loanAsset,
+            collateralAsset: m.collateralAsset ?? { address: import_ethers.ethers.ZeroAddress, symbol: "N/A", decimals: 0 },
+            oracle: m.oracleAddress,
+            irm: m.irmAddress,
+            lltv: BigInt(m.lltv),
+            totalSupplyAssets: BigInt(m.state?.supplyAssets ?? "0"),
+            totalBorrowAssets: BigInt(m.state?.borrowAssets ?? "0"),
+            utilization: m.state?.utilization ? Number(m.state.utilization) : 0
+          }));
+          this._discoveredAt = Date.now();
+          for (const mi of this._discoveredMarkets) {
+            if (mi.collateralAsset.address !== import_ethers.ethers.ZeroAddress) {
+              this._marketCache.set(mi.collateralAsset.address.toLowerCase(), {
+                loanToken: mi.loanAsset.address,
+                collateralToken: mi.collateralAsset.address,
+                oracle: mi.oracle,
+                irm: mi.irm,
+                lltv: mi.lltv
+              });
+            }
+          }
+          return this._discoveredMarkets;
+        } catch {
+          return this._discoveredMarkets ?? [];
+        }
+      }
+      /**
+       * Get MarketParams for a collateral token.
+       * Tries cache → API → on-chain idToMarketParams.
+       */
+      async findMarketForCollateral(collateralSymbolOrAddress) {
+        const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
+        const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+        const cached = this._marketCache.get(colAddr);
+        if (cached) return cached;
+        await this.getMarkets();
+        const fromApi = this._marketCache.get(colAddr);
+        if (fromApi) return fromApi;
+        throw new AgetherError(
+          `No Morpho market found for collateral ${collateralSymbolOrAddress}`,
+          "MARKET_NOT_FOUND"
+        );
+      }
+      /** Read MarketParams on-chain by market ID (bytes32). */
+      async getMarketParams(marketId) {
+        const result = await this.morphoBlue.idToMarketParams(marketId);
+        return {
+          loanToken: result.loanToken,
+          collateralToken: result.collateralToken,
+          oracle: result.oracle,
+          irm: result.irm,
+          lltv: result.lltv
+        };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Position Reads
+      // ════════════════════════════════════════════════════════
+      /** Read on-chain position for a specific market. */
+      async getPosition(marketId) {
+        const acctAddr = await this.getAccountAddress();
+        const pos = await this.morphoBlue.position(marketId, acctAddr);
+        return {
+          supplyShares: pos.supplyShares,
+          borrowShares: pos.borrowShares,
+          collateral: pos.collateral
+        };
+      }
+      /**
+       * Full status: positions across all discovered markets.
+       */
+      async getStatus() {
+        const acctAddr = await this.getAccountAddress();
+        const markets = await this.getMarkets();
+        const positions = [];
+        let totalDebt = 0n;
+        for (const m of markets) {
+          if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
+          try {
+            const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
+            if (pos.collateral === 0n && pos.borrowShares === 0n && pos.supplyShares === 0n) continue;
+            let debt = 0n;
+            if (pos.borrowShares > 0n) {
+              try {
+                const mkt = await this.morphoBlue.market(m.uniqueKey);
+                const totalBorrowShares = BigInt(mkt.totalBorrowShares);
+                const totalBorrowAssets = BigInt(mkt.totalBorrowAssets);
+                debt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
+                totalDebt += debt;
+              } catch {
+              }
+            }
+            positions.push({
+              marketId: m.uniqueKey,
+              collateralToken: m.collateralAsset.symbol,
+              collateral: import_ethers.ethers.formatUnits(pos.collateral, m.collateralAsset.decimals),
+              borrowShares: pos.borrowShares.toString(),
+              supplyShares: pos.supplyShares.toString(),
+              debt: import_ethers.ethers.formatUnits(debt, 6)
+            });
+          } catch {
+            continue;
+          }
+        }
+        return {
+          agentId: this.agentId || "?",
+          agentAccount: acctAddr,
+          totalDebt: import_ethers.ethers.formatUnits(totalDebt, 6),
+          positions
+        };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Lending Operations (all via AgentAccount.executeBatch)
+      // ════════════════════════════════════════════════════════
+      /**
+       * Deposit collateral into Morpho Blue.
+       *
+       * Flow:
+       * 1. EOA transfers collateral to AgentAccount
+       * 2. AgentAccount.executeBatch:
+       *    [collateral.approve(MorphoBlue), Morpho.supplyCollateral(params)]
+       */
+      async supplyCollateral(tokenSymbol, amount, marketParams) {
+        const acctAddr = await this.getAccountAddress();
+        const colInfo = BASE_COLLATERALS[tokenSymbol];
+        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
+        const weiAmount = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
+        const morphoAddr = this.config.contracts.morphoBlue;
+        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this.wallet);
+        const transferTx = await colToken.transfer(acctAddr, weiAmount);
+        await transferTx.wait();
+        const targets = [colInfo.address, morphoAddr];
+        const values = [0n, 0n];
+        const datas = [
+          erc20Iface.encodeFunctionData("approve", [morphoAddr, weiAmount]),
+          morphoIface.encodeFunctionData("supplyCollateral", [
+            this._toTuple(params),
+            weiAmount,
+            acctAddr,
+            "0x"
+          ])
+        ];
+        const receipt = await this.batch(targets, values, datas);
+        return {
+          tx: receipt.hash,
+          collateralToken: tokenSymbol,
+          amount,
+          agentAccount: acctAddr
+        };
+      }
+      /**
+       * Borrow USDC against existing collateral.
+       *
+       * AgentAccount.execute: Morpho.borrow(params, amount, 0, account, account)
+       *
+       * @param usdcAmount - USDC amount (e.g. '100')
+       * @param tokenSymbol - collateral symbol to identify which market (default: first with collateral)
+       */
+      async borrow(usdcAmount, tokenSymbol, marketParams) {
+        const acctAddr = await this.getAccountAddress();
+        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
+        const morphoAddr = this.config.contracts.morphoBlue;
+        let params;
+        let usedToken = tokenSymbol || "WETH";
+        if (marketParams) {
+          params = marketParams;
+        } else if (tokenSymbol) {
+          params = await this.findMarketForCollateral(tokenSymbol);
+        } else {
+          const { params: p, symbol } = await this._findActiveMarket();
+          params = p;
+          usedToken = symbol;
+        }
+        const data = morphoIface.encodeFunctionData("borrow", [
+          this._toTuple(params),
+          amount,
+          0n,
+          acctAddr,
+          acctAddr
+        ]);
+        const receipt = await this.exec(morphoAddr, data);
+        return {
+          tx: receipt.hash,
+          amount: usdcAmount,
+          collateralToken: usedToken,
+          agentAccount: acctAddr
+        };
+      }
+      /**
+       * Deposit collateral AND borrow USDC in one batched transaction.
+       *
+       * AgentAccount.executeBatch:
+       *   [collateral.approve, Morpho.supplyCollateral, Morpho.borrow]
+       *
+       * The collateral must be transferred to AgentAccount first.
+       */
+      async depositAndBorrow(tokenSymbol, collateralAmount, borrowUsdcAmount, marketParams) {
+        const acctAddr = await this.getAccountAddress();
+        const colInfo = BASE_COLLATERALS[tokenSymbol];
+        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
+        const colWei = import_ethers.ethers.parseUnits(collateralAmount, colInfo.decimals);
+        const borrowWei = import_ethers.ethers.parseUnits(borrowUsdcAmount, 6);
+        const morphoAddr = this.config.contracts.morphoBlue;
+        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this.wallet);
+        const transferTx = await colToken.transfer(acctAddr, colWei);
+        await transferTx.wait();
+        const targets = [colInfo.address, morphoAddr, morphoAddr];
+        const values = [0n, 0n, 0n];
+        const datas = [
+          erc20Iface.encodeFunctionData("approve", [morphoAddr, colWei]),
+          morphoIface.encodeFunctionData("supplyCollateral", [
+            this._toTuple(params),
+            colWei,
+            acctAddr,
+            "0x"
+          ]),
+          morphoIface.encodeFunctionData("borrow", [
+            this._toTuple(params),
+            borrowWei,
+            0n,
+            acctAddr,
+            acctAddr
+          ])
+        ];
+        const receipt = await this.batch(targets, values, datas);
+        return {
+          tx: receipt.hash,
+          collateralToken: tokenSymbol,
+          collateralAmount,
+          borrowAmount: borrowUsdcAmount,
+          agentAccount: acctAddr
+        };
+      }
+      /**
+       * Repay borrowed USDC from AgentAccount.
+       *
+       * AgentAccount.executeBatch:
+       *   [USDC.approve(MorphoBlue), Morpho.repay(params)]
+       */
+      async repay(usdcAmount, tokenSymbol, marketParams) {
+        const acctAddr = await this.getAccountAddress();
+        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
+        const morphoAddr = this.config.contracts.morphoBlue;
+        const usdcAddr = this.config.contracts.usdc;
+        let params;
+        if (marketParams) {
+          params = marketParams;
+        } else if (tokenSymbol) {
+          params = await this.findMarketForCollateral(tokenSymbol);
+        } else {
+          const { params: p } = await this._findActiveMarket();
+          params = p;
+        }
+        const targets = [usdcAddr, morphoAddr];
+        const values = [0n, 0n];
+        const datas = [
+          erc20Iface.encodeFunctionData("approve", [morphoAddr, amount]),
+          morphoIface.encodeFunctionData("repay", [
+            this._toTuple(params),
+            amount,
+            0n,
+            acctAddr,
+            "0x"
+          ])
+        ];
+        const receipt = await this.batch(targets, values, datas);
+        let remainingDebt = "0";
+        try {
+          const status = await this.getStatus();
+          remainingDebt = status.totalDebt;
+        } catch {
+        }
+        return { tx: receipt.hash, amount: usdcAmount, remainingDebt };
+      }
+      /**
+       * Withdraw collateral from Morpho Blue.
+       *
+       * AgentAccount.execute: Morpho.withdrawCollateral(params, amount, account, receiver)
+       *
+       * @param receiver - defaults to EOA wallet
+       */
+      async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
+        const acctAddr = await this.getAccountAddress();
+        const colInfo = BASE_COLLATERALS[tokenSymbol];
+        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+        const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
+        const morphoAddr = this.config.contracts.morphoBlue;
+        const dest = receiver || this.wallet.address;
+        let weiAmount;
+        if (amount === "all") {
+          const markets = await this.getMarkets();
+          const market = markets.find(
+            (m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase()
+          );
+          if (!market) throw new AgetherError("Market not found", "MARKET_NOT_FOUND");
+          const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+          weiAmount = pos.collateral;
+          if (weiAmount === 0n) throw new AgetherError("No collateral to withdraw", "NO_COLLATERAL");
+        } else {
+          weiAmount = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
+        }
+        const data = morphoIface.encodeFunctionData("withdrawCollateral", [
+          this._toTuple(params),
+          weiAmount,
+          acctAddr,
+          dest
+        ]);
+        const receipt = await this.exec(morphoAddr, data);
+        let remainingCollateral = "0";
+        try {
+          const markets = await this.getMarkets();
+          const market = markets.find(
+            (m) => m.collateralAsset.address.toLowerCase() === colInfo.address.toLowerCase()
+          );
+          if (market) {
+            const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+            remainingCollateral = import_ethers.ethers.formatUnits(pos.collateral, colInfo.decimals);
+          }
+        } catch {
+        }
+        return {
+          tx: receipt.hash,
+          token: tokenSymbol,
+          amount: amount === "all" ? import_ethers.ethers.formatUnits(weiAmount, colInfo.decimals) : amount,
+          remainingCollateral,
+          destination: dest
+        };
+      }
+      /**
+       * Sponsor: transfer collateral to another agent's AgentAccount.
+       * (The agent must then supplyCollateral themselves via their own account.)
+       */
+      async sponsor(target, tokenSymbol, amount) {
+        const colInfo = BASE_COLLATERALS[tokenSymbol];
+        if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+        let targetAddr;
+        if (target.address) {
+          targetAddr = target.address;
+        } else if (target.agentId) {
+          targetAddr = await this.accountFactory.getAccount(BigInt(target.agentId));
+          if (targetAddr === import_ethers.ethers.ZeroAddress) throw new AgetherError("Target agent has no account", "NO_ACCOUNT");
+        } else {
+          throw new AgetherError("Provide agentId or address", "INVALID_TARGET");
+        }
+        const weiAmount = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
+        const colToken = new import_ethers.Contract(colInfo.address, ERC20_ABI, this.wallet);
+        const tx = await colToken.transfer(targetAddr, weiAmount);
+        const receipt = await tx.wait();
+        return { tx: receipt.hash, targetAccount: targetAddr, targetAgentId: target.agentId };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Reputation (AgentReputation contract)
+      // ════════════════════════════════════════════════════════
+      async getCreditScore() {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        return this.agentReputation.getCreditScore(BigInt(this.agentId));
+      }
+      async getAttestation() {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        const att = await this.agentReputation.getAttestation(BigInt(this.agentId));
+        return { score: att.score, timestamp: att.timestamp, signer: att.signer };
+      }
+      async isEligible(minScore = 500n) {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        const [eligible, currentScore] = await this.agentReputation.isEligible(BigInt(this.agentId), minScore);
+        return { eligible, currentScore };
+      }
+      async isScoreFresh() {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        const [fresh, age] = await this.agentReputation.isScoreFresh(BigInt(this.agentId));
+        return { fresh, age };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Internal Helpers
+      // ════════════════════════════════════════════════════════
+      /**
+       * Execute a single call via AgentAccount.execute.
+       */
+      async exec(target, data, value = 0n) {
+        const acctAddr = await this.getAccountAddress();
+        const account = new import_ethers.Contract(acctAddr, AGENT_ACCOUNT_ABI, this.wallet);
+        let gasLimit;
+        try {
+          const estimate = await account.execute.estimateGas(target, value, data);
+          gasLimit = estimate * 130n / 100n;
+        } catch {
+          gasLimit = 500000n;
+        }
+        const tx = await account.execute(target, value, data, { gasLimit });
+        return tx.wait();
+      }
+      /**
+       * Execute multiple calls via AgentAccount.executeBatch.
+       */
+      async batch(targets, values, datas) {
+        const acctAddr = await this.getAccountAddress();
+        const account = new import_ethers.Contract(acctAddr, AGENT_ACCOUNT_ABI, this.wallet);
+        let gasLimit;
+        try {
+          const estimate = await account.executeBatch.estimateGas(targets, values, datas);
+          gasLimit = estimate * 130n / 100n;
+        } catch {
+          gasLimit = 800000n;
+        }
+        const tx = await account.executeBatch(targets, values, datas, { gasLimit });
+        return tx.wait();
+      }
+      /** Convert MorphoMarketParams to Solidity tuple. */
+      _toTuple(p) {
+        return [p.loanToken, p.collateralToken, p.oracle, p.irm, p.lltv];
+      }
+      /** Find the first market where the agent has collateral deposited. */
+      async _findActiveMarket() {
+        const acctAddr = await this.getAccountAddress();
+        const markets = await this.getMarkets();
+        for (const m of markets) {
+          if (!m.collateralAsset || m.collateralAsset.address === import_ethers.ethers.ZeroAddress) continue;
+          try {
+            const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
+            if (pos.collateral > 0n) {
+              return {
+                params: {
+                  loanToken: m.loanAsset.address,
+                  collateralToken: m.collateralAsset.address,
+                  oracle: m.oracle,
+                  irm: m.irm,
+                  lltv: m.lltv
+                },
+                symbol: m.collateralAsset.symbol
+              };
+            }
+          } catch {
+            continue;
+          }
+        }
+        const params = await this.findMarketForCollateral("WETH");
+        return { params, symbol: "WETH" };
+      }
+    };
+  }
+});
+
 // src/clients/X402Client.ts
 var X402Client_exports = {};
 __export(X402Client_exports, {
@@ -39,11 +840,11 @@ function chainIdFromNetwork(network) {
   const m = network.match(/^eip155:(\d+)$/);
   return m ? Number(m[1]) : 1;
 }
-var import_ethers, USDC_DOMAINS, X402Client;
+var import_ethers2, USDC_DOMAINS, X402Client;
 var init_X402Client = __esm({
   "src/clients/X402Client.ts"() {
     "use strict";
-    import_ethers = require("ethers");
+    import_ethers2 = require("ethers");
     USDC_DOMAINS = {
       "eip155:1": { name: "USD Coin", version: "2", address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" },
       "eip155:8453": { name: "USD Coin", version: "2", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
@@ -51,11 +852,11 @@ var init_X402Client = __esm({
       "eip155:42161": { name: "USD Coin", version: "2", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" },
       "eip155:10": { name: "USD Coin", version: "2", address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }
     };
-    X402Client = class _X402Client {
+    X402Client = class {
       constructor(config) {
         this.config = config;
-        const provider = new import_ethers.ethers.JsonRpcProvider(config.rpcUrl);
-        this.wallet = new import_ethers.ethers.Wallet(config.privateKey, provider);
+        const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
+        this.wallet = new import_ethers2.ethers.Wallet(config.privateKey, provider);
       }
       async get(url, opts) {
         return this.request(url, { ...opts, method: "GET" });
@@ -100,9 +901,6 @@ var init_X402Client = __esm({
           console.log(`         amount  : ${requirements.amount} (atomic)`);
           console.log(`         asset   : ${requirements.asset}`);
           console.log(`         payTo   : ${requirements.payTo}`);
-          if (this.config.autoDraw && this.config.accountAddress && this.config.morphoCreditAddress) {
-            await this.ensureBalance(BigInt(requirements.amount));
-          }
           console.log("   [3/4] Signing EIP-3009 transferWithAuthorization\u2026");
           const paymentPayload = await this.buildPaymentPayload(requirements, resource, url);
           const paymentB64 = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
@@ -198,7 +996,7 @@ var init_X402Client = __esm({
         const now = Math.floor(Date.now() / 1e3);
         const validAfter = String(now - 60);
         const validBefore = String(now + (reqs.maxTimeoutSeconds || 300));
-        const nonce = import_ethers.ethers.hexlify(import_ethers.ethers.randomBytes(32));
+        const nonce = import_ethers2.ethers.hexlify(import_ethers2.ethers.randomBytes(32));
         const chainId = chainIdFromNetwork(reqs.network);
         const usdcDomain = USDC_DOMAINS[reqs.network] || USDC_DOMAINS["eip155:1"];
         const payerAddress = this.config.accountAddress || this.wallet.address;
@@ -263,73 +1061,6 @@ var init_X402Client = __esm({
           }
         };
       }
-      static {
-        // ──────────── Auto-draw (Flow 9) ────────────
-        //
-        // When autoDraw is enabled and the AgentAccount has insufficient USDC,
-        // automatically borrow from Morpho credit line to cover the payment.
-        this.MORPHO_DRAW_ABI = [
-          "function drawWithCollateral(address collateralToken, uint256 amount)",
-          "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))"
-        ];
-      }
-      static {
-        this.AGENT_ACCOUNT_EXEC_ABI = [
-          "function execute(address target, uint256 value, bytes data) payable returns (bytes)"
-        ];
-      }
-      static {
-        this.ERC20_BALANCE_ABI = [
-          "function balanceOf(address) view returns (uint256)"
-        ];
-      }
-      static {
-        this.AUTO_DRAW_COLLATERALS = [
-          "0x4200000000000000000000000000000000000006",
-          // WETH
-          "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
-          // wstETH
-          "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
-          // cbETH
-        ];
-      }
-      async ensureBalance(requiredAmount) {
-        const accountAddr = this.config.accountAddress;
-        const morphoAddr = this.config.morphoCreditAddress;
-        const provider = this.wallet.provider;
-        const usdcAddr = USDC_DOMAINS["eip155:8453"]?.address || USDC_DOMAINS["eip155:1"].address;
-        const usdc = new import_ethers.ethers.Contract(usdcAddr, _X402Client.ERC20_BALANCE_ABI, provider);
-        const balance = await usdc.balanceOf(accountAddr);
-        const needed = requiredAmount + requiredAmount / 10n;
-        if (balance >= needed) return;
-        const deficit = needed - balance;
-        const minDraw = import_ethers.ethers.parseUnits("10", 6);
-        const drawAmount = deficit > minDraw ? deficit : minDraw;
-        console.log(`   [auto-draw] USDC balance $${import_ethers.ethers.formatUnits(balance, 6)} < needed $${import_ethers.ethers.formatUnits(needed, 6)}`);
-        const morpho = new import_ethers.ethers.Contract(morphoAddr, _X402Client.MORPHO_DRAW_ABI, provider);
-        let collateralAddr = null;
-        for (const addr of _X402Client.AUTO_DRAW_COLLATERALS) {
-          try {
-            const pos = await morpho.getPosition(accountAddr, addr);
-            if (pos.collateralAmount > 0n) {
-              collateralAddr = addr;
-              break;
-            }
-          } catch {
-            continue;
-          }
-        }
-        if (!collateralAddr) {
-          throw new Error("autoDraw failed: no collateral deposited in Morpho. Deposit collateral first.");
-        }
-        const account = new import_ethers.ethers.Contract(accountAddr, _X402Client.AGENT_ACCOUNT_EXEC_ABI, this.wallet);
-        const morphoIface = new import_ethers.ethers.Interface(_X402Client.MORPHO_DRAW_ABI);
-        const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, drawAmount]);
-        console.log(`   [auto-draw] Borrowing $${import_ethers.ethers.formatUnits(drawAmount, 6)} from Morpho...`);
-        const tx = await account.execute(morphoAddr, 0, calldata);
-        await tx.wait();
-        console.log(`   [auto-draw] \u2713 Borrowed (tx: ${tx.hash.slice(0, 14)}\u2026)`);
-      }
       // ──────────── Risk check via our backend ────────────
       async riskCheck(paymentPayload, reqs) {
         try {
@@ -365,7 +1096,7 @@ var init_X402Client = __esm({
 });
 
 // src/cli.ts
-var import_ethers2 = require("ethers");
+var import_ethers3 = require("ethers");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
@@ -383,11 +1114,17 @@ function loadConfig() {
 }
 function saveConfig(config) {
   const dir = path.dirname(CONFIG_PATH);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
 }
+function requireConfig() {
+  const config = loadConfig();
+  if (!config) {
+    console.error("\u274C Not initialized. Run: agether init <private-key>");
+    process.exit(1);
+  }
+  return config;
+}
 async function waitForTx(tx, retries = 5) {
   for (let attempt = 1; attempt <= retries; attempt++) {
     try {
@@ -401,176 +1138,119 @@ async function waitForTx(tx, retries = 5) {
   }
   throw new Error("Failed to get transaction receipt after retries");
 }
-function requireConfig() {
-  const config = loadConfig();
-  if (!config) {
-    console.error("\u274C Not initialized. Run: agether init <private-key>");
-    process.exit(1);
-  }
-  return config;
-}
-function getSigner(config) {
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  return new import_ethers2.ethers.Wallet(config.privateKey, provider);
-}
-function getFreshSigner(config) {
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  return new import_ethers2.ethers.Wallet(config.privateKey, provider);
+async function getMorphoClient(config) {
+  const { MorphoClient: MorphoClient2 } = await Promise.resolve().then(() => (init_MorphoClient(), MorphoClient_exports));
+  return new MorphoClient2({
+    privateKey: config.privateKey,
+    rpcUrl: config.rpcUrl,
+    agentId: config.agentId !== "0" ? config.agentId : void 0
+  });
 }
-async function apiGet(backendUrl, endpoint) {
-  const res = await fetch(`${backendUrl}${endpoint}`);
-  return res.json();
+async function getX402Client(config) {
+  const { X402Client: X402Client2 } = await Promise.resolve().then(() => (init_X402Client(), X402Client_exports));
+  let accountAddress;
+  try {
+    const mc = await getMorphoClient(config);
+    accountAddress = await mc.getAccountAddress();
+  } catch {
+  }
+  return new X402Client2({
+    privateKey: config.privateKey,
+    rpcUrl: config.rpcUrl,
+    backendUrl: config.backendUrl,
+    agentId: config.agentId,
+    accountAddress
+  });
 }
 var ERC8004_ABI = [
   "function register(string agentURI) external returns (uint256 agentId)",
   "function register() external returns (uint256 agentId)",
   "function ownerOf(uint256 tokenId) view returns (address)",
   "function balanceOf(address owner) view returns (uint256)",
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
-  "event Registered(uint256 indexed agentId, string agentURI, address indexed owner)"
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
 ];
-var ACCOUNT_FACTORY_ABI = [
+var ACCOUNT_FACTORY_ABI2 = [
   "function getAccount(uint256 agentId) view returns (address)",
   "function accountExists(uint256 agentId) view returns (bool)",
-  "function predictAddress(uint256 agentId) view returns (address)",
-  "function totalAccounts() view returns (uint256)",
   "function createAccount(uint256 agentId) returns (address account)",
   "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
 ];
-var AGENT_ACCOUNT_ABI = [
-  "function agentId() view returns (uint256)",
-  "function owner() view returns (address)",
-  "function balanceOf(address token) view returns (uint256)",
-  "function ethBalance() view returns (uint256)",
-  "function execute(address target, uint256 value, bytes data) payable returns (bytes)",
-  "function drawCredit(address creditProvider, uint256 amount)",
-  "function repayCredit(address creditProvider, uint256 amount)",
-  "function fund(address token, uint256 amount)",
-  "function withdraw(address token, uint256 amount, address to)"
-];
-var MORPHO_CREDIT_ABI = [
-  "function depositCollateral(address collateralToken, uint256 amount)",
-  "function depositCollateralFor(address onBehalf, address collateralToken, uint256 amount)",
-  "function withdrawCollateral(address collateralToken, uint256 amount)",
-  "function drawWithCollateral(address collateralToken, uint256 amount)",
-  "function repayWithCollateral(address collateralToken, uint256 amount)",
-  "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))",
-  "function getSupportedCollaterals() view returns (address[])",
-  "function asset() view returns (address)",
-  "function getCreditInfo(address account) view returns (tuple(uint256 limit, uint256 used, uint256 available, uint256 accruedInterest, uint256 aprBps, bool isActive, bool requiresCollateral))",
-  "function getTotalDebt(address account) view returns (uint256)",
-  "function maxDrawable(address account) view returns (uint256)"
-];
-var REPUTATION_CREDIT_ABI = [
-  "function asset() view returns (address)",
-  "function isEligible(address account) view returns (bool)",
-  "function getCreditInfo(address account) view returns (tuple(uint256 limit, uint256 used, uint256 available, uint256 accruedInterest, uint256 aprBps, bool isActive, bool requiresCollateral))",
-  "function getTotalDebt(address account) view returns (uint256)",
-  "function maxDrawable(address account) view returns (uint256)",
-  "function applyForCredit(address account, uint256 requestedLimit)",
-  "function getCreditLineStatus(address account) view returns (uint8)",
-  "function getCreditLineDetails(address account) view returns (uint256 agentId, uint256 limit, uint256 used, uint256 aprBps, uint256 accruedInterest, uint256 requestedLimit, uint256 createdAt, uint256 lastActivityAt, uint8 status)",
-  "function getAgentAccount(uint256 agentId) view returns (address)",
-  "function previewScoredLimit(uint256 agentId) view returns (uint256 limit, uint256 score, bool eligible)",
-  "function dailyDrawLimit() view returns (uint256)",
-  "function totalBorrowed() view returns (uint256)",
-  "event CreditApplied(uint256 indexed creditLineId, uint256 indexed agentId, uint256 requestedLimit)"
-];
 var VALIDATION_REGISTRY_ABI = [
-  "function isAgentCodeApproved(uint256 agentId) view returns (bool)",
-  "function getAgentValidations(uint256 agentId) view returns (bytes32[])"
-];
-var ERC20_ABI = [
-  "function balanceOf(address account) view returns (uint256)",
-  "function approve(address spender, uint256 amount) external returns (bool)",
-  "function allowance(address owner, address spender) view returns (uint256)",
-  "function decimals() view returns (uint8)",
-  "function symbol() view returns (string)"
+  "function isAgentCodeApproved(uint256 agentId) view returns (bool)"
 ];
 var MOCK_ERC20_ABI = [
   "function mint(address to, uint256 amount) external"
 ];
-var STATUS_NAMES = {
-  0: "None",
-  1: "Pending",
-  2: "Active",
-  3: "Frozen",
-  4: "Closed",
-  5: "Defaulted"
-};
-function getCollateralInfo(chainId) {
-  if (chainId === 8453 || chainId === 84532) {
-    return {
-      WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18 },
-      wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", decimals: 18 },
-      cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", decimals: 18 }
-    };
-  }
-  return {
-    WETH: { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", decimals: 18 },
-    wstETH: { address: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0", decimals: 18 }
-  };
+async function apiGet(backendUrl, endpoint) {
+  const res = await fetch(`${backendUrl}${endpoint}`);
+  return res.json();
+}
+function decodeError(error) {
+  const msg = error?.message || String(error);
+  if (msg.includes("CodeNotApproved")) return "Agent code not approved. Complete KYA first.";
+  if (msg.includes("0xda04aecc") || msg.includes("ExceedsMaxLtv"))
+    return "ExceedsMaxLtv \u2014 collateral too low for this borrow amount.";
+  if (msg.includes("0xfeca99cb") || msg.includes("ExecutionFailed"))
+    return "ExecutionFailed \u2014 the inner contract call reverted.";
+  if (msg.includes("0xa920ef9f"))
+    return "PositionNotActive \u2014 no collateral deposited for this token.";
+  if (msg.length > 200) return msg.slice(0, 200) + "...";
+  return msg;
 }
 async function cmdInit(privateKey, agentId) {
   const rpcUrl = process.env.AGETHER_RPC_URL || DEFAULT_RPC;
   const backendUrl = process.env.AGETHER_BACKEND_URL || DEFAULT_BACKEND;
   let wallet;
   try {
-    wallet = new import_ethers2.ethers.Wallet(privateKey);
+    wallet = new import_ethers3.ethers.Wallet(privateKey);
   } catch {
     console.error("\u274C Invalid private key");
     process.exit(1);
   }
-  const config = {
-    privateKey,
-    agentId: agentId || "0",
-    rpcUrl,
-    backendUrl
-  };
+  const config = { privateKey, agentId: agentId || "0", rpcUrl, backendUrl };
   saveConfig(config);
-  console.log(`\u2705 Initialized Agether CLI`);
+  console.log("\u2705 Initialized Agether CLI");
   console.log(`   Address: ${wallet.address}`);
   console.log(`   RPC:     ${rpcUrl}`);
   console.log(`   Backend: ${backendUrl}`);
   console.log(`   Config:  ${CONFIG_PATH}`);
 }
-async function cmdRegister(name, _codeUrl) {
+async function cmdRegister(name) {
   const config = requireConfig();
-  const signer = getSigner(config);
-  const wallet = new import_ethers2.ethers.Wallet(config.privateKey);
-  const agentName = name || `Agent-${wallet.address.slice(0, 8)}`;
+  const provider = new import_ethers3.ethers.JsonRpcProvider(config.rpcUrl);
+  const signer = new import_ethers3.ethers.Wallet(config.privateKey, provider);
+  const agentName = name || `Agent-${signer.address.slice(0, 8)}`;
   console.log(`\u{1F916} Registering agent: ${agentName}
 `);
-  console.log(`   Wallet: ${wallet.address}`);
-  console.log("\n  [1/5] Fetching contract addresses...");
-  let status;
+  console.log(`   Wallet: ${signer.address}`);
+  console.log("\n  [1/4] Fetching contract addresses...");
+  let contracts;
   try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.agentRegistry) {
-      console.error("        \u274C Backend not configured with agentRegistry");
-      process.exit(1);
-    }
-    console.log(`        \u2713 ChainId: ${status.chainId}`);
-    console.log(`        \u2713 Registry: ${status.contracts.agentRegistry}`);
+    const statusResp = await apiGet(config.backendUrl, "/status");
+    contracts = statusResp.contracts || {};
+    console.log("        \u2713 Backend OK");
   } catch (e) {
     console.error(`        \u274C Failed to reach backend: ${e.message}`);
     process.exit(1);
   }
-  console.log("  [2/5] Registering on ERC-8004 IdentityRegistry...");
-  const agentRegistry = new import_ethers2.ethers.Contract(
-    status.contracts.agentRegistry,
-    ERC8004_ABI,
-    signer
-  );
+  const registryAddr = contracts.agentRegistry || contracts.identityRegistry;
+  const factoryAddr = contracts.accountFactory;
+  const validationAddr = contracts.validationRegistry;
+  if (!registryAddr || !factoryAddr) {
+    console.error("        \u274C Backend missing agentRegistry or accountFactory");
+    process.exit(1);
+  }
+  console.log("  [2/4] Registering on ERC-8004 IdentityRegistry...");
+  const agentRegistry = new import_ethers3.ethers.Contract(registryAddr, ERC8004_ABI, signer);
   let agentId;
   if (config.agentId && config.agentId !== "0") {
     agentId = BigInt(config.agentId);
     try {
       const owner = await agentRegistry.ownerOf(agentId);
-      if (owner.toLowerCase() === wallet.address.toLowerCase()) {
-        console.log(`        \u2713 Already registered as Agent #${agentId}, skipping mint`);
+      if (owner.toLowerCase() === signer.address.toLowerCase()) {
+        console.log(`        \u2713 Already registered as Agent #${agentId}`);
       } else {
-        console.error("        \u274C agentId in config does not belong to this wallet");
+        console.error("        \u274C agentId does not belong to this wallet");
         process.exit(1);
       }
     } catch {
@@ -578,1551 +1258,325 @@ async function cmdRegister(name, _codeUrl) {
       process.exit(1);
     }
   } else {
-    const existingBalance = await agentRegistry.balanceOf(wallet.address);
+    const existingBalance = await agentRegistry.balanceOf(signer.address);
     if (existingBalance > 0n) {
-      console.log(`        \u26A0 Wallet already owns ${existingBalance} ERC-8004 token(s), minting another`);
+      console.log(`        \u26A0 Wallet already owns ${existingBalance} token(s), minting another`);
     }
     try {
       const registrationFile = JSON.stringify({
         type: "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
         name: agentName,
         description: "AI agent registered via Agether CLI",
-        active: true,
-        registrations: [{
-          agentId: 0,
-          agentRegistry: `eip155:${status.chainId}:${status.contracts.agentRegistry}`
-        }]
+        active: true
       });
       const agentURI = `data:application/json;base64,${Buffer.from(registrationFile).toString("base64")}`;
       const tx = await agentRegistry["register(string)"](agentURI);
       const receipt = await waitForTx(tx);
-      const transferTopic = import_ethers2.ethers.id("Transfer(address,address,uint256)");
-      const transferLog = receipt.logs.find(
-        (log) => log.topics[0] === transferTopic
-      );
+      const transferTopic = import_ethers3.ethers.id("Transfer(address,address,uint256)");
+      const transferLog = receipt.logs.find((log) => log.topics[0] === transferTopic);
       if (transferLog && transferLog.topics.length >= 4) {
         agentId = BigInt(transferLog.topics[3]);
       } else {
-        const registeredTopic = import_ethers2.ethers.id("Registered(uint256,string,address)");
-        const registeredLog = receipt.logs.find(
-          (log) => log.topics[0] === registeredTopic
-        );
-        if (registeredLog && registeredLog.topics.length >= 2) {
-          agentId = BigInt(registeredLog.topics[1]);
-        } else {
-          console.error("        \u274C Could not parse agentId from receipt");
-          console.error("        Logs:", receipt.logs.length);
-          process.exit(1);
-        }
-      }
-      const owner = await agentRegistry.ownerOf(agentId);
-      if (owner.toLowerCase() !== wallet.address.toLowerCase()) {
-        console.error(`        \u274C Ownership mismatch: expected ${wallet.address}, got ${owner}`);
+        console.error("        \u274C Could not parse agentId from receipt");
         process.exit(1);
       }
-      console.log(`        \u2713 Agent #${agentId} registered on ERC-8004`);
+      console.log(`        \u2713 Agent #${agentId} registered`);
       console.log(`        TX: ${tx.hash}`);
       config.agentId = agentId.toString();
       saveConfig(config);
     } catch (e) {
-      if (e.message?.includes("already") || e.message?.includes("exists") || e.message?.includes("execution reverted")) {
-        console.log("        Already registered on ERC-8004, looking up existing agentId...");
-        const balance = await agentRegistry.balanceOf(wallet.address);
+      if (config.agentId && config.agentId !== "0") {
+        agentId = BigInt(config.agentId);
+        console.log(`        Using existing Agent #${agentId}`);
+      } else {
+        const balance = await agentRegistry.balanceOf(signer.address);
         if (balance > 0n) {
-          if (config.agentId && config.agentId !== "0") {
-            agentId = BigInt(config.agentId);
-            const owner = await agentRegistry.ownerOf(agentId);
-            if (owner.toLowerCase() === wallet.address.toLowerCase()) {
-              console.log(`        \u2713 Using existing Agent #${agentId}`);
-            } else {
-              console.error("        \u274C agentId in config does not belong to this wallet");
-              process.exit(1);
-            }
-          } else {
-            console.error(`        Wallet owns ${balance} ERC-8004 tokens but agentId unknown.`);
-            console.error("        Set manually: agether init <pk> --agent-id <id>");
-            process.exit(1);
-          }
+          console.error(`        Wallet owns ${balance} token(s) but agentId unknown.`);
+          console.error("        Set manually: agether init <pk> --agent-id <id>");
         } else {
-          console.error(`        \u274C No agentId in config. Re-register or set manually.`);
-          process.exit(1);
+          console.error(`        \u274C Registration failed: ${e.message}`);
         }
-      } else {
-        console.error(`        \u274C Failed: ${e.message}`);
         process.exit(1);
       }
     }
   }
-  const network = await new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl).getNetwork();
+  const network = await provider.getNetwork();
   const chainId = Number(network.chainId);
   if (chainId === 31337 || chainId === 1) {
-    if (status.contracts?.usdc) {
-      console.log("  [3/5] Minting test USDC (Hardhat fork)...");
-      const deployerPk = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
-      const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-      const deployer = new import_ethers2.ethers.Wallet(deployerPk, provider);
-      const usdc = new import_ethers2.ethers.Contract(status.contracts.usdc, MOCK_ERC20_ABI, deployer);
+    console.log("  [3/4] Minting test USDC (Hardhat fork)...");
+    const deployerPk = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+    const deployer = new import_ethers3.ethers.Wallet(deployerPk, provider);
+    const usdcAddr = contracts.usdc;
+    if (usdcAddr) {
       try {
-        const mintAmount = BigInt(5e10);
-        const tx = await usdc.mint(wallet.address, mintAmount);
+        const usdc = new import_ethers3.ethers.Contract(usdcAddr, MOCK_ERC20_ABI, deployer);
+        const tx = await usdc.mint(signer.address, BigInt(5e10));
         await waitForTx(tx);
-        console.log(`        \u2713 Minted $${Number(mintAmount) / 1e6} USDC`);
-      } catch (e) {
-        console.log(`        \u26A0 Mint failed: ${e.message?.slice(0, 80)}`);
+        console.log("        \u2713 Minted $50,000 USDC");
+      } catch {
+        console.log("        \u26A0 Mint failed (probably real network)");
       }
     }
   } else {
-    console.log("  [3/5] Skipping USDC mint (real network \u2014 fund wallet manually)");
+    console.log("  [3/4] Skipping USDC mint (real network)");
   }
-  console.log("  [4/5] Creating AgentAccount (smart wallet)...");
-  if (status.contracts?.accountFactory) {
-    const accountFactory = new import_ethers2.ethers.Contract(
-      status.contracts.accountFactory,
-      ACCOUNT_FACTORY_ABI,
-      signer
-    );
+  console.log("  [4/4] Creating AgentAccount...");
+  if (factoryAddr) {
+    const factory = new import_ethers3.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI2, signer);
     try {
-      const exists = await accountFactory.accountExists(agentId);
+      const exists = await factory.accountExists(agentId);
       if (exists) {
-        const accountAddr = await accountFactory.getAccount(agentId);
-        console.log(`        Already exists: ${accountAddr}`);
+        const addr = await factory.getAccount(agentId);
+        console.log(`        Already exists: ${addr}`);
       } else {
-        const tx = await accountFactory.createAccount(agentId);
+        const tx = await factory.createAccount(agentId);
         await waitForTx(tx);
-        const accountAddr = await accountFactory.getAccount(agentId);
-        console.log(`        \u2713 Account created: ${accountAddr}`);
+        const addr = await factory.getAccount(agentId);
+        console.log(`        \u2713 Created: ${addr}`);
         console.log(`        TX: ${tx.hash}`);
       }
     } catch (e) {
       console.error(`        \u274C Failed: ${e.message}`);
     }
-  } else {
-    console.log("        \u26A0 No accountFactory configured");
   }
-  console.log("  [5/5] Checking KYA status (ValidationRegistry)...");
-  if (status.contracts?.validationRegistry) {
-    const validationRegistry = new import_ethers2.ethers.Contract(
-      status.contracts.validationRegistry,
-      VALIDATION_REGISTRY_ABI,
-      signer
-    );
+  if (validationAddr) {
+    const vr = new import_ethers3.ethers.Contract(validationAddr, VALIDATION_REGISTRY_ABI, provider);
     try {
-      const approved = await validationRegistry.isAgentCodeApproved(agentId);
-      console.log(`        Code approved: ${approved ? "\u2705 Yes" : "\u23F3 Pending"}`);
+      const approved = await vr.isAgentCodeApproved(agentId);
+      console.log(`
+  KYA Status: ${approved ? "\u2705 Approved" : "\u23F3 Pending"}`);
     } catch {
-      console.log("        \u26A0 Could not check validation status");
+      console.log("\n  KYA Status: \u26A0 Could not check");
     }
-  } else {
-    console.log("        \u26A0 No validationRegistry configured");
-  }
-  console.log("\n  \u{1F4CA} Fetching initial credit scores...");
-  try {
-    const scoreRes = await fetch(`${config.backendUrl}/credit/score/${agentId}`);
-    const score = await scoreRes.json();
-    if (score.error) {
-      console.log("        \u26A0 Could not fetch scores (agent not yet indexed)");
-    } else {
-      console.log("");
-      console.log("  Credit Score Summary:");
-      console.log(`     Bayesian Score:    ${score.bayesianScore}/1000`);
-      console.log(`     Internal Score:    ${score.internalScore}/1000`);
-      console.log(`     External Score:    ${score.externalScore}/1000 (Cred Protocol)`);
-      console.log(`     Confidence:        ${(score.confidence * 100).toFixed(0)}%`);
-      console.log("");
-      console.log("  ChainRisk Subscores (5-factor model):");
-      if (score.subscores) {
-        console.log(`     Historical (35%):  ${score.subscores.historical?.score || "N/A"} - ${score.subscores.historical?.description || ""}`);
-        console.log(`     Current Risk (25%):${score.subscores.currentRisk?.score || "N/A"} - ${score.subscores.currentRisk?.description || ""}`);
-        console.log(`     Utilization (15%): ${score.subscores.utilization?.score || "N/A"} - ${score.subscores.utilization?.description || ""}`);
-        console.log(`     On-chain TX (15%): ${score.subscores.onChainTx?.score || "N/A"} - ${score.subscores.onChainTx?.description || ""}`);
-        console.log(`     New Credit (10%):  ${score.subscores.newCredit?.score || "N/A"} - ${score.subscores.newCredit?.description || ""}`);
-      }
-    }
-  } catch {
-    console.log("        \u26A0 Could not reach backend for scores");
   }
   console.log(`
-\u2705 Agent #${agentId} registered on ERC-8004!`);
+\u2705 Agent #${agentId} ready!`);
   console.log(`   Config: ${CONFIG_PATH}`);
-  console.log("");
-  console.log("   Next steps:");
-  console.log("     1. Wait for Admin to approve code (KYA audit) at /test");
-  console.log("     2. Apply for credit: agether apply --limit 5000");
-  console.log("     3. After approval, deposit collateral if required");
-  console.log("     4. Draw funds: agether draw --amount 1000");
+  console.log("\n   Next steps:");
+  console.log("     agether balance");
+  console.log("     agether deposit --amount 0.05 --token WETH");
+  console.log("     agether borrow --amount 100");
 }
-async function cmdApply(limitUsd) {
+async function cmdBalance() {
   const config = requireConfig();
-  const signer = getSigner(config);
-  const agentId = BigInt(config.agentId);
-  if (agentId === 0n) {
-    console.error("\u274C No agentId. Run: agether register");
-    process.exit(1);
-  }
-  console.log(`\u{1F4CB} Applying for $${limitUsd} credit line (Agent #${agentId})...
+  const mc = await getMorphoClient(config);
+  const balances = await mc.getBalances();
+  console.log(`
+\u{1F4B0} Agent #${balances.agentId} Balances
 `);
-  const status = await apiGet(config.backendUrl, "/status");
-  const reputationCreditAddr = status.contracts?.reputationCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  if (!reputationCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Backend not configured (missing reputationCredit or accountFactory)");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const accountFactory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, provider);
-  const reputationCredit = new import_ethers2.ethers.Contract(reputationCreditAddr, REPUTATION_CREDIT_ABI, signer);
-  const accountExists = await accountFactory.accountExists(agentId);
-  if (!accountExists) {
-    console.error("  \u274C No AgentAccount. Run: agether register");
-    process.exit(1);
+  console.log(`  EOA:     ${balances.address}`);
+  console.log(`  ETH:     ${parseFloat(balances.eth).toFixed(6)}`);
+  console.log(`  USDC:    $${parseFloat(balances.usdc).toFixed(2)}`);
+  if (balances.agentAccount) {
+    console.log(`
+  AgentAccount: ${balances.agentAccount.address}`);
+    console.log(`  ETH:          ${parseFloat(balances.agentAccount.eth).toFixed(6)}`);
+    console.log(`  USDC:         $${parseFloat(balances.agentAccount.usdc).toFixed(2)}`);
   }
-  const accountAddr = await accountFactory.getAccount(agentId);
-  const statusCode = await reputationCredit.getCreditLineStatus(accountAddr);
-  if (Number(statusCode) !== 0) {
-    console.log(`  \u26A0 Agent #${agentId} already has a credit line`);
-    console.log(`  Status: ${STATUS_NAMES[Number(statusCode)] || statusCode}`);
-    const data = await reputationCredit.getCreditLineDetails(accountAddr);
-    console.log(`  Limit:  $${(Number(data[1]) / 1e6).toFixed(2)}`);
+}
+async function cmdStatus() {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log("\n\u{1F4CA} Morpho Positions\n");
+  const status = await mc.getStatus();
+  console.log(`  Agent #${status.agentId}`);
+  console.log(`  Account:    ${status.agentAccount}`);
+  console.log(`  Total Debt: $${parseFloat(status.totalDebt).toFixed(2)}`);
+  if (status.positions.length === 0) {
+    console.log("\n  No active positions. Deposit collateral first:");
+    console.log("    agether deposit --amount 0.05 --token WETH");
     return;
   }
-  console.log("  [1/2] Evaluating credit application...");
-  const limitRaw = import_ethers2.ethers.parseUnits(limitUsd.toString(), 6);
-  let evaluation;
-  try {
-    const res = await fetch(`${config.backendUrl}/credit/evaluate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        agentId: agentId.toString(),
-        requestedLimit: limitRaw.toString()
-      })
-    });
-    evaluation = await res.json();
-  } catch (e) {
-    console.error(`        \u274C Evaluation failed: ${e.message}`);
-    process.exit(1);
-  }
-  console.log("");
-  console.log("  \u{1F4CA} Evaluation Results:");
-  console.log(`     Approved:          ${evaluation.approved ? "\u2705 Yes" : "\u274C No"}`);
-  console.log(`     Credit Limit:      $${(Number(evaluation.limit) / 1e6).toFixed(2)}`);
-  console.log(`     APR:               ${evaluation.aprBps / 100}%`);
-  console.log(`     Risk Score:        ${evaluation.riskScore}/100`);
-  console.log(`     Bayesian Score:    ${evaluation.bayesianScore}/1000`);
-  console.log(`     Confidence:        ${((evaluation.confidence || 0) * 100).toFixed(0)}%`);
-  if (!evaluation.approved) {
-    console.log("");
-    console.log(`  \u274C Reason: ${evaluation.reason}`);
-    process.exit(1);
+  console.log("\n  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log("  \u2502 Token     \u2502 Collateral       \u2502 Debt (USDC)      \u2502");
+  console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  for (const p of status.positions) {
+    const tok = p.collateralToken.padEnd(9);
+    const col = parseFloat(p.collateral).toFixed(6).padStart(16);
+    const debt = ("$" + parseFloat(p.debt).toFixed(2)).padStart(16);
+    console.log(`  \u2502 ${tok} \u2502 ${col} \u2502 ${debt} \u2502`);
   }
-  console.log("");
-  console.log("  [2/2] Submitting application on-chain...");
+  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
   try {
-    const tx = await reputationCredit.applyForCredit(accountAddr, limitRaw);
-    await tx.wait();
-    console.log(`        \u2713 TX: ${tx.hash}`);
+    const score = await mc.getCreditScore();
+    const { fresh, age } = await mc.isScoreFresh();
+    const ageHrs = Number(age) / 3600;
     console.log(`
-\u2705 Credit application submitted (Pending)`);
-    console.log("   Next steps:");
-    console.log("     1. Wait for admin to process your application");
-    console.log("     2. After approval, draw: agether draw --amount <usd>");
-  } catch (e) {
-    console.error(`        \u274C ${decodeError(e)}`);
-  }
-}
-async function cmdDraw(amountUsd) {
-  const config = requireConfig();
-  const signer = getSigner(config);
-  const agentId = BigInt(config.agentId);
-  const walletAddress = await signer.getAddress();
-  console.log(`\u{1F4B8} Drawing $${amountUsd} (Agent #${agentId})...
-`);
-  const status = await apiGet(config.backendUrl, "/status");
-  const reputationCreditAddr = status.contracts?.reputationCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const accountFactory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, provider);
-  const accountAddr = await accountFactory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("  \u274C No AgentAccount. Run: agether register");
-    process.exit(1);
-  }
-  const agentAccount = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, provider);
-  const owner = await agentAccount.owner();
-  if (owner.toLowerCase() !== walletAddress.toLowerCase()) {
-    console.error("  \u274C WALLET MISMATCH!");
-    console.error(`     Your wallet:  ${walletAddress}`);
-    console.error(`     Agent owner:  ${owner}`);
-    process.exit(1);
-  }
-  const reputationCredit = new import_ethers2.ethers.Contract(reputationCreditAddr, REPUTATION_CREDIT_ABI, provider);
-  const creditStatus = await reputationCredit.getCreditLineStatus(accountAddr);
-  if (Number(creditStatus) !== 2) {
-    console.error(`  \u274C Credit line not active (status: ${STATUS_NAMES[Number(creditStatus)] || creditStatus})`);
-    process.exit(1);
-  }
-  const available = await reputationCredit.maxDrawable(accountAddr);
-  const drawAmount = import_ethers2.ethers.parseUnits(amountUsd.toString(), 6);
-  console.log(`  Account:    ${accountAddr}`);
-  console.log(`  Available:  $${(Number(available) / 1e6).toFixed(2)}`);
-  console.log(`  Drawing:    $${amountUsd}`);
-  if (drawAmount > available) {
-    console.error(`  \u274C Exceeds available credit`);
-    process.exit(1);
-  }
-  console.log("\n  Signing draw transaction...");
-  try {
-    const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-    const tx = await account.drawCredit(reputationCreditAddr, drawAmount);
-    await tx.wait();
-    console.log(`
-\u2705 Drew $${amountUsd}`);
-    console.log(`   TX: ${tx.hash}`);
-    const newAvailable = await reputationCredit.maxDrawable(accountAddr);
-    console.log(`   Remaining credit: $${(Number(newAvailable) / 1e6).toFixed(2)}`);
-  } catch (e) {
-    console.error(`  \u274C ${decodeError(e)}`);
-  }
-}
-async function cmdRepay(amountUsd) {
-  const config = requireConfig();
-  const signer = getSigner(config);
-  const agentId = BigInt(config.agentId);
-  console.log(`\u{1F4B0} Repaying $${amountUsd} (Agent #${agentId})...
-`);
-  const status = await apiGet(config.backendUrl, "/status");
-  const reputationCreditAddr = status.contracts?.reputationCredit;
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  const usdcAddr = status.contracts?.usdc;
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const accountFactory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, provider);
-  const accountAddr = await accountFactory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("  \u274C No AgentAccount found");
-    process.exit(1);
-  }
-  if (morphoCreditAddr) {
-    const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-    const COLLATERALS = getCollateralInfo(Number((await provider.getNetwork()).chainId));
-    for (const [symbol, info] of Object.entries(COLLATERALS)) {
-      const pos = await morphoCredit.getPosition(accountAddr, info.address);
-      if (pos.borrowedAmount > 0n) {
-        console.log(`  \u26A0 Agent has Morpho debt ($${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)} via ${symbol})`);
-        console.log(`  \u2192 Redirecting to morpho-repay...
-`);
-        return cmdMorphoRepay(amountUsd.toString());
-      }
-    }
-  }
-  const reputationCredit = new import_ethers2.ethers.Contract(reputationCreditAddr, REPUTATION_CREDIT_ABI, provider);
-  const totalDebt = await reputationCredit.getTotalDebt(accountAddr);
-  if (totalDebt === 0n) {
-    console.log("  \u2705 Nothing to repay \u2014 debt is zero");
-    return;
-  }
-  let repayAmount = import_ethers2.ethers.parseUnits(amountUsd.toString(), 6);
-  if (repayAmount > totalDebt) {
-    repayAmount = totalDebt;
-    console.log(`  \u26A0 Capped to total debt: $${(Number(totalDebt) / 1e6).toFixed(2)}`);
-  }
-  console.log(`  Account:     ${accountAddr}`);
-  console.log(`  Total debt:  $${(Number(totalDebt) / 1e6).toFixed(2)}`);
-  console.log(`  Repaying:    $${(Number(repayAmount) / 1e6).toFixed(2)}`);
-  const usdc = new import_ethers2.ethers.Contract(usdcAddr, ERC20_ABI, signer);
-  console.log("\n  [1/3] Approving USDC...");
-  try {
-    const approveTx = await usdc.approve(accountAddr, repayAmount);
-    await approveTx.wait();
-    console.log("        \u2713 Approved");
-  } catch (e) {
-    console.error(`        \u274C Approve failed: ${e.message}`);
-    process.exit(1);
-  }
-  console.log("  [2/3] Funding AgentAccount...");
-  const freshSigner = getFreshSigner(config);
-  const agentAccount = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, freshSigner);
-  try {
-    const fundTx = await agentAccount.fund(usdcAddr, repayAmount);
-    await fundTx.wait();
-    console.log("        \u2713 Funded");
-  } catch (e) {
-    console.error(`        \u274C Fund failed: ${e.message}`);
-    process.exit(1);
-  }
-  console.log("  [3/3] Repaying...");
-  const freshSigner2 = getFreshSigner(config);
-  const agentAccount2 = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, freshSigner2);
-  try {
-    const tx = await agentAccount2.repayCredit(reputationCreditAddr, repayAmount);
-    await tx.wait();
-    console.log(`
-\u2705 Repaid $${(Number(repayAmount) / 1e6).toFixed(2)}`);
-    console.log(`   TX: ${tx.hash}`);
-    const newDebt = await reputationCredit.getTotalDebt(accountAddr);
-    console.log(`   Remaining debt: $${(Number(newDebt) / 1e6).toFixed(2)}`);
-  } catch (e) {
-    console.error(`  \u274C ${decodeError(e)}`);
-  }
-}
-async function cmdStatus() {
-  const config = requireConfig();
-  const agentId = BigInt(config.agentId || "0");
-  if (agentId === 0n) {
-    const signer = getSigner(config);
-    console.log(`\u{1F4CA} Wallet Status (not registered yet)
-`);
-    console.log(`  Wallet:  ${signer.address}`);
-    try {
-      const provider2 = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-      const balance = await provider2.getBalance(signer.address);
-      console.log(`  ETH:     ${import_ethers2.ethers.formatEther(balance)}`);
-    } catch {
-      console.log("  ETH:     (could not read)");
-    }
-    console.log(`
-  Run: agether register <name>`);
-    return;
-  }
-  console.log(`\u{1F4CA} Agent #${agentId} Status
-`);
-  const status = await apiGet(config.backendUrl, "/status");
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const accountFactory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    provider
-  );
-  const accountAddr = await accountFactory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.log("  No AgentAccount found. Run: agether register");
-    return;
-  }
-  const reputationCredit = new import_ethers2.ethers.Contract(
-    status.contracts.reputationCredit,
-    REPUTATION_CREDIT_ABI,
-    provider
-  );
-  const creditStatus = await reputationCredit.getCreditLineStatus(accountAddr);
-  if (Number(creditStatus) === 0) {
-    console.log("  No credit line found. Run: agether apply --limit <amount>");
-    return;
-  }
-  const data = await reputationCredit.getCreditLineDetails(accountAddr);
-  const totalDebt = await reputationCredit.getTotalDebt(accountAddr);
-  const available = await reputationCredit.maxDrawable(accountAddr);
-  const limit = Number(data[1]) / 1e6;
-  const used = Number(data[2]) / 1e6;
-  const interest = Number(data[4]) / 1e6;
-  console.log(`  Account:         ${accountAddr}`);
-  console.log(`  Status:          ${STATUS_NAMES[Number(data[8])] || data[8]}`);
-  console.log(`  Limit:           $${limit.toFixed(2)}`);
-  console.log(`  Used:            $${used.toFixed(2)}`);
-  console.log(`  Interest:        $${interest.toFixed(2)}`);
-  console.log(`  Total Debt:      $${(Number(totalDebt) / 1e6).toFixed(2)}`);
-  console.log(`  Available:       $${(Number(available) / 1e6).toFixed(2)}`);
-  console.log(`  APR:             ${Number(data[3]) / 100}%`);
-  console.log(`  Requested Limit: $${(Number(data[5]) / 1e6).toFixed(2)}`);
-  console.log(`  Created:         ${new Date(Number(data[6]) * 1e3).toISOString()}`);
-  console.log(`  Last Activity:   ${new Date(Number(data[7]) * 1e3).toISOString()}`);
-}
-async function cmdScore() {
-  const config = requireConfig();
-  console.log(`\u{1F4C8} Agent #${config.agentId} Score
-`);
-  try {
-    const score = await apiGet(config.backendUrl, `/credit/score/${config.agentId}`);
-    console.log(`  Bayesian Score: ${score.bayesianScore?.toFixed(0) || "N/A"}`);
-    console.log(`  Confidence:     ${((score.confidence || 0) * 100).toFixed(1)}%`);
-    if (score.subscores) {
-      console.log("");
-      console.log("  Subscores:");
-      console.log(`    Historical:   ${score.subscores.historical?.score?.toFixed(0) || "N/A"}`);
-      console.log(`    Current Risk: ${score.subscores.currentRisk?.score?.toFixed(0) || "N/A"}`);
-      console.log(`    Utilization:  ${score.subscores.utilization?.score?.toFixed(0) || "N/A"}`);
-      console.log(`    On-chain TX:  ${score.subscores.onChainTx?.score?.toFixed(0) || "N/A"}`);
-      console.log(`    New Credit:   ${score.subscores.newCredit?.score?.toFixed(0) || "N/A"}`);
-    }
-  } catch (e) {
-    console.error(`\u274C Failed: ${e.message}`);
-  }
-}
-async function cmdBalance() {
-  const config = requireConfig();
-  const wallet = new import_ethers2.ethers.Wallet(config.privateKey);
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  console.log(`\u{1F4B0} Agent #${config.agentId} Balances
-`);
-  console.log(`  Address: ${wallet.address}`);
-  const ethBal = await provider.getBalance(wallet.address);
-  console.log(`  ETH:     ${import_ethers2.ethers.formatEther(ethBal)}`);
-  try {
-    const status = await apiGet(config.backendUrl, "/status");
-    if (status.contracts?.usdc) {
-      const usdc = new import_ethers2.ethers.Contract(status.contracts.usdc, ERC20_ABI, provider);
-      const usdcBal = await usdc.balanceOf(wallet.address);
-      console.log(`  USDC:    $${(Number(usdcBal) / 1e6).toFixed(2)}`);
-    }
+  Credit Score: ${score} ${fresh ? "\u2705" : `\u26A0\uFE0F stale (${ageHrs.toFixed(1)}h old)`}`);
   } catch {
-    console.log("  USDC:    (could not read)");
+    console.log("\n  Credit Score: not yet computed");
   }
 }
-async function cmdCollateral(_amountUsd) {
-  console.log("\u26A0\uFE0F  Collateral deposit is not needed in v2.");
-  console.log("   ReputationCredit is undercollateralized (LP-funded).");
-  console.log("   For overcollateralized credit, use MorphoCredit.");
-}
-function decodeError(error) {
-  const msg = error?.message || String(error);
-  if (msg.includes("CodeNotApproved")) return "Agent code not approved. Complete KYA first.";
-  if (msg.includes("DailyLimitExceeded")) return "Daily draw limit exceeded. Try smaller amount or wait.";
-  if (msg.includes("CollateralRequired")) return "Collateral required. Run: agether collateral --amount <usd>";
-  if (msg.includes("ExceedsAvailable")) return "Amount exceeds available credit.";
-  if (msg.includes("NotAgentOwner")) return "Wallet is not the owner of this agentId.";
-  if (msg.includes("AlreadyHasCreditLine")) return "Agent already has a credit line.";
-  if (msg.includes("BelowMinimum")) return "Amount below minimum ($100).";
-  if (msg.includes("AboveMaximum")) return "Amount above maximum ($100,000).";
-  if (msg.includes("InsufficientLiquidity")) return "Vault has insufficient liquidity.";
-  if (msg.includes("Undercollateralized")) return "Position is undercollateralized.";
-  if (msg.includes("AgentDefaulted")) return "Agent has defaulted. Cannot use protocol.";
-  if (msg.includes("InvalidCreditStatus")) return "Credit line is not in the required status.";
-  if (msg.length > 200) return msg.slice(0, 200) + "...";
-  return msg;
-}
-async function cmdMorphoCompare(amountUsd) {
+async function cmdScore() {
   const config = requireConfig();
-  const signer = getSigner(config);
-  const address = await signer.getAddress();
   console.log(`
-\u{1F4CA} Comparing credit options for $${amountUsd}...
+\u{1F4C8} Agent #${config.agentId} Score
 `);
-  console.log(`   Wallet: ${address}`);
   try {
-    const balRes = await fetch(`${config.backendUrl}/morpho/balances/${address}`);
-    const balances = await balRes.json();
-    console.log("\n\u{1F4B0} Your Available Assets:");
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    console.log("\u2502  Token        \u2502  Balance         \u2502  Value USD      \u2502");
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    for (const [token, info] of Object.entries(balances.balances)) {
-      const bal = parseFloat(info.balanceFormatted);
-      if (bal > 0 || token === "USDC") {
-        const balStr = bal.toFixed(token === "USDC" ? 2 : 4).padStart(14);
-        const valStr = `$${parseFloat(info.valueUsd).toLocaleString()}`.padStart(13);
-        console.log(`\u2502  ${token.padEnd(11)} \u2502  ${balStr} \u2502  ${valStr} \u2502`);
-      }
-    }
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-    const res = await fetch(`${config.backendUrl}/morpho/compare`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        agentId: config.agentId,
-        amount: import_ethers2.ethers.parseUnits(amountUsd.toString(), 6).toString()
-      })
-    });
-    await res.json();
-    let estimates = {};
-    try {
-      const estRes = await fetch(`${config.backendUrl}/morpho/estimate/${amountUsd}`);
-      const estData = await estRes.json();
-      estimates = estData.estimates || {};
-    } catch {
-    }
-    const opts = balances.creditOptions || {};
-    const canMorphoWETH = opts.morphoWETH?.available && parseFloat(opts.morphoWETH?.maxBorrow || "0") >= amountUsd;
-    const canMorphoWstETH = opts.morphoWstETH?.available && parseFloat(opts.morphoWstETH?.maxBorrow || "0") >= amountUsd;
-    const canMorpho = canMorphoWETH || canMorphoWstETH;
-    console.log("\n\u{1F4CB} Credit Options for $" + amountUsd.toLocaleString() + ":");
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    for (const [symbol, est] of Object.entries(estimates)) {
-      const optKey = `morpho${symbol}`;
-      const canAfford = opts[optKey]?.available && parseFloat(opts[optKey]?.maxBorrow || "0") >= amountUsd;
-      const price = parseFloat(est.priceUsd || 0);
-      const needed = parseFloat(est.minCollateral || 0);
-      const neededUsd = parseFloat(est.minCollateralUsd || 0);
-      if (canAfford) {
-        console.log(`\u2502  \u2705 MORPHO with ${symbol} (Overcollateralized)`.padEnd(71) + "\u2502");
-        console.log(`\u2502     Need: ~${needed.toFixed(6)} ${symbol} ($${neededUsd.toFixed(2)}) at $${price.toFixed(0)}/${symbol} (120%)`.padEnd(71) + "\u2502");
-        console.log(`\u2502     \u2713 Instant  \u2713 No limits  \u2713 Borrow from Morpho Blue pool`.padEnd(71) + "\u2502");
-      } else if (price > 0) {
-        console.log(`\u2502  \u26A0\uFE0F  MORPHO with ${symbol} \u2014 need ${needed.toFixed(6)} ${symbol} ($${neededUsd.toFixed(2)})`.padEnd(71) + "\u2502");
-        const have = parseFloat(balances.balances?.[symbol]?.valueUsd || "0");
-        console.log(`\u2502     Have: $${have.toFixed(2)} ${symbol} | Need: $${neededUsd.toFixed(2)}`.padEnd(71) + "\u2502");
-      }
-    }
-    if (Object.keys(estimates).length === 0) {
-      console.log("\u2502  \u26A0\uFE0F  Could not fetch oracle prices from backend".padEnd(71) + "\u2502");
-    }
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-    if (canMorpho) {
-      const bestToken = canMorphoWETH ? "WETH" : "wstETH";
-      const bestEst = estimates[bestToken];
-      const needed = bestEst ? parseFloat(bestEst.minCollateral) : amountUsd * 1.2 / 2600;
-      const depositAmount = (needed * 1.05).toFixed(6);
-      console.log("\n\u{1F4A1} Recommended:");
-      console.log(`   agether morpho-deposit --amount ${depositAmount} --token ${bestToken}`);
-      console.log(`   agether morpho-borrow --amount ${amountUsd}`);
+    const data = await apiGet(config.backendUrl, `/score/${config.agentId}/current`);
+    if (data.score !== void 0) {
+      console.log(`  On-chain Score: ${data.score}`);
+      console.log(`  Timestamp:      ${data.timestamp ? new Date(Number(data.timestamp) * 1e3).toISOString() : "N/A"}`);
+      console.log(`  Signer:         ${data.signer || "N/A"}`);
+      console.log(`  Fresh:          ${data.fresh ? "\u2705" : "\u26A0\uFE0F stale"}`);
     } else {
-      console.log("\n\u274C Cannot borrow $" + amountUsd.toLocaleString());
-      console.log("   You need more collateral. Options:");
-      console.log("   \u2022 Wrap ETH to WETH for Morpho credit");
-      if (estimates["WETH"]) {
-        console.log(`   \u2022 Minimum: ${estimates["WETH"].minCollateral} WETH ($${estimates["WETH"].minCollateralUsd})`);
-      }
-    }
-  } catch (e) {
-    console.error(`\u274C Failed to compare: ${e.message}`);
-  }
-}
-async function cmdMorphoBalances() {
-  const config = requireConfig();
-  const signer = getSigner(config);
-  const address = await signer.getAddress();
-  console.log(`
-\u{1F4B0} Token Balances & Credit Capacity
-`);
-  console.log(`   Wallet: ${address}`);
-  try {
-    const res = await fetch(`${config.backendUrl}/morpho/balances/${address}`);
-    const data = await res.json();
-    console.log("\n\u{1F4CA} Your Balances:");
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    console.log("\u2502  Token        \u2502  Balance             \u2502  Value USD        \u2502");
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    for (const [token, info] of Object.entries(data.balances)) {
-      const bal = parseFloat(info.balanceFormatted);
-      const balStr = bal.toFixed(token === "USDC" ? 2 : 6).padStart(18);
-      const valStr = `$${parseFloat(info.valueUsd).toLocaleString()}`.padStart(15);
-      console.log(`\u2502  ${token.padEnd(11)} \u2502  ${balStr} \u2502  ${valStr} \u2502`);
-    }
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    console.log(`\u2502  TOTAL        \u2502                      \u2502  $${parseFloat(data.totalValueUsd).toLocaleString().padStart(13)} \u2502`);
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-    console.log("\n\u{1F4B3} Max Credit Capacity:");
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    console.log("\u2502  Option                         \u2502  Max Borrow       \u2502  Status   \u2502");
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    const opts = data.creditOptions || {};
-    const rows = [
-      ["Morpho WETH", opts.morphoWETH?.maxBorrow || "0", opts.morphoWETH?.available || false],
-      ["Morpho wstETH", opts.morphoWstETH?.maxBorrow || "0", opts.morphoWstETH?.available || false],
-      ["Morpho WBTC", opts.morphoWBTC?.maxBorrow || "0", opts.morphoWBTC?.available || false]
-    ];
-    for (const [name, max, avail] of rows) {
-      const nameStr = name.padEnd(29);
-      const maxStr = `$${parseFloat(max).toLocaleString()}`.padStart(15);
-      const statusStr = avail ? "\u2705" : "\u274C";
-      console.log(`\u2502  ${nameStr} \u2502  ${maxStr} \u2502     ${statusStr}    \u2502`);
-    }
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  } catch (e) {
-    console.error(`\u274C Failed to fetch balances: ${e.message}`);
-  }
-}
-async function cmdMorphoMarkets() {
-  const config = requireConfig();
-  console.log("\n\u{1F4C8} Supported Morpho Markets\n");
-  try {
-    const data = await apiGet(config.backendUrl, "/morpho/markets");
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    console.log("\u2502  Collateral   \u2502 Loan     \u2502 Status     \u2502");
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    for (const m of data.markets) {
-      const collat = m.collateralToken.padEnd(11);
-      const loan = (m.loanToken || "USDC").padEnd(6);
-      const status = m.status === "active" ? "\u2705 Active" : "\u274C Inactive";
-      console.log(`\u2502  ${collat}  \u2502 ${loan}  \u2502 ${status} \u2502`);
+      console.log("  No score on-chain yet.");
     }
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  } catch (e) {
-    console.error(`\u274C Failed to fetch markets: ${e.message}`);
-  }
-}
-async function cmdMorphoOpen(collateralToken) {
-  const config = requireConfig();
-  console.log(`
-\u{1F3E6} Setting up Morpho credit with ${collateralToken} collateral...
-`);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  if (!morphoCreditAddr) {
-    console.error("\u274C MorphoCredit not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const net = await provider.getNetwork();
-  const cid = Number(net.chainId);
-  const COLLATERAL_ADDRESSES = cid === 8453 || cid === 84532 ? {
-    WETH: "0x4200000000000000000000000000000000000006",
-    wstETH: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
-    cbETH: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
-  } : {
-    WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-    wstETH: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"
-  };
-  const collateralAddr = COLLATERAL_ADDRESSES[collateralToken];
-  if (!collateralAddr) {
-    console.error(`\u274C Unsupported collateral: ${collateralToken}`);
-    console.log("   Supported:", Object.keys(COLLATERAL_ADDRESSES).join(", "));
-    process.exit(1);
-  }
-  const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer);
-  const position = await morphoCredit.getPosition(signer.address, collateralAddr);
-  if (position.isActive) {
-    console.log(`\u2713 Position already active with ${import_ethers2.ethers.formatEther(position.collateralAmount)} ${collateralToken}`);
-    console.log(`   Borrowed: $${import_ethers2.ethers.formatUnits(position.borrowedAmount, 6)}`);
-  } else {
-    console.log(`   No existing position for ${collateralToken}`);
+  } catch {
+    console.log("  Could not fetch current score.");
   }
-  console.log(`
-\u2705 Ready for Morpho credit with ${collateralToken}!`);
-  console.log(`
-Deposit collateral directly:
-`);
-  console.log(`   agether morpho-deposit --amount 0.1 --token ${collateralToken}`);
-  console.log(`
-This will:`);
-  console.log(`   1. Approve MorphoCredit to pull ${collateralToken} from your EOA`);
-  console.log(`   2. Deposit collateral to Morpho Blue via MorphoCredit`);
-  console.log(`   3. You can then borrow: agether morpho-borrow --amount 100`);
+  console.log("\n  To compute a fresh score (x402-gated, costs USDC):");
+  console.log(`    agether x402 ${config.backendUrl}/score/${config.agentId}`);
 }
-async function cmdMorphoDeposit(amountStr, tokenSymbol) {
+async function cmdMarkets() {
   const config = requireConfig();
-  console.log(`
-\u{1F4B0} Depositing ${amountStr} ${tokenSymbol} as collateral via MorphoCredit...
-`);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  if (!morphoCreditAddr) {
-    console.error("\u274C MorphoCredit not deployed");
-    process.exit(1);
-  }
-  if (!accountFactoryAddr) {
-    console.error("\u274C AccountFactory not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const net = await provider.getNetwork();
-  const COLLATERAL_INFO = getCollateralInfo(Number(net.chainId));
-  const tokenInfo = COLLATERAL_INFO[tokenSymbol];
-  if (!tokenInfo) {
-    console.error(`\u274C Unsupported token: ${tokenSymbol}`);
-    console.log("   Supported:", Object.keys(COLLATERAL_INFO).join(", "));
-    process.exit(1);
-  }
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const amount = import_ethers2.ethers.parseUnits(amountStr, tokenInfo.decimals);
-  const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const accountExists = await factory.accountExists(config.agentId);
-  if (!accountExists) {
-    console.error("\u274C No AgentAccount. Create one first: agether wallet-create");
-    process.exit(1);
-  }
-  const accountAddr = await factory.getAccount(config.agentId);
-  console.log(`   AgentAccount: ${accountAddr}`);
-  const token = new import_ethers2.ethers.Contract(tokenInfo.address, [
-    "function approve(address spender, uint256 amount) returns (bool)",
-    "function balanceOf(address) view returns (uint256)"
-  ], signer);
-  const balance = await token.balanceOf(signer.address);
-  if (balance < amount) {
-    console.error(`\u274C Insufficient ${tokenSymbol} balance`);
-    console.log(`   Have: ${import_ethers2.ethers.formatUnits(balance, tokenInfo.decimals)} ${tokenSymbol}`);
-    console.log(`   Need: ${amountStr} ${tokenSymbol}`);
-    process.exit(1);
-  }
-  console.log(`Step 1/3: Approving ${tokenSymbol} for MorphoCredit...`);
-  const approveTx = await token.approve(morphoCreditAddr, amount);
-  await approveTx.wait();
-  console.log(`   \u2713 Approved`);
-  const signer2 = new import_ethers2.ethers.Wallet(config.privateKey, new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl));
-  const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer2);
-  console.log(`Step 2/3: Depositing collateral for AgentAccount...`);
-  try {
-    const depositTx = await morphoCredit.depositCollateralFor(accountAddr, tokenInfo.address, amount);
-    await depositTx.wait();
-    console.log(`   \u2713 Deposited`);
-  } catch (e) {
-    console.error(`\u274C Deposit failed: ${decodeError(e)}`);
-    process.exit(1);
-  }
-  const signer3 = new import_ethers2.ethers.Wallet(config.privateKey, new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl));
-  const account = new import_ethers2.ethers.Contract(accountAddr, [
-    ...AGENT_ACCOUNT_ABI,
-    "function approveCreditProvider(address creditProvider)"
-  ], signer3);
-  console.log(`Step 3/3: Approving MorphoCredit as credit provider...`);
-  try {
-    const approveCpTx = await account.approveCreditProvider(morphoCreditAddr);
-    await approveCpTx.wait();
-    console.log(`   \u2713 Approved`);
-  } catch (e) {
-    console.log(`   \u2713 Already approved`);
+  const mc = await getMorphoClient(config);
+  console.log("\n\u{1F4C8} Morpho Blue Markets (Base USDC)\n");
+  const markets = await mc.getMarkets();
+  if (markets.length === 0) {
+    console.log("  No markets found. API may be unavailable.");
+    return;
   }
-  const morphoCreditView = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-  const position = await morphoCreditView.getPosition(accountAddr, tokenInfo.address);
-  console.log(`
-\u2705 Deposited ${amountStr} ${tokenSymbol} as Morpho collateral`);
-  console.log(`   Position tracked under: ${accountAddr} (AgentAccount)`);
-  console.log(`   Total collateral: ${import_ethers2.ethers.formatUnits(position.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-  console.log(`
-\u{1F4B5} You can now borrow USDC:`);
-  console.log(`   agether morpho-borrow --amount 100`);
+  console.log("  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+  console.log("  \u2502 Collateral    \u2502 LLTV     \u2502 Util %     \u2502 Supply (USDC)    \u2502");
+  console.log("  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+  for (const m of markets.slice(0, 15)) {
+    const col = (m.collateralAsset?.symbol || "N/A").padEnd(13);
+    const lltv = (Number(m.lltv) / 1e18 * 100).toFixed(0).padStart(6) + "%";
+    const util = (m.utilization * 100).toFixed(1).padStart(8) + "%";
+    const supply = ("$" + (Number(m.totalSupplyAssets) / 1e6).toLocaleString()).padStart(16);
+    console.log(`  \u2502 ${col} \u2502 ${lltv} \u2502 ${util} \u2502 ${supply} \u2502`);
+  }
+  console.log("  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
 }
-async function cmdMorphoBorrow(amountUsd) {
+async function cmdDeposit(amount, token) {
   const config = requireConfig();
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F4B8} Borrowing $${amountUsd} USDC via AgentAccount \u2192 MorphoCredit...
+\u{1F4B0} Depositing ${amount} ${token} as collateral...
 `);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  const usdcAddr = status.contracts?.usdc;
-  if (!morphoCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Contracts not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const accountAddr = await factory.getAccount(config.agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("\u274C No AgentAccount. Create one first: agether wallet-create");
-    process.exit(1);
-  }
-  console.log(`   AgentAccount: ${accountAddr}`);
-  const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-  const COLLATERALS = getCollateralInfo(Number((await provider.getNetwork()).chainId));
-  let activeCollateral = null;
-  for (const [symbol, info] of Object.entries(COLLATERALS)) {
-    const pos = await morphoCredit.getPosition(accountAddr, info.address);
-    if (pos.collateralAmount > 0n) {
-      activeCollateral = symbol;
-      console.log(`   Position: ${import_ethers2.ethers.formatEther(pos.collateralAmount)} ${symbol}`);
-      console.log(`   Current debt: $${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)}`);
-      break;
-    }
-  }
-  if (!activeCollateral) {
-    console.error("\u274C No collateral deposited for AgentAccount");
-    console.log("   Deposit first: agether morpho-deposit --amount 0.1 --token WETH");
-    process.exit(1);
-  }
-  const collateralAddr = COLLATERALS[activeCollateral].address;
-  const amountWei = import_ethers2.ethers.parseUnits(amountUsd, 6);
   try {
-    const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-    const morphoIface = new import_ethers2.ethers.Interface(MORPHO_CREDIT_ABI);
-    const borrowCalldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, amountWei]);
-    console.log(`   Borrowing $${amountUsd} USDC via drawWithCollateral(${activeCollateral})...`);
-    const tx = await account.execute(morphoCreditAddr, 0, borrowCalldata);
-    await waitForTx(tx);
-    const usdc = new import_ethers2.ethers.Contract(usdcAddr, ERC20_ABI, provider);
-    const accountUsdcBalance = await usdc.balanceOf(accountAddr);
-    console.log(`
-\u2705 Borrowed $${amountUsd} USDC`);
-    console.log(`   TX: ${tx.hash}`);
-    console.log(`   AgentAccount USDC: $${import_ethers2.ethers.formatUnits(accountUsdcBalance, 6)}`);
-    console.log(`
-   USDC is in your AgentAccount \u2014 ready for x402 payments`);
+    const result = await mc.supplyCollateral(token, amount);
+    console.log(`\u2705 Deposited ${amount} ${token}`);
+    console.log(`   AgentAccount: ${result.agentAccount}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
 }
-async function cmdMorphoWithdraw(amountStr, tokenSymbol) {
+async function cmdBorrow(amount, token) {
   const config = requireConfig();
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F3E7} Withdrawing ${amountStr} ${tokenSymbol} collateral from Morpho...
+\u{1F4B8} Borrowing $${amount} USDC...
 `);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  if (!morphoCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Contracts not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const net = await provider.getNetwork();
-  const COLLATERALS = getCollateralInfo(Number(net.chainId));
-  const tokenInfo = COLLATERALS[tokenSymbol];
-  if (!tokenInfo) {
-    console.error(`\u274C Unsupported token: ${tokenSymbol}`);
-    console.log("   Supported:", Object.keys(COLLATERALS).join(", "));
-    process.exit(1);
-  }
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const amount = import_ethers2.ethers.parseUnits(amountStr, tokenInfo.decimals);
-  const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const accountAddr = await factory.getAccount(config.agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("\u274C No AgentAccount");
-    process.exit(1);
-  }
-  console.log(`   AgentAccount: ${accountAddr}`);
-  const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-  const pos = await morphoCredit.getPosition(accountAddr, tokenInfo.address);
-  console.log(`   Collateral: ${import_ethers2.ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-  console.log(`   Debt: $${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)}`);
-  if (pos.collateralAmount === 0n) {
-    console.error(`\u274C No ${tokenSymbol} collateral deposited`);
-    process.exit(1);
-  }
-  const withdrawAmount = amountStr.toLowerCase() === "all" ? pos.collateralAmount : amount;
-  if (withdrawAmount > pos.collateralAmount) {
-    console.error(`\u274C Cannot withdraw more than deposited`);
-    console.log(`   Max: ${import_ethers2.ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-    process.exit(1);
-  }
   try {
-    const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-    const morphoIface = new import_ethers2.ethers.Interface(MORPHO_CREDIT_ABI);
-    console.log(`   Step 1/2: Withdrawing from Morpho...`);
-    const withdrawCalldata = morphoIface.encodeFunctionData("withdrawCollateral", [tokenInfo.address, withdrawAmount]);
-    const tx1 = await account.execute(morphoCreditAddr, 0, withdrawCalldata);
-    await waitForTx(tx1);
-    console.log(`   \u2713 Collateral withdrawn to AgentAccount`);
-    console.log(`   Step 2/2: Transferring to EOA wallet...`);
-    const tx2 = await account.withdraw(tokenInfo.address, withdrawAmount, signer.address);
-    await waitForTx(tx2);
-    console.log(`   \u2713 Sent to ${signer.address}`);
-    const newPos = await morphoCredit.getPosition(accountAddr, tokenInfo.address);
-    console.log(`
-\u2705 Withdrew ${import_ethers2.ethers.formatUnits(withdrawAmount, tokenInfo.decimals)} ${tokenSymbol} to EOA`);
-    console.log(`   Remaining collateral: ${import_ethers2.ethers.formatUnits(newPos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-    console.log(`   Remaining debt: $${import_ethers2.ethers.formatUnits(newPos.borrowedAmount, 6)}`);
-    console.log(`   TX: ${tx1.hash}`);
+    const result = await mc.borrow(amount, token);
+    console.log(`\u2705 Borrowed $${amount} USDC`);
+    console.log(`   Collateral: ${result.collateralToken}`);
+    console.log(`   AgentAccount: ${result.agentAccount}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
 }
-async function cmdMorphoRepay(amountUsd) {
+async function cmdDepositAndBorrow(collateralAmount, token, borrowAmount) {
   const config = requireConfig();
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F4B3} Repaying $${amountUsd} USDC via AgentAccount \u2192 MorphoCredit...
+\uFFFD\uFFFD Depositing ${collateralAmount} ${token} + Borrowing $${borrowAmount}...
 `);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  const usdcAddr = status.contracts?.usdc;
-  if (!morphoCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Contracts not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const accountAddr = await factory.getAccount(config.agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("\u274C No AgentAccount");
-    process.exit(1);
-  }
-  console.log(`   AgentAccount: ${accountAddr}`);
-  const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-  const COLLATERALS = getCollateralInfo(Number((await provider.getNetwork()).chainId));
-  let hasDebt = false;
-  let activeCollateral = null;
-  for (const [symbol, info] of Object.entries(COLLATERALS)) {
-    const pos = await morphoCredit.getPosition(accountAddr, info.address);
-    if (pos.borrowedAmount > 0n) {
-      hasDebt = true;
-      activeCollateral = symbol;
-      console.log(`   Position: ${import_ethers2.ethers.formatEther(pos.collateralAmount)} ${symbol}`);
-      console.log(`   Current debt: $${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)}`);
-      break;
-    }
-  }
-  if (!hasDebt || !activeCollateral) {
-    console.error("\u274C No Morpho debt to repay");
-    process.exit(1);
-  }
-  const collateralAddr = COLLATERALS[activeCollateral].address;
-  const amountWei = import_ethers2.ethers.parseUnits(amountUsd, 6);
-  const usdc = new import_ethers2.ethers.Contract(usdcAddr, ERC20_ABI, provider);
-  const accountUsdcBalance = await usdc.balanceOf(accountAddr);
-  if (accountUsdcBalance < amountWei) {
-    console.error(`\u274C Insufficient USDC in AgentAccount`);
-    console.log(`   Have: $${import_ethers2.ethers.formatUnits(accountUsdcBalance, 6)}`);
-    console.log(`   Need: $${amountUsd}`);
-    process.exit(1);
-  }
   try {
-    const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-    const erc20Iface = new import_ethers2.ethers.Interface(ERC20_ABI);
-    const approveCalldata = erc20Iface.encodeFunctionData("approve", [morphoCreditAddr, amountWei]);
-    console.log(`   Approving $${amountUsd} USDC for MorphoCredit...`);
-    const approveTx = await account.execute(usdcAddr, 0, approveCalldata);
-    await waitForTx(approveTx);
-    const morphoIface = new import_ethers2.ethers.Interface(MORPHO_CREDIT_ABI);
-    const repayCalldata = morphoIface.encodeFunctionData("repayWithCollateral", [collateralAddr, amountWei]);
-    console.log(`   Repaying $${amountUsd} USDC via repayWithCollateral(${activeCollateral})...`);
-    const tx = await account.execute(morphoCreditAddr, 0, repayCalldata);
-    await waitForTx(tx);
-    const totalDebt = await morphoCredit.getTotalDebt(accountAddr);
-    console.log(`
-\u2705 Repaid $${amountUsd} to Morpho`);
-    console.log(`   TX: ${tx.hash}`);
-    console.log(`   Remaining debt: $${import_ethers2.ethers.formatUnits(totalDebt, 6)}`);
+    const result = await mc.depositAndBorrow(token, collateralAmount, borrowAmount);
+    console.log(`\u2705 Deposited ${collateralAmount} ${token} & Borrowed $${borrowAmount} USDC`);
+    console.log(`   AgentAccount: ${result.agentAccount}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
 }
-async function cmdMorphoDepositAndBorrow(amountStr, tokenSymbol, borrowUsd) {
+async function cmdRepay(amount, token) {
   const config = requireConfig();
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F4B0} Deposit ${amountStr} ${tokenSymbol} + Borrow $${borrowUsd} USDC...
+\u{1F4B3} Repaying $${amount} USDC...
 `);
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  const usdcAddr = status.contracts?.usdc;
-  if (!morphoCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Contracts not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const net = await provider.getNetwork();
-  const COLLATERAL_INFO = getCollateralInfo(Number(net.chainId));
-  const tokenInfo = COLLATERAL_INFO[tokenSymbol];
-  if (!tokenInfo) {
-    console.error(`\u274C Unsupported token: ${tokenSymbol}. Supported: ${Object.keys(COLLATERAL_INFO).join(", ")}`);
-    process.exit(1);
-  }
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const collateralWei = import_ethers2.ethers.parseUnits(amountStr, tokenInfo.decimals);
-  const borrowWei = import_ethers2.ethers.parseUnits(borrowUsd, 6);
-  const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-  const accountAddr = await factory.getAccount(config.agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.error("\u274C No AgentAccount. Create one first: agether wallet-create");
-    process.exit(1);
-  }
-  console.log(`   AgentAccount: ${accountAddr}`);
-  const token = new import_ethers2.ethers.Contract(tokenInfo.address, ERC20_ABI, signer);
-  const balance = await token.balanceOf(signer.address);
-  if (balance < collateralWei) {
-    console.error(`\u274C Insufficient ${tokenSymbol}: have ${import_ethers2.ethers.formatUnits(balance, tokenInfo.decimals)}, need ${amountStr}`);
-    process.exit(1);
-  }
   try {
-    console.log(`Step 1/4: Approving ${tokenSymbol}...`);
-    const approveTx = await token.approve(morphoCreditAddr, collateralWei);
-    await approveTx.wait();
-    console.log(`   \u2713 Approved`);
-    console.log(`Step 2/4: Depositing collateral...`);
-    const signer2 = getFreshSigner(config);
-    const morpho = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer2);
-    const depositTx = await morpho.depositCollateralFor(accountAddr, tokenInfo.address, collateralWei);
-    await depositTx.wait();
-    console.log(`   \u2713 Deposited`);
-    console.log(`Step 3/4: Approving credit provider...`);
-    const signer3 = getFreshSigner(config);
-    const account = new import_ethers2.ethers.Contract(accountAddr, [
-      ...AGENT_ACCOUNT_ABI,
-      "function approveCreditProvider(address creditProvider)"
-    ], signer3);
-    try {
-      const cpTx = await account.approveCreditProvider(morphoCreditAddr);
-      await cpTx.wait();
-      console.log(`   \u2713 Approved`);
-    } catch {
-      console.log(`   \u2713 Already approved`);
-    }
-    console.log(`Step 4/4: Borrowing $${borrowUsd} USDC...`);
-    const signer4 = getFreshSigner(config);
-    const account4 = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer4);
-    const morphoIface = new import_ethers2.ethers.Interface(MORPHO_CREDIT_ABI);
-    const borrowCalldata = morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-    const borrowTx = await account4.execute(morphoCreditAddr, 0, borrowCalldata);
-    await waitForTx(borrowTx);
-    const morphoView = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-    const pos = await morphoView.getPosition(accountAddr, tokenInfo.address);
-    const totalDebt = await morphoView.getTotalDebt(accountAddr);
-    const usdc = new import_ethers2.ethers.Contract(usdcAddr, ERC20_ABI, provider);
-    const accUsdcBal = await usdc.balanceOf(accountAddr);
-    console.log(`
-\u2705 Deposited ${amountStr} ${tokenSymbol} + Borrowed $${borrowUsd}`);
-    console.log(`   Deposit TX: ${depositTx.hash}`);
-    console.log(`   Borrow TX:  ${borrowTx.hash}`);
-    console.log(`   Collateral: ${import_ethers2.ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-    console.log(`   Total debt: $${import_ethers2.ethers.formatUnits(totalDebt, 6)}`);
-    console.log(`   AgentAccount USDC: $${import_ethers2.ethers.formatUnits(accUsdcBal, 6)}`);
-    console.log(`
-   USDC is in your AgentAccount \u2014 ready for x402 payments`);
+    const result = await mc.repay(amount, token);
+    console.log(`\u2705 Repaid $${amount}`);
+    console.log(`   Remaining debt: $${parseFloat(result.remainingDebt).toFixed(2)}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
 }
-async function cmdMorphoSponsor(amountStr, tokenSymbol, targetAgentId, targetAddress, borrowUsd) {
+async function cmdWithdraw(amount, token) {
   const config = requireConfig();
-  const targetDesc = targetAgentId ? `agent #${targetAgentId}` : targetAddress;
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F91D} Sponsoring ${targetDesc}: ${amountStr} ${tokenSymbol}${borrowUsd ? ` + borrow $${borrowUsd}` : ""}...
+\u{1F4E4} Withdrawing ${amount} ${token}...
 `);
-  if (!targetAgentId && !targetAddress) {
-    console.error("\u274C Provide --agent-id or --address");
-    process.exit(1);
-  }
-  const status = await apiGet(config.backendUrl, "/status");
-  const morphoCreditAddr = status.contracts?.morphoCredit;
-  const accountFactoryAddr = status.contracts?.accountFactory;
-  if (!morphoCreditAddr || !accountFactoryAddr) {
-    console.error("\u274C Contracts not deployed");
-    process.exit(1);
-  }
-  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-  const net = await provider.getNetwork();
-  const COLLATERAL_INFO = getCollateralInfo(Number(net.chainId));
-  const tokenInfo = COLLATERAL_INFO[tokenSymbol];
-  if (!tokenInfo) {
-    console.error(`\u274C Unsupported token: ${tokenSymbol}. Supported: ${Object.keys(COLLATERAL_INFO).join(", ")}`);
-    process.exit(1);
-  }
-  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
-  const collateralWei = import_ethers2.ethers.parseUnits(amountStr, tokenInfo.decimals);
-  let accountAddr;
-  if (targetAddress) {
-    accountAddr = targetAddress;
-  } else {
-    const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, signer);
-    accountAddr = await factory.getAccount(targetAgentId);
-    if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-      console.error(`\u274C No AgentAccount for agent #${targetAgentId}`);
-      process.exit(1);
-    }
-  }
-  console.log(`   Target AgentAccount: ${accountAddr}`);
-  const token = new import_ethers2.ethers.Contract(tokenInfo.address, ERC20_ABI, signer);
-  const balance = await token.balanceOf(signer.address);
-  if (balance < collateralWei) {
-    console.error(`\u274C Insufficient ${tokenSymbol}: have ${import_ethers2.ethers.formatUnits(balance, tokenInfo.decimals)}, need ${amountStr}`);
-    process.exit(1);
-  }
   try {
-    console.log(`Step 1/2: Approving + Depositing ${tokenSymbol} for target...`);
-    const approveTx = await token.approve(morphoCreditAddr, collateralWei);
-    await approveTx.wait();
-    const signer2 = getFreshSigner(config);
-    const morpho = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, signer2);
-    const depositTx = await morpho.depositCollateralFor(accountAddr, tokenInfo.address, collateralWei);
-    await depositTx.wait();
-    console.log(`   \u2713 Deposited ${amountStr} ${tokenSymbol} for ${targetDesc}`);
-    if (borrowUsd) {
-      console.log(`Step 2/2: Borrowing $${borrowUsd} for target...`);
-      const signer3 = getFreshSigner(config);
-      const account = new import_ethers2.ethers.Contract(accountAddr, [
-        ...AGENT_ACCOUNT_ABI,
-        "function approveCreditProvider(address creditProvider)"
-      ], signer3);
-      try {
-        const cpTx = await account.approveCreditProvider(morphoCreditAddr);
-        await cpTx.wait();
-      } catch {
-      }
-      const borrowWei = import_ethers2.ethers.parseUnits(borrowUsd, 6);
-      const signer4 = getFreshSigner(config);
-      const account4 = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer4);
-      const morphoIface = new import_ethers2.ethers.Interface(MORPHO_CREDIT_ABI);
-      const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
-      try {
-        const borrowTx = await account4.execute(morphoCreditAddr, 0, calldata);
-        await waitForTx(borrowTx);
-        console.log(`   \u2713 Borrowed $${borrowUsd} for target (TX: ${borrowTx.hash})`);
-      } catch (e) {
-        console.log(`   \u26A0 Borrow failed (you may not own this AgentAccount): ${decodeError(e)}`);
-      }
-    }
-    const morphoView = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-    const pos = await morphoView.getPosition(accountAddr, tokenInfo.address);
-    console.log(`
-\u2705 Sponsored ${targetDesc}`);
-    console.log(`   Deposit TX: ${depositTx.hash}`);
-    console.log(`   Collateral: ${import_ethers2.ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`);
-    console.log(`   Debt: $${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)}`);
+    const result = await mc.withdrawCollateral(token, amount);
+    console.log(`\u2705 Withdrew ${result.amount} ${token}`);
+    console.log(`   Remaining collateral: ${result.remainingCollateral}`);
+    console.log(`   Destination: ${result.destination}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
     console.error(`\u274C ${decodeError(e)}`);
   }
 }
-async function cmdMorphoStatus() {
-  const config = requireConfig();
-  console.log("\n\u{1F4CA} Morpho Credit Status\n");
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  try {
-    const status = await apiGet(config.backendUrl, "/status");
-    const morphoCreditAddr = status.contracts?.morphoCredit;
-    const accountFactoryAddr = status.contracts?.accountFactory;
-    if (!morphoCreditAddr || !accountFactoryAddr) {
-      console.error("\u274C Contracts not deployed");
-      process.exit(1);
-    }
-    const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-    const morphoCredit = new import_ethers2.ethers.Contract(morphoCreditAddr, MORPHO_CREDIT_ABI, provider);
-    const factory = new import_ethers2.ethers.Contract(accountFactoryAddr, ACCOUNT_FACTORY_ABI, provider);
-    const accountAddr = await factory.getAccount(config.agentId);
-    if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-      console.log("\u274C No AgentAccount. Create one: agether wallet-create");
-      return;
-    }
-    console.log(`   AgentAccount: ${accountAddr}
-`);
-    const COLLATERALS = getCollateralInfo(Number((await provider.getNetwork()).chainId));
-    let hasPositions = false;
-    for (const [symbol, info] of Object.entries(COLLATERALS)) {
-      const pos = await morphoCredit.getPosition(accountAddr, info.address);
-      if (pos.isActive || pos.collateralAmount > 0n) {
-        hasPositions = true;
-        console.log(`Position: ${symbol}`);
-        console.log(`   Collateral: ${import_ethers2.ethers.formatUnits(pos.collateralAmount, info.decimals)} ${symbol}`);
-        console.log(`   Borrowed:   $${import_ethers2.ethers.formatUnits(pos.borrowedAmount, 6)}`);
-        console.log(`   Status:     ${pos.isActive ? "\u2705 Active" : "\u274C Inactive"}`);
-        console.log("");
-      }
-    }
-    if (!hasPositions) {
-      console.log("No Morpho credit positions found.");
-      console.log("\nTo open one:");
-      console.log("   agether morpho-deposit --amount 0.1 --token WETH");
-    }
-  } catch (e) {
-    console.error(`\u274C Failed to fetch status: ${e.message}`);
-  }
-}
-async function cmdUnifiedStatus() {
-  const config = requireConfig();
-  console.log("\n\u{1F4CA} All Credit Lines (Unified View)\n");
-  if (config.agentId === "0") {
-    console.error("\u274C Register agent first: agether register");
-    process.exit(1);
-  }
-  try {
-    const data = await apiGet(config.backendUrl, `/morpho/unified/agent/${config.agentId}`);
-    if (data.creditLines.length === 0) {
-      console.log("No credit lines found.");
-      console.log("\nTo get credit:");
-      console.log("   agether apply --limit 5000           # Undercollateralized (80%)");
-      console.log("   agether morpho-open --collateral WETH  # Overcollateralized (120%)");
-      return;
-    }
-    console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-    console.log("\u2502  ID  \u2502  Type                   \u2502  Borrowed    \u2502  Available   \u2502  Health      \u2502");
-    console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-    for (const cl of data.creditLines) {
-      const id = cl.id.toString().padEnd(4);
-      const type = cl.creditType === "undercollateralized" ? "Undercollat (80%)".padEnd(21) : `Morpho ${cl.collateralSymbol} (120%)`.padEnd(21);
-      const borrowed = `$${(parseFloat(cl.borrowed) / 1e6).toFixed(2)}`.padEnd(10);
-      const available = `$${(parseFloat(cl.available) / 1e6).toFixed(2)}`.padEnd(10);
-      const health = cl.healthFactor === "Infinity" ? "\u221E" : parseFloat(cl.healthFactor).toFixed(2);
-      console.log(`\u2502  ${id}\u2502  ${type}\u2502  ${borrowed}  \u2502  ${available}  \u2502  ${health.padEnd(10)}  \u2502`);
-    }
-    console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-    console.log(`
-\u{1F4C8} Summary:`);
-    console.log(`   Total Borrowed:   $${(parseFloat(data.summary.totalBorrowed) / 1e6).toFixed(2)}`);
-    console.log(`   Total Available:  $${(parseFloat(data.summary.totalAvailable) / 1e6).toFixed(2)}`);
-    console.log(`   Total Collateral: $${(parseFloat(data.summary.totalCollateralUsd) / 1e6).toFixed(2)}`);
-  } catch (e) {
-    console.error(`\u274C Failed to fetch status: ${e.message}`);
-  }
-}
-async function cmdWalletCreate() {
-  const config = requireConfig();
-  const signer = getSigner(config);
-  console.log("\n\u{1F4BC} Creating Agent Account\n");
-  let status;
-  try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.accountFactory) {
-      console.error("\u274C Backend not configured with accountFactory");
-      process.exit(1);
-    }
-  } catch (e) {
-    console.error(`\u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const factory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    signer
-  );
-  const agentId = BigInt(config.agentId);
-  const exists = await factory.accountExists(agentId);
-  if (exists) {
-    const accountAddr2 = await factory.getAccount(agentId);
-    console.log(`\u2713 Account already exists: ${accountAddr2}`);
-    return;
-  }
-  console.log(`   Agent ID: ${agentId}`);
-  console.log(`   Factory:  ${status.contracts.accountFactory}`);
-  console.log("   Creating account...");
-  const tx = await factory.createAccount(agentId);
-  console.log(`   TX: ${tx.hash}`);
-  const receipt = await tx.wait();
-  console.log(`   \u2713 Confirmed in block ${receipt.blockNumber}`);
-  const accountAddr = await factory.getAccount(agentId);
-  console.log(`
-\u2705 Account created: ${accountAddr}`);
-  console.log("\nNext steps:");
-  console.log("  1. Fund the account:  agether wallet-fund --amount 1000");
-  console.log("  2. Draw credit:       agether wallet-draw --amount 500");
-  console.log("  3. Check status:      agether wallet-status");
-}
-async function cmdWalletStatus() {
+async function cmdSponsor(amount, token, agentId, address) {
   const config = requireConfig();
-  const signer = getSigner(config);
-  console.log("\n\u{1F4BC} Agent Account Status\n");
-  let status;
-  try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.accountFactory) {
-      console.error("\u274C Backend not configured with accountFactory");
-      process.exit(1);
-    }
-  } catch (e) {
-    console.error(`\u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const factory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    signer
-  );
-  const agentId = BigInt(config.agentId);
-  const exists = await factory.accountExists(agentId);
-  if (!exists) {
-    console.log("\u274C No account found for this agent");
-    console.log("   Create one with: agether wallet-create");
-    return;
-  }
-  const accountAddr = await factory.getAccount(agentId);
-  const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-  const usdcAddr = status.contracts.usdc;
-  const usdc = new import_ethers2.ethers.Contract(usdcAddr, ERC20_ABI, signer);
-  const [owner, usdcBalance, ethBal] = await Promise.all([
-    account.owner(),
-    usdc.balanceOf(accountAddr),
-    signer.provider.getBalance(accountAddr)
-  ]);
-  console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
-  console.log(`\u2502  Account:  ${accountAddr.slice(0, 20)}...  \u2502`);
-  console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
-  console.log(`\u2502  Agent ID:           ${config.agentId.padStart(10)}`);
-  console.log(`\u2502  Owner:              ${owner.slice(0, 20)}...`);
-  console.log(`\u2502  ETH Balance:        ${import_ethers2.ethers.formatEther(ethBal).padStart(10)} ETH`);
-  console.log(`\u2502  USDC Balance:       $${import_ethers2.ethers.formatUnits(usdcBalance, 6).padStart(10)}`);
-  console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-}
-async function cmdWalletDraw(amount) {
-  const config = requireConfig();
-  const signer = getSigner(config);
+  const mc = await getMorphoClient(config);
+  const target = agentId ? { agentId } : { address };
   console.log(`
-\u{1F4B8} Drawing $${amount} from Credit Line via AgentAccount
+\u{1F381} Sponsoring ${amount} ${token} to ${agentId || address}...
 `);
-  let status;
   try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.accountFactory) {
-      console.error("\u274C Backend not configured with accountFactory");
-      process.exit(1);
-    }
+    const result = await mc.sponsor(target, token, amount);
+    console.log(`\u2705 Sponsored ${amount} ${token}`);
+    console.log(`   Target: ${result.targetAccount}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
-    console.error(`\u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const factory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    signer
-  );
-  const agentId = BigInt(config.agentId);
-  const accountAddr = await factory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.log("\u274C No account found. Create one first: agether wallet-create");
-    return;
-  }
-  const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-  const amountWei = import_ethers2.ethers.parseUnits(amount.toString(), 6);
-  const creditProvider = status.contracts.reputationCredit;
-  console.log(`   Account: ${accountAddr}`);
-  console.log(`   Amount:  $${amount} USDC`);
-  console.log("   Drawing from credit line...");
-  const tx = await account.drawCredit(creditProvider, amountWei);
-  console.log(`   TX: ${tx.hash}`);
-  const receipt = await tx.wait();
-  console.log(`   \u2713 Confirmed in block ${receipt.blockNumber}`);
-  const usdc = new import_ethers2.ethers.Contract(status.contracts.usdc, ERC20_ABI, signer);
-  const newBalance = await usdc.balanceOf(accountAddr);
-  console.log(`
-\u2705 Drew $${amount}. Account USDC balance: $${import_ethers2.ethers.formatUnits(newBalance, 6)}`);
-}
-async function cmdWalletRepay(amount) {
-  const config = requireConfig();
-  const signer = getSigner(config);
-  console.log(`
-\u{1F4B0} Repaying $${amount} to Credit Line from AgentAccount
-`);
-  let status;
-  try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.accountFactory) {
-      console.error("\u274C Backend not configured with accountFactory");
-      process.exit(1);
-    }
-  } catch (e) {
-    console.error(`\u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const factory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    signer
-  );
-  const agentId = BigInt(config.agentId);
-  const accountAddr = await factory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.log("\u274C No account found. Create one first: agether wallet-create");
-    return;
+    console.error(`\u274C ${decodeError(e)}`);
   }
-  const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, signer);
-  const amountWei = import_ethers2.ethers.parseUnits(amount.toString(), 6);
-  const creditProvider = status.contracts.reputationCredit;
-  console.log(`   Account: ${accountAddr}`);
-  console.log(`   Amount:  $${amount} USDC`);
-  console.log("   Repaying to credit line...");
-  const tx = await account.repayCredit(creditProvider, amountWei);
-  console.log(`   TX: ${tx.hash}`);
-  const receipt = await tx.wait();
-  console.log(`   \u2713 Confirmed in block ${receipt.blockNumber}`);
-  console.log(`
-\u2705 Repaid $${amount}.`);
 }
-async function cmdWalletFund(amount) {
+async function cmdFund(amount) {
   const config = requireConfig();
-  const signer = getSigner(config);
+  const mc = await getMorphoClient(config);
   console.log(`
-\u{1F4B5} Funding Account with $${amount} USDC
+\u{1F4B5} Funding AgentAccount with $${amount} USDC...
 `);
-  let status;
   try {
-    status = await apiGet(config.backendUrl, "/status");
-    if (!status.contracts?.accountFactory || !status.contracts?.usdc) {
-      console.error("\u274C Backend not configured with required contracts");
-      process.exit(1);
-    }
+    const result = await mc.fundAccount(amount);
+    console.log(`\u2705 Funded $${amount} USDC`);
+    console.log(`   AgentAccount: ${result.agentAccount}`);
+    console.log(`   TX: ${result.tx}`);
   } catch (e) {
-    console.error(`\u274C Failed to reach backend: ${e.message}`);
-    process.exit(1);
-  }
-  const factory = new import_ethers2.ethers.Contract(
-    status.contracts.accountFactory,
-    ACCOUNT_FACTORY_ABI,
-    signer
-  );
-  const agentId = BigInt(config.agentId);
-  const accountAddr = await factory.getAccount(agentId);
-  if (accountAddr === import_ethers2.ethers.ZeroAddress) {
-    console.log("\u274C No account found. Create one first: agether wallet-create");
-    return;
+    console.error(`\u274C ${decodeError(e)}`);
   }
-  const usdc = new import_ethers2.ethers.Contract(status.contracts.usdc, ERC20_ABI, signer);
-  const amountWei = import_ethers2.ethers.parseUnits(amount.toString(), 6);
-  console.log(`   From:    ${signer.address}`);
-  console.log(`   To:      ${accountAddr}`);
-  console.log(`   Amount:  $${amount} USDC`);
-  console.log("   Approving USDC...");
-  const approveTx = await usdc.approve(accountAddr, amountWei);
-  await approveTx.wait();
-  const freshSigner = getFreshSigner(config);
-  const account = new import_ethers2.ethers.Contract(accountAddr, AGENT_ACCOUNT_ABI, freshSigner);
-  console.log("   Funding account...");
-  const tx = await account.fund(status.contracts.usdc, amountWei);
-  console.log(`   TX: ${tx.hash}`);
-  const receipt = await tx.wait();
-  console.log(`   \u2713 Confirmed in block ${receipt.blockNumber}`);
-  const usdcContract = new import_ethers2.ethers.Contract(status.contracts.usdc, ERC20_ABI, signer);
-  const newBalance = await usdcContract.balanceOf(accountAddr);
-  console.log(`
-\u2705 Funded. Account USDC balance: $${import_ethers2.ethers.formatUnits(newBalance, 6)}`);
 }
-async function cmdX402Call(url, method = "GET", body, autoDraw = false) {
+async function cmdX402Call(url, method = "GET", body) {
   const config = requireConfig();
   console.log("\n\u{1F510} x402 Paid API Call\n");
-  if (autoDraw) console.log("   \u26A1 Auto-draw enabled: will borrow from Morpho if USDC insufficient");
-  let accountAddress;
-  let morphoCreditAddress;
-  try {
-    const status = await apiGet(config.backendUrl, "/status");
-    const factoryAddr = status.contracts?.accountFactory;
-    morphoCreditAddress = status.contracts?.morphoCredit;
-    if (factoryAddr && config.agentId) {
-      const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
-      const factory = new import_ethers2.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI, provider);
-      const addr = await factory.getAccount(config.agentId);
-      if (addr !== import_ethers2.ethers.ZeroAddress) {
-        accountAddress = addr;
-        console.log(`   AgentAccount: ${addr}`);
-      }
-    }
-  } catch {
-  }
-  const { X402Client: X402Client2 } = await Promise.resolve().then(() => (init_X402Client(), X402Client_exports));
-  const client = new X402Client2({
-    privateKey: config.privateKey,
-    rpcUrl: config.rpcUrl,
-    backendUrl: config.backendUrl,
-    agentId: config.agentId,
-    accountAddress,
-    autoDraw,
-    morphoCreditAddress
-  });
-  console.log(`   Wallet:       ${new import_ethers2.ethers.Wallet(config.privateKey).address}`);
+  const x402 = await getX402Client(config);
+  console.log(`   Wallet: ${new import_ethers3.ethers.Wallet(config.privateKey).address}`);
   console.log(`
-\u{1F4E1} Calling: ${method} ${url}`);
-  if (body) {
-    console.log(`\u{1F4E6} Body: ${body}`);
-  }
+\u{1F4E1} ${method} ${url}`);
+  if (body) console.log(`\u{1F4E6} Body: ${body}`);
   try {
     let result;
     if (method === "POST" && body) {
-      result = await client.post(url, JSON.parse(body));
+      result = await x402.post(url, JSON.parse(body));
     } else {
-      result = await client.get(url);
+      result = await x402.get(url);
     }
     if (result.success) {
       console.log("\n\u2705 Success!");
       if (result.paymentInfo) {
         console.log(`\u{1F4B0} Paid: ${result.paymentInfo.amount} ${result.paymentInfo.asset} on ${result.paymentInfo.network}`);
-        if (result.paymentInfo.txHash) {
-          console.log(`\u{1F4DC} TX: ${result.paymentInfo.txHash}`);
-        }
+        if (result.paymentInfo.txHash) console.log(`\u{1F4DC} TX: ${result.paymentInfo.txHash}`);
       }
       console.log("\n\u{1F4C4} Response:");
       console.log(JSON.stringify(result.data, null, 2));
@@ -2136,88 +1590,46 @@ async function cmdX402Call(url, method = "GET", body, autoDraw = false) {
 }
 function cmdHelp() {
   console.log(`
-\u{1F3E6} Agether CLI \u2014 On-Chain Credit for AI Agents
+\u{1F3E6} Agether CLI \u2014 Direct Morpho Blue Credit for AI Agents
 
 USAGE:
   agether <command> [options]
 
-COMMANDS (Undercollateralized - 80% collateral, reputation-based):
+SETUP:
   init <private-key> [--agent-id <id>]    Initialize with private key
-  register [--name <n>] [--code-url <u>]  Register on ERC-8004 + code audit
-  apply --limit <usd>                     Apply for credit line (needs scoring)
-  collateral --amount <usd>               Deposit USDC collateral
-  draw --amount <usd>                     Draw funds (daily limits apply)
-  repay --amount <usd>                    Repay debt
-  status                                  Show credit line status
-  score                                   Show credit score
-  balance                                 Show ETH + USDC balances
+  register [--name <n>]                   Register ERC-8004 + create AgentAccount
 
-COMMANDS (Morpho - 120% collateral, instant approval):
-  morpho-compare --amount <usd>           Compare both credit options (checks balances!)
-  morpho-balances                         Show all token balances & available credit
-  morpho-markets                          List supported Morpho markets
-  morpho-open --collateral <token>        Open Morpho credit line (WETH/wstETH/WBTC)
-  morpho-deposit --amount <n> --token <t> Deposit collateral (e.g. 0.5 WETH)
-  morpho-deposit-and-borrow --amount <n> --token <t> --borrow <usd>  Deposit + borrow in one go
-  morpho-borrow --amount <usd>            Borrow USDC against collateral
-  morpho-repay --amount <usd>             Repay borrowed USDC
-  morpho-withdraw --amount <n> --token <t> Withdraw collateral to EOA (e.g. 0.05 WETH or "all")
-  morpho-sponsor --amount <n> --token <t> --agent-id <id> [--borrow <usd>]  Sponsor another agent
-  morpho-sponsor --amount <n> --token <t> --address <addr> [--borrow <usd>]  Sponsor by address
-  morpho-status                           Show Morpho credit lines
-  unified-status                          Show ALL credit lines (both types)
+INFO:
+  balance                                 Check ETH + USDC balances
+  status                                  Show Morpho positions & credit score
+  score                                   Get credit score
+  markets                                 List Morpho Blue USDC markets
 
-COMMANDS (Agent Wallet - Per-agent execution wallet):
-  wallet-create                           Create isolated wallet for your agent
-  wallet-status                           Show wallet status & balances
-  wallet-fund --amount <usd>              Fund wallet with USDC
-  wallet-draw --amount <usd>              Draw from credit line into wallet
-  wallet-repay --amount <usd>             Repay credit line from wallet
+MORPHO LENDING:
+  deposit --amount <n> --token <t>        Deposit collateral (WETH, wstETH, cbETH)
+  borrow --amount <usd> [--token <t>]     Borrow USDC against collateral
+  deposit-and-borrow --amount <n> --token <t> --borrow <usd>
+                                          Deposit + borrow in one batched tx
+  repay --amount <usd> [--token <t>]      Repay borrowed USDC
+  withdraw --amount <n> --token <t>       Withdraw collateral (use 'all' for max)
+  sponsor --amount <n> --token <t> --agent-id <id>   Send collateral to another agent
+  fund --amount <usd>                     Transfer USDC from EOA to AgentAccount
 
-COMMANDS (x402 - Paid API Calls):
-  x402 <url> [--method GET|POST] [--body <json>] [--auto-draw]   Make a paid API call using credit
+x402 PAYMENTS:
+  x402 <url> [--method GET|POST] [--body <json>]   Make a paid API call
 
 ENVIRONMENT:
-  AGETHER_RPC_URL       RPC endpoint (default: https://mainnet.base.org)
-  AGETHER_BACKEND_URL   Backend URL (default: http://95.179.189.214:3001)
-
-COMPARISON:
-  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
-  \u2502  UNDERCOLLATERALIZED  \u2502  MORPHO-BACKED                          \u2502
-  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524
-  \u2502  80% collateral       \u2502  120% collateral                        \u2502
-  \u2502  Requires scoring     \u2502  Instant approval                       \u2502
-  \u2502  Daily limits         \u2502  No limits                              \u2502
-  \u2502  ~12% APR             \u2502  ~5% APR                                \u2502
-  \u2502  Builds reputation    \u2502  No reputation                          \u2502
-  \u2502  Can graduate to 0%   \u2502  Collateral always required             \u2502
-  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
-
-EXAMPLE FLOWS:
+  AGETHER_RPC_URL       RPC endpoint (default: ${DEFAULT_RPC})
+  AGETHER_BACKEND_URL   Backend URL (default: ${DEFAULT_BACKEND})
 
-  Undercollateralized (recommended for agents building reputation):
-    agether init 0xYOUR_PRIVATE_KEY
-    agether register --name "MyAgent"
-    agether apply --limit 5000          # Wait for approval
-    agether collateral --amount 4000    # 80% of limit
-    agether draw --amount 1000
-    agether repay --amount 500
-
-  Morpho-backed (instant, for new agents or large amounts):
-    agether init 0xYOUR_PRIVATE_KEY
-    agether register --name "MyAgent"
-    agether morpho-open --collateral WETH
-    agether morpho-deposit --amount 0.01 --token WETH   # ~$25 collateral
-    agether morpho-borrow --amount 10                    # Borrow $10 USDC
-    agether morpho-repay --amount 10                     # Repay when done
-
-  Agent Wallet (isolated execution wallet with x402 support):
-    agether init 0xYOUR_PRIVATE_KEY
-    agether register --name "MyAgent"
-    agether wallet-create               # Deploy isolated wallet
-    agether wallet-fund --amount 100    # Pre-fund wallet
-    agether wallet-draw --amount 500    # Draw from credit line
-    agether wallet-status               # Check balances
+EXAMPLE FLOW:
+  agether init 0xYOUR_PRIVATE_KEY
+  agether register --name "MyAgent"
+  agether deposit --amount 0.05 --token WETH       # ~$125 collateral
+  agether borrow --amount 50                        # Borrow $50 USDC
+  agether status                                    # Check positions
+  agether repay --amount 50                         # Repay when done
+  agether withdraw --amount all --token WETH        # Withdraw collateral
 `);
 }
 function parseArgs(args) {
@@ -2253,35 +1665,10 @@ async function main() {
         await cmdInit(positional[0], options["agent-id"]);
         break;
       case "register":
-        await cmdRegister(options.name, options["code-url"]);
+        await cmdRegister(options.name);
         break;
-      case "apply":
-        if (!options.limit) {
-          console.error("\u274C --limit required");
-          process.exit(1);
-        }
-        await cmdApply(parseFloat(options.limit));
-        break;
-      case "draw":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
-          process.exit(1);
-        }
-        await cmdDraw(parseFloat(options.amount));
-        break;
-      case "repay":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
-          process.exit(1);
-        }
-        await cmdRepay(parseFloat(options.amount));
-        break;
-      case "collateral":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
-          process.exit(1);
-        }
-        await cmdCollateral(parseFloat(options.amount));
+      case "balance":
+        await cmdBalance();
         break;
       case "status":
         await cmdStatus();
@@ -2289,94 +1676,75 @@ async function main() {
       case "score":
         await cmdScore();
         break;
-      case "balance":
-        await cmdBalance();
-        break;
-      case "morpho-compare":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
-          process.exit(1);
-        }
-        await cmdMorphoCompare(parseFloat(options.amount));
-        break;
-      case "morpho-balances":
-        await cmdMorphoBalances();
-        break;
-      case "morpho-markets":
-        await cmdMorphoMarkets();
-        break;
-      case "morpho-open":
-        if (!options.collateral) {
-          console.error("\u274C --collateral required (WETH, wstETH, or WBTC)");
-          process.exit(1);
-        }
-        await cmdMorphoOpen(options.collateral);
+      case "markets":
+        await cmdMarkets();
         break;
-      case "morpho-deposit":
+      case "deposit":
         if (!options.amount || !options.token) {
           console.error("\u274C --amount and --token required");
-          console.error("   agether morpho-deposit --amount 0.5 --token WETH");
+          console.error("   agether deposit --amount 0.05 --token WETH");
           process.exit(1);
         }
-        await cmdMorphoDeposit(options.amount, options.token);
+        await cmdDeposit(options.amount, options.token);
         break;
-      case "morpho-borrow":
+      case "borrow":
         if (!options.amount) {
           console.error("\u274C --amount required (in USD)");
-          console.error("   agether morpho-borrow --amount 100");
+          console.error("   agether borrow --amount 100");
           process.exit(1);
         }
-        await cmdMorphoBorrow(options.amount);
+        await cmdBorrow(options.amount, options.token);
         break;
-      case "morpho-repay":
+      case "deposit-and-borrow":
+        if (!options.amount || !options.token || !options.borrow) {
+          console.error("\u274C --amount, --token, and --borrow required");
+          console.error("   agether deposit-and-borrow --amount 0.05 --token WETH --borrow 100");
+          process.exit(1);
+        }
+        await cmdDepositAndBorrow(
+          options.amount,
+          options.token,
+          options.borrow
+        );
+        break;
+      case "repay":
         if (!options.amount) {
-          console.error("\u274C --amount required (in USD)");
-          console.error("   agether morpho-repay --amount 50");
+          console.error("\u274C --amount required");
           process.exit(1);
         }
-        await cmdMorphoRepay(options.amount);
+        await cmdRepay(options.amount, options.token);
         break;
-      case "morpho-withdraw":
+      case "withdraw":
         if (!options.amount || !options.token) {
           console.error("\u274C --amount and --token required");
-          console.error("   agether morpho-withdraw --amount 0.05 --token WETH");
-          console.error("   agether morpho-withdraw --amount all --token WETH");
+          console.error("   agether withdraw --amount 0.05 --token WETH");
+          console.error("   agether withdraw --amount all --token WETH");
           process.exit(1);
         }
-        await cmdMorphoWithdraw(options.amount, options.token);
-        break;
-      case "morpho-status":
-        await cmdMorphoStatus();
-        break;
-      case "unified-status":
-        await cmdUnifiedStatus();
+        await cmdWithdraw(options.amount, options.token);
         break;
-      case "wallet-create":
-        await cmdWalletCreate();
-        break;
-      case "wallet-status":
-        await cmdWalletStatus();
-        break;
-      case "wallet-draw":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
+      case "sponsor":
+        if (!options.amount || !options.token) {
+          console.error("\u274C --amount and --token required, plus --agent-id or --address");
           process.exit(1);
         }
-        await cmdWalletDraw(parseFloat(options.amount));
-        break;
-      case "wallet-repay":
-        if (!options.amount) {
-          console.error("\u274C --amount required");
+        if (!options["agent-id"] && !options.address) {
+          console.error("\u274C --agent-id or --address required");
           process.exit(1);
         }
-        await cmdWalletRepay(parseFloat(options.amount));
+        await cmdSponsor(
+          options.amount,
+          options.token,
+          options["agent-id"],
+          options.address
+        );
         break;
-      case "wallet-fund":
+      case "fund":
         if (!options.amount) {
-          console.error("\u274C --amount required");
+          console.error("\u274C --amount required (USDC)");
           process.exit(1);
         }
-        await cmdWalletFund(parseFloat(options.amount));
+        await cmdFund(options.amount);
         break;
       case "x402":
         if (!positional[0]) {
@@ -2386,39 +1754,7 @@ async function main() {
         await cmdX402Call(
           positional[0],
           options.method || "GET",
-          options.body,
-          !!options["auto-draw"]
-        );
-        break;
-      case "morpho-deposit-and-borrow":
-        if (!options.amount || !options.token || !options.borrow) {
-          console.error("\u274C --amount, --token, and --borrow required");
-          console.error("   agether morpho-deposit-and-borrow --amount 0.01 --token WETH --borrow 10");
-          process.exit(1);
-        }
-        await cmdMorphoDepositAndBorrow(
-          options.amount,
-          options.token,
-          options.borrow
-        );
-        break;
-      case "morpho-sponsor":
-        if (!options.amount || !options.token) {
-          console.error("\u274C --amount and --token required, plus --agent-id or --address");
-          console.error("   agether morpho-sponsor --amount 0.01 --token WETH --agent-id 17676");
-          console.error("   agether morpho-sponsor --amount 0.01 --token WETH --address 0x... --borrow 50");
-          process.exit(1);
-        }
-        if (!options["agent-id"] && !options.address) {
-          console.error("\u274C --agent-id or --address required");
-          process.exit(1);
-        }
-        await cmdMorphoSponsor(
-          options.amount,
-          options.token,
-          options["agent-id"],
-          options.address,
-          options.borrow
+          options.body
         );
         break;
       case "help":