@agether/sdk 1.11.1 → 2.0.0

package/dist/cli.js

@@ -0,0 +1,2375 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  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, SAFE_AGENT_FACTORY_ABI, ACCOUNT_FACTORY_ABI, ERC8004_VALIDATION_MODULE_ABI, AGENT_REPUTATION_ABI, MORPHO_BLUE_ABI, ERC20_ABI, ENTRYPOINT_V07_ABI, SAFE7579_ACCOUNT_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)"
+    ];
+    SAFE_AGENT_FACTORY_ABI = [
+      "function getAccount(uint256 agentId) view returns (address)",
+      "function accountExists(uint256 agentId) view returns (bool)",
+      "function totalAccounts() view returns (uint256)",
+      "function getAgentId(address account) view returns (uint256)",
+      "function getAgentIdByIndex(uint256 index) view returns (uint256)",
+      "function getAllAgentIds() view returns (uint256[])",
+      "function createAccount(uint256 agentId) returns (address safeAccount)",
+      "function identityRegistry() view returns (address)",
+      "function validationModule() view returns (address)",
+      "function hookMultiplexer() view returns (address)",
+      "function safeSingleton() view returns (address)",
+      "function safe7579() view returns (address)",
+      "function bootstrap() view returns (address)",
+      "function SENTINEL_OWNER() view returns (address)",
+      "event AccountCreated(uint256 indexed agentId, address indexed safeAccount, address indexed owner)"
+    ];
+    ACCOUNT_FACTORY_ABI = SAFE_AGENT_FACTORY_ABI;
+    ERC8004_VALIDATION_MODULE_ABI = [
+      // View
+      "function getConfig(address account) view returns (address registry, uint256 agentId)",
+      "function getOwner(address account) view returns (address)",
+      "function isInstalled(address account) view returns (bool)",
+      "function isKYAApproved(address account) view returns (bool)",
+      "function validationRegistry() view returns (address)",
+      "function owner() view returns (address)",
+      // Admin (via TimelockController)
+      "function setValidationRegistry(address registry_)"
+    ];
+    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)"
+    ];
+    ENTRYPOINT_V07_ABI = [
+      "function handleOps(tuple(address sender, uint256 nonce, bytes initCode, bytes callData, bytes32 accountGasLimits, uint256 preVerificationGas, bytes32 gasFees, bytes paymasterAndData, bytes signature)[] ops, address payable beneficiary)",
+      "function getUserOpHash(tuple(address sender, uint256 nonce, bytes initCode, bytes callData, bytes32 accountGasLimits, uint256 preVerificationGas, bytes32 gasFees, bytes paymasterAndData, bytes signature) userOp) view returns (bytes32)",
+      "function getNonce(address sender, uint192 key) view returns (uint256 nonce)",
+      "function balanceOf(address account) view returns (uint256)",
+      "function depositTo(address account) payable",
+      "event UserOperationEvent(bytes32 indexed userOpHash, address indexed sender, address indexed paymaster, uint256 nonce, bool success, uint256 actualGasCost, uint256 actualGasUsed)"
+    ];
+    SAFE7579_ACCOUNT_ABI = [
+      // ERC-7579 execution (called via UserOp through Safe7579 fallback)
+      "function execute(bytes32 mode, bytes executionCalldata) payable",
+      "function executeFromExecutor(bytes32 mode, bytes executionCalldata) payable returns (bytes[])",
+      // ERC-7579 module queries
+      "function isModuleInstalled(uint256 moduleTypeId, address module, bytes additionalContext) view returns (bool)",
+      // EIP-1271
+      "function isValidSignature(bytes32 hash, bytes signature) view returns (bytes4)"
+    ];
+  }
+});
+
+// src/utils/config.ts
+function getDefaultConfig(chainId) {
+  return {
+    chainId,
+    rpcUrl: RPC_URLS[chainId],
+    contracts: CONTRACT_ADDRESSES[chainId],
+    scoringEndpoint: SCORING_ENDPOINTS[chainId]
+  };
+}
+var ZERO, ENTRYPOINT_V07, ERC8004_IDENTITY_REGISTRY, ERC8004_IDENTITY_REGISTRY_TESTNET, MORPHO_BLUE, SAFE_SINGLETON, SAFE_PROXY_FACTORY, SAFE7579, CONTRACT_ADDRESSES, RPC_URLS, SCORING_ENDPOINTS;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    "use strict";
+    init_types();
+    ZERO = "0x0000000000000000000000000000000000000000";
+    ENTRYPOINT_V07 = "0x0000000071727De22E5E9d8BAf0edAc6f37da032";
+    ERC8004_IDENTITY_REGISTRY = "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432";
+    ERC8004_IDENTITY_REGISTRY_TESTNET = "0x8004A818BFB912233c491871b3d84c89A494BD9e";
+    MORPHO_BLUE = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
+    SAFE_SINGLETON = "0x41675C099F32341bf84BFc5382aF534df5C7461a";
+    SAFE_PROXY_FACTORY = "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67";
+    SAFE7579 = "0x7579EE8307284F293B1927136486880611F20002";
+    CONTRACT_ADDRESSES = {
+      [1 /* Ethereum */]: {
+        safeSingleton: SAFE_SINGLETON,
+        safeProxyFactory: SAFE_PROXY_FACTORY,
+        safe7579: SAFE7579,
+        entryPoint: ENTRYPOINT_V07,
+        safeAgentFactory: ZERO,
+        safe7579Bootstrap: ZERO,
+        erc8004ValidationModule: ZERO,
+        hookMultiplexer: ZERO,
+        validationRegistry: ZERO,
+        agentReputation: ZERO,
+        timelockController: ZERO,
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        identityRegistry: ERC8004_IDENTITY_REGISTRY,
+        morphoBlue: MORPHO_BLUE
+      },
+      [8453 /* Base */]: {
+        safeSingleton: SAFE_SINGLETON,
+        safeProxyFactory: SAFE_PROXY_FACTORY,
+        safe7579: SAFE7579,
+        entryPoint: ENTRYPOINT_V07,
+        safeAgentFactory: "0xB0A88ffe28491E793F7706829278f20d724947d1",
+        safe7579Bootstrap: "0x72A636bc23B2644138489c3bBE3B05a0a7184b33",
+        erc8004ValidationModule: "0x49e27A6B4d012B87271897b51d0296ABcFCb0BBd",
+        hookMultiplexer: "0x12c77f17F91f06a11C2C34C618ce9d78f9a34541",
+        validationRegistry: "0x88E21e8883c093E4c8d0d0cE68f1c93Cf6190f51",
+        agentReputation: "0x4C2d42cbD35f6541f0902499CFEC27C1Cf5683E3",
+        timelockController: "0x0517b4f73b61774C88A2B1c5745141315E831015",
+        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        identityRegistry: ERC8004_IDENTITY_REGISTRY,
+        morphoBlue: MORPHO_BLUE
+      },
+      [84532 /* BaseSepolia */]: {
+        safeSingleton: SAFE_SINGLETON,
+        safeProxyFactory: SAFE_PROXY_FACTORY,
+        safe7579: SAFE7579,
+        entryPoint: ENTRYPOINT_V07,
+        safeAgentFactory: ZERO,
+        safe7579Bootstrap: ZERO,
+        erc8004ValidationModule: ZERO,
+        hookMultiplexer: ZERO,
+        validationRegistry: ZERO,
+        agentReputation: ZERO,
+        timelockController: ZERO,
+        usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        identityRegistry: ERC8004_IDENTITY_REGISTRY_TESTNET,
+        morphoBlue: ZERO
+      },
+      [11155111 /* Sepolia */]: {
+        safeSingleton: SAFE_SINGLETON,
+        safeProxyFactory: SAFE_PROXY_FACTORY,
+        safe7579: SAFE7579,
+        entryPoint: ENTRYPOINT_V07,
+        safeAgentFactory: ZERO,
+        safe7579Bootstrap: ZERO,
+        erc8004ValidationModule: ZERO,
+        hookMultiplexer: ZERO,
+        validationRegistry: ZERO,
+        agentReputation: ZERO,
+        timelockController: ZERO,
+        usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+        identityRegistry: ERC8004_IDENTITY_REGISTRY_TESTNET,
+        morphoBlue: ZERO
+      },
+      [31337 /* Hardhat */]: {
+        safeSingleton: SAFE_SINGLETON,
+        safeProxyFactory: SAFE_PROXY_FACTORY,
+        safe7579: SAFE7579,
+        entryPoint: ENTRYPOINT_V07,
+        safeAgentFactory: ZERO,
+        safe7579Bootstrap: ZERO,
+        erc8004ValidationModule: ZERO,
+        hookMultiplexer: ZERO,
+        validationRegistry: ZERO,
+        agentReputation: ZERO,
+        timelockController: ZERO,
+        usdc: "0x56d4d6aEe0278c5Df2FA23Ecb32eC146C9446FDf",
+        identityRegistry: ERC8004_IDENTITY_REGISTRY,
+        morphoBlue: ZERO
+      }
+    };
+    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, MODE_SINGLE, MODE_BATCH, 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";
+    MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
+    MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
+    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._rpcUrl = config.rpcUrl || defaultCfg.rpcUrl;
+        if ("signer" in config && config.signer) {
+          this._useExternalSigner = true;
+          const signerProvider = config.signer.provider;
+          if (signerProvider) {
+            this.provider = signerProvider;
+            this._signer = config.signer;
+          } else {
+            this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
+            this._signer = config.signer.connect(this.provider);
+          }
+          if ("address" in config.signer && typeof config.signer.address === "string") {
+            this._eoaAddress = config.signer.address;
+          }
+        } else {
+          this._privateKey = config.privateKey;
+          this._useExternalSigner = false;
+          this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
+          const wallet = new import_ethers.ethers.Wallet(this._privateKey, this.provider);
+          this._signer = wallet;
+          this._eoaAddress = wallet.address;
+        }
+        const addrs = { ...defaultCfg.contracts, ...config.contracts };
+        this.safeAgentFactory = new import_ethers.Contract(addrs.safeAgentFactory, ACCOUNT_FACTORY_ABI, this._signer);
+        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._signer);
+        this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
+        this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
+        this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
+      }
+      // ════════════════════════════════════════════════════════
+      //  KYA Gate Check
+      // ════════════════════════════════════════════════════════
+      /**
+       * Check whether the KYA (Know Your Agent) code verification gate is active.
+       * Reads the ERC8004ValidationModule's validationRegistry — when set to
+       * a non-zero address, the module enforces KYA code approval.
+       */
+      async isKyaRequired() {
+        try {
+          const registryAddr = await this.validationModule.validationRegistry();
+          return registryAddr !== import_ethers.ethers.ZeroAddress;
+        } catch {
+          return false;
+        }
+      }
+      // ════════════════════════════════════════════════════════
+      //  Account Management
+      // ════════════════════════════════════════════════════════
+      /** Resolve the AgentAccount address (cached, with retry for flaky RPCs). */
+      async getAccountAddress() {
+        if (this._accountAddress) return this._accountAddress;
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        const MAX_RETRIES = 3;
+        let lastErr;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            const addr = await this.safeAgentFactory.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;
+          } catch (err) {
+            if (err instanceof AgetherError) throw err;
+            lastErr = err;
+            if (attempt < MAX_RETRIES) {
+              await new Promise((r) => setTimeout(r, 500 * attempt));
+            }
+          }
+        }
+        throw lastErr;
+      }
+      getAgentId() {
+        if (!this.agentId) throw new AgetherError("agentId not set", "NO_AGENT_ID");
+        return this.agentId;
+      }
+      /**
+       * Get the EOA wallet address (synchronous, best-effort).
+       *
+       * For the `privateKey` path this always works. For the `signer` path
+       * it works if the signer exposes `.address` synchronously (e.g. ethers.Wallet).
+       * If the address has not been resolved yet, throws — call `getSignerAddress()` first.
+       */
+      getWalletAddress() {
+        if (this._eoaAddress) return this._eoaAddress;
+        const signer = this._signer;
+        if (signer.address && typeof signer.address === "string") {
+          const addr = signer.address;
+          this._eoaAddress = addr;
+          return addr;
+        }
+        throw new AgetherError(
+          "EOA address not yet resolved. Call getSignerAddress() (async) first, or use a signer that exposes .address synchronously.",
+          "ADDRESS_NOT_RESOLVED"
+        );
+      }
+      /**
+       * Resolve the EOA signer address (async, works with all signer types).
+       * Result is cached after the first call.
+       */
+      async getSignerAddress() {
+        if (!this._eoaAddress) {
+          this._eoaAddress = await this._signer.getAddress();
+        }
+        return this._eoaAddress;
+      }
+      /** Mint a new ERC-8004 identity and return the agentId. */
+      async _mintNewIdentity() {
+        const regTx = await this.identityRegistry.register();
+        const regReceipt = await regTx.wait();
+        this._refreshSigner();
+        let 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 (e) {
+            console.warn("[agether] parseLog skip:", e instanceof Error ? e.message : e);
+            continue;
+          }
+        }
+        if (agentId === 0n) throw new AgetherError("Failed to parse agentId from registration", "PARSE_ERROR");
+        return agentId;
+      }
+      /**
+       * Register: create ERC-8004 identity + AgentAccount in one flow.
+       * If already registered, returns existing state.
+       */
+      async register(_name) {
+        const eoaAddr = await this.getSignerAddress();
+        if (this.agentId) {
+          const exists = await this.safeAgentFactory.accountExists(BigInt(this.agentId));
+          if (exists) {
+            const acct = await this.safeAgentFactory.getAccount(BigInt(this.agentId));
+            this._accountAddress = acct;
+            const kyaRequired2 = await this.isKyaRequired();
+            return { agentId: this.agentId, address: eoaAddr, agentAccount: acct, alreadyRegistered: true, kyaRequired: kyaRequired2 };
+          }
+        }
+        let agentId;
+        if (this.agentId) {
+          const balance = await this.identityRegistry.balanceOf(eoaAddr);
+          if (balance > 0n) {
+            agentId = BigInt(this.agentId);
+          } else {
+            agentId = await this._mintNewIdentity();
+          }
+        } else {
+          agentId = await this._mintNewIdentity();
+        }
+        this.agentId = agentId.toString();
+        const acctExists = await this.safeAgentFactory.accountExists(agentId);
+        let txHash;
+        if (!acctExists) {
+          const tx = await this.safeAgentFactory.createAccount(agentId);
+          const receipt = await tx.wait();
+          this._refreshSigner();
+          txHash = receipt.hash;
+        }
+        const acctAddr = await this.safeAgentFactory.getAccount(agentId);
+        this._accountAddress = acctAddr;
+        const kyaRequired = await this.isKyaRequired();
+        return {
+          agentId: this.agentId,
+          address: eoaAddr,
+          agentAccount: acctAddr,
+          alreadyRegistered: acctExists,
+          kyaRequired,
+          tx: txHash
+        };
+      }
+      /** Get ETH / USDC / collateral balances for EOA and AgentAccount. */
+      async getBalances() {
+        const eoaAddr = await this.getSignerAddress();
+        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 eoaCollateral = {};
+        for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+          try {
+            const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
+            const bal = await token.balanceOf(eoaAddr);
+            eoaCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+          } catch (e) {
+            console.warn(`[agether] EOA collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
+            eoaCollateral[symbol] = "0";
+          }
+        }
+        const result = {
+          agentId: this.agentId || "?",
+          address: eoaAddr,
+          eth: import_ethers.ethers.formatEther(ethBal),
+          usdc: import_ethers.ethers.formatUnits(usdcBal, 6),
+          collateral: eoaCollateral
+        };
+        try {
+          const acctAddr = await this.getAccountAddress();
+          const acctEth = await this.provider.getBalance(acctAddr);
+          const acctUsdc = await usdc.balanceOf(acctAddr);
+          const acctCollateral = {};
+          for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+            try {
+              const token = new import_ethers.Contract(info.address, ERC20_ABI, this.provider);
+              const bal = await token.balanceOf(acctAddr);
+              acctCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+            } catch (e) {
+              console.warn(`[agether] AgentAccount collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
+              acctCollateral[symbol] = "0";
+            }
+          }
+          result.agentAccount = {
+            address: acctAddr,
+            eth: import_ethers.ethers.formatEther(acctEth),
+            usdc: import_ethers.ethers.formatUnits(acctUsdc, 6),
+            collateral: acctCollateral
+          };
+        } catch (err) {
+          if (err instanceof AgetherError && err.code === "NO_ACCOUNT") {
+          } else {
+            console.warn("[agether] getBalances: failed to fetch AgentAccount data:", err.message ?? err);
+          }
+        }
+        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._signer);
+        const amount = import_ethers.ethers.parseUnits(usdcAmount, 6);
+        const tx = await usdc.transfer(acctAddr, amount);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        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 (e) {
+          console.warn("[agether] getMarkets failed, using cache:", e instanceof Error ? e.message : e);
+          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 - 1n) / totalBorrowShares : 0n;
+                totalDebt += debt;
+              } catch (e) {
+                console.warn(`[agether] debt calc failed for market ${m.uniqueKey}:`, e instanceof Error ? e.message : e);
+              }
+            }
+            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 (e) {
+            console.warn(`[agether] position read failed for market:`, e instanceof Error ? e.message : e);
+            continue;
+          }
+        }
+        return {
+          agentId: this.agentId || "?",
+          agentAccount: acctAddr,
+          totalDebt: import_ethers.ethers.formatUnits(totalDebt, 6),
+          positions
+        };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Balance & Borrowing Capacity
+      // ════════════════════════════════════════════════════════
+      /**
+       * Get the USDC balance of the AgentAccount.
+       * @returns USDC balance in raw units (6 decimals)
+       */
+      async getUsdcBalance() {
+        const acctAddr = await this.getAccountAddress();
+        const usdc = new import_ethers.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
+        return usdc.balanceOf(acctAddr);
+      }
+      /**
+       * Calculate the maximum additional USDC that can be borrowed
+       * given the agent's current collateral and debt across all markets.
+       *
+       * For each market with collateral deposited:
+       *   maxBorrow = (collateralValue * LLTV) - currentDebt
+       *
+       * Uses the Morpho oracle to price collateral → loan token.
+       *
+       * @returns Maximum additional USDC borrowable (6 decimals)
+       */
+      async getMaxBorrowable() {
+        const acctAddr = await this.getAccountAddress();
+        const markets = await this.getMarkets();
+        let totalAdditional = 0n;
+        const byMarket = [];
+        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) continue;
+            const mktState = await this.morphoBlue.market(m.uniqueKey);
+            const totalBorrowShares = BigInt(mktState.totalBorrowShares);
+            const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
+            const currentDebt = totalBorrowShares > 0n ? (BigInt(pos.borrowShares) * totalBorrowAssets + totalBorrowShares - 1n) / totalBorrowShares : 0n;
+            let collateralValueInLoan;
+            try {
+              const oracleContract = new import_ethers.Contract(m.oracle, [
+                "function price() view returns (uint256)"
+              ], this.provider);
+              const oraclePrice = await oracleContract.price();
+              const ORACLE_PRICE_SCALE = 10n ** 36n;
+              collateralValueInLoan = BigInt(pos.collateral) * oraclePrice / ORACLE_PRICE_SCALE;
+            } catch (e) {
+              console.warn(`[agether] oracle price fetch failed:`, e instanceof Error ? e.message : e);
+              continue;
+            }
+            const maxBorrowTotal = collateralValueInLoan * m.lltv / 10n ** 18n;
+            const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
+            totalAdditional += maxAdditional;
+            byMarket.push({
+              collateralToken: m.collateralAsset.symbol,
+              maxAdditional,
+              currentDebt,
+              collateralValue: collateralValueInLoan
+            });
+          } catch (e) {
+            console.warn(`[agether] maxBorrow calc failed:`, e instanceof Error ? e.message : e);
+            continue;
+          }
+        }
+        return { total: totalAdditional, byMarket };
+      }
+      // ════════════════════════════════════════════════════════
+      //  Market Rates & Yield Estimation
+      // ════════════════════════════════════════════════════════
+      /**
+       * Fetch current supply/borrow APY for a collateral market from Morpho GraphQL API.
+       *
+       * Note: On Morpho Blue, collateral does NOT earn yield directly. Supply APY
+       * is what lenders earn; borrow APY is what borrowers pay.
+       */
+      async getMarketRates(collateralSymbolOrAddress) {
+        const chainId = this.config.chainId;
+        const usdcAddr = this.config.contracts.usdc.toLowerCase();
+        let collateralFilter = "";
+        if (collateralSymbolOrAddress) {
+          const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
+          const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+          collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
+        }
+        const query = `{
+      markets(
+        first: 50
+        orderBy: SupplyAssetsUsd
+        orderDirection: Desc
+        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"]${collateralFilter} }
+      ) {
+        items {
+          uniqueKey
+          lltv
+          loanAsset { address symbol decimals }
+          collateralAsset { address symbol decimals }
+          state {
+            borrowAssets
+            supplyAssets
+            utilization
+            supplyApy
+            borrowApy
+          }
+        }
+      }
+    }`;
+        try {
+          const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+          const items = resp.data?.data?.markets?.items ?? [];
+          return items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers.ethers.ZeroAddress).map((m) => ({
+            collateralToken: m.collateralAsset.symbol,
+            loanToken: m.loanAsset.symbol,
+            supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
+            borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
+            utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
+            totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / 1e6 : 0,
+            totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / 1e6 : 0,
+            lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
+            marketId: m.uniqueKey
+          }));
+        } catch (e) {
+          console.warn("[agether] getMarketRates failed:", e instanceof Error ? e.message : e);
+          return [];
+        }
+      }
+      /**
+       * Estimate theoretical yield for a given collateral amount over a period.
+       *
+       * ⚠️ IMPORTANT: On Morpho Blue, collateral does NOT earn yield directly.
+       * This estimates what the collateral WOULD earn if it were instead supplied
+       * as a lender (not used as collateral). This is a theoretical upper bound
+       * useful for setting spending caps.
+       *
+       * @param collateralSymbol - e.g. 'WETH'
+       * @param amount - collateral amount in human-readable (e.g. '1.5')
+       * @param periodDays - estimation period in days (default: 1)
+       * @param ethPriceUsd - ETH price in USD for value conversion (if not provided, uses oracle)
+       * @returns Estimated yield in USD for the period
+       */
+      async getYieldEstimate(collateralSymbol, amount, periodDays = 1, ethPriceUsd) {
+        const colInfo = BASE_COLLATERALS[collateralSymbol];
+        if (!colInfo) throw new AgetherError(`Unknown collateral: ${collateralSymbol}`, "UNKNOWN_COLLATERAL");
+        const rates = await this.getMarketRates(collateralSymbol);
+        if (rates.length === 0) {
+          throw new AgetherError(`No market found for ${collateralSymbol}`, "MARKET_NOT_FOUND");
+        }
+        const market = rates[0];
+        const supplyApy = market.supplyApy;
+        let collateralValueUsd;
+        if (ethPriceUsd) {
+          collateralValueUsd = parseFloat(amount) * ethPriceUsd;
+        } else {
+          try {
+            const params = await this.findMarketForCollateral(collateralSymbol);
+            const oracleContract = new import_ethers.Contract(params.oracle, [
+              "function price() view returns (uint256)"
+            ], this.provider);
+            const oraclePrice = await oracleContract.price();
+            const ORACLE_PRICE_SCALE = 10n ** 36n;
+            const amountWei = import_ethers.ethers.parseUnits(amount, colInfo.decimals);
+            const valueInUsdc = amountWei * oraclePrice / ORACLE_PRICE_SCALE;
+            collateralValueUsd = Number(valueInUsdc) / 1e6;
+          } catch (e) {
+            console.warn("[agether] oracle price fetch for yield estimation failed:", e instanceof Error ? e.message : e);
+            throw new AgetherError("Cannot determine collateral value. Provide ethPriceUsd.", "PRICE_UNAVAILABLE");
+          }
+        }
+        const estimatedYieldUsd = collateralValueUsd * supplyApy * (periodDays / 365);
+        return {
+          collateralToken: collateralSymbol,
+          amount,
+          periodDays,
+          theoreticalSupplyApy: supplyApy,
+          estimatedYieldUsd,
+          collateralValueUsd,
+          disclaimer: "Collateral on Morpho Blue does NOT earn yield directly. This estimates what it WOULD earn if supplied as a lender instead. Use as a theoretical spending cap."
+        };
+      }
+      // ════════════════════════════════════════════════════════
+      //  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._signer);
+        const transferTx = await colToken.transfer(acctAddr, weiAmount);
+        await transferTx.wait();
+        this._refreshSigner();
+        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._signer);
+        const transferTx = await colToken.transfer(acctAddr, colWei);
+        await transferTx.wait();
+        this._refreshSigner();
+        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 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;
+        }
+        let repayAssets;
+        let repayShares;
+        let approveAmount;
+        if (usdcAmount === "all") {
+          const markets = await this.getMarkets();
+          const mkt = markets.find(
+            (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
+          );
+          if (mkt) {
+            const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
+            repayShares = BigInt(pos.borrowShares);
+            repayAssets = 0n;
+            const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
+            const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+            const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+            const estimated = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
+            approveAmount = estimated > 0n ? estimated : import_ethers.ethers.parseUnits("1", 6);
+          } else {
+            repayAssets = import_ethers.ethers.parseUnits("999999", 6);
+            repayShares = 0n;
+            approveAmount = repayAssets;
+          }
+        } else {
+          repayAssets = import_ethers.ethers.parseUnits(usdcAmount, 6);
+          repayShares = 0n;
+          approveAmount = repayAssets;
+        }
+        const usdcContract = new import_ethers.Contract(usdcAddr, ERC20_ABI, this._signer);
+        const acctBalance = await usdcContract.balanceOf(acctAddr);
+        if (acctBalance < approveAmount) {
+          const shortfall = approveAmount - acctBalance;
+          const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
+          if (eoaBalance < shortfall) {
+            throw new AgetherError(
+              `Insufficient USDC for repay. Need ${import_ethers.ethers.formatUnits(approveAmount, 6)} USDC, AgentAccount has ${import_ethers.ethers.formatUnits(acctBalance, 6)}, EOA has ${import_ethers.ethers.formatUnits(eoaBalance, 6)}.`,
+              "INSUFFICIENT_BALANCE"
+            );
+          }
+          const transferTx = await usdcContract.transfer(acctAddr, shortfall);
+          await transferTx.wait();
+          this._refreshSigner();
+        }
+        const targets = [usdcAddr, morphoAddr];
+        const values = [0n, 0n];
+        const datas = [
+          erc20Iface.encodeFunctionData("approve", [morphoAddr, approveAmount]),
+          morphoIface.encodeFunctionData("repay", [
+            this._toTuple(params),
+            repayAssets,
+            repayShares,
+            acctAddr,
+            "0x"
+          ])
+        ];
+        const receipt = await this.batch(targets, values, datas);
+        let remainingDebt = "0";
+        try {
+          const status = await this.getStatus();
+          remainingDebt = status.totalDebt;
+        } catch (e) {
+          console.warn("[agether] failed to read remaining debt after repay:", e instanceof Error ? e.message : e);
+        }
+        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 usdcAddr = this.config.contracts.usdc;
+        const dest = receiver || await this.getSignerAddress();
+        let weiAmount;
+        const markets = await this.getMarkets();
+        const market = markets.find(
+          (m) => m.collateralAsset?.address.toLowerCase() === colInfo.address.toLowerCase()
+        );
+        if (amount === "all") {
+          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);
+        }
+        let hasDustDebt = false;
+        let dustBorrowShares = 0n;
+        let dustApproveAmount = 0n;
+        if (market) {
+          try {
+            const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+            dustBorrowShares = BigInt(pos.borrowShares);
+            if (dustBorrowShares > 0n) {
+              hasDustDebt = true;
+              const onChainMkt = await this.morphoBlue.market(market.uniqueKey);
+              const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+              const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+              const estimated = totalBorrowShares > 0n ? dustBorrowShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
+              dustApproveAmount = estimated > 0n ? estimated : import_ethers.ethers.parseUnits("1", 6);
+              console.log(`[agether] dust borrow shares detected: ${dustBorrowShares} shares \u2248 ${import_ethers.ethers.formatUnits(dustApproveAmount, 6)} USDC \u2014 auto-repaying before withdraw`);
+            }
+          } catch (e) {
+            console.warn("[agether] failed to check borrow shares before withdraw:", e instanceof Error ? e.message : e);
+          }
+        }
+        const withdrawData = morphoIface.encodeFunctionData("withdrawCollateral", [
+          this._toTuple(params),
+          weiAmount,
+          acctAddr,
+          dest
+        ]);
+        let receipt;
+        if (hasDustDebt) {
+          const usdcContract = new import_ethers.Contract(usdcAddr, ERC20_ABI, this._signer);
+          const acctBalance = await usdcContract.balanceOf(acctAddr);
+          if (acctBalance < dustApproveAmount) {
+            const shortfall = dustApproveAmount - acctBalance;
+            const eoaBalance = await usdcContract.balanceOf(await this.getSignerAddress());
+            if (eoaBalance >= shortfall) {
+              console.log(`[agether] transferring ${import_ethers.ethers.formatUnits(shortfall, 6)} USDC from EOA \u2192 AgentAccount for dust repay`);
+              const transferTx = await usdcContract.transfer(acctAddr, shortfall);
+              await transferTx.wait();
+              this._refreshSigner();
+            }
+          }
+          const targets = [usdcAddr, morphoAddr, morphoAddr];
+          const values = [0n, 0n, 0n];
+          const datas = [
+            erc20Iface.encodeFunctionData("approve", [morphoAddr, dustApproveAmount]),
+            morphoIface.encodeFunctionData("repay", [
+              this._toTuple(params),
+              0n,
+              dustBorrowShares,
+              acctAddr,
+              "0x"
+            ]),
+            withdrawData
+          ];
+          receipt = await this.batch(targets, values, datas);
+        } else {
+          receipt = await this.exec(morphoAddr, withdrawData);
+        }
+        let remainingCollateral = "0";
+        try {
+          if (market) {
+            const pos = await this.morphoBlue.position(market.uniqueKey, acctAddr);
+            remainingCollateral = import_ethers.ethers.formatUnits(pos.collateral, colInfo.decimals);
+          }
+        } catch (e) {
+          console.warn("[agether] failed to read remaining collateral after withdraw:", e instanceof Error ? e.message : e);
+        }
+        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.safeAgentFactory.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._signer);
+        const tx = await colToken.transfer(targetAddr, weiAmount);
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        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
+      // ════════════════════════════════════════════════════════
+      /**
+       * Refresh the signer and re-bind contract instances.
+       *
+       * For the **privateKey** path: recreates provider + wallet so the next tx
+       * fetches a fresh nonce from chain. Anvil (and some RPC providers) return a
+       * stale `eth_getTransactionCount` right after a block is mined, causing
+       * "nonce too low" on the follow-up tx.
+       *
+       * For the **external signer** path: the signer is immutable and owned by the
+       * caller (e.g. custody provider). We only re-bind contract instances to
+       * ensure they reference the current signer. Nonce management is the caller's
+       * responsibility.
+       */
+      _refreshSigner() {
+        if (this._useExternalSigner) {
+          const addrs = this.config.contracts;
+          this.safeAgentFactory = new import_ethers.Contract(addrs.safeAgentFactory, ACCOUNT_FACTORY_ABI, this._signer);
+          this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
+          this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
+          this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
+          this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
+        } else {
+          this.provider = new import_ethers.ethers.JsonRpcProvider(this._rpcUrl);
+          const wallet = new import_ethers.ethers.Wallet(this._privateKey, this.provider);
+          this._signer = wallet;
+          this._eoaAddress = wallet.address;
+          const addrs = this.config.contracts;
+          this.safeAgentFactory = new import_ethers.Contract(addrs.safeAgentFactory, ACCOUNT_FACTORY_ABI, this._signer);
+          this.entryPoint = new import_ethers.Contract(addrs.entryPoint, ENTRYPOINT_V07_ABI, this._signer);
+          this.validationModule = new import_ethers.Contract(addrs.erc8004ValidationModule, ERC8004_VALIDATION_MODULE_ABI, this.provider);
+          this.agentReputation = new import_ethers.Contract(addrs.agentReputation, AGENT_REPUTATION_ABI, this._signer);
+          this.identityRegistry = new import_ethers.Contract(addrs.identityRegistry, IDENTITY_REGISTRY_ABI, this._signer);
+        }
+      }
+      // ────────────────────────────────────────────────────────────
+      //  ERC-4337 UserOp helpers (Safe + Safe7579 + EntryPoint v0.7)
+      // ────────────────────────────────────────────────────────────
+      /**
+       * Pack two uint128 values into a single bytes32:
+       *   bytes32 = (hi << 128) | lo
+       */
+      _packUint128(hi, lo) {
+        return import_ethers.ethers.zeroPadValue(import_ethers.ethers.toBeHex(hi << 128n | lo), 32);
+      }
+      /**
+       * Build, sign and submit a PackedUserOperation through EntryPoint.handleOps.
+       *
+       * @param callData – the ABI-encoded calldata for the Safe7579 account
+       *   (e.g. `execute(mode, executionCalldata)`)
+       * @returns the transaction receipt of the handleOps call
+       */
+      async _submitUserOp(callData) {
+        const sender = await this.getAccountAddress();
+        const nonce = await this.entryPoint.getNonce(sender, 0);
+        const feeData = await this.provider.getFeeData();
+        const maxFeePerGas = feeData.maxFeePerGas ?? import_ethers.ethers.parseUnits("0.5", "gwei");
+        const maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? import_ethers.ethers.parseUnits("0.1", "gwei");
+        const verificationGasLimit = 500000n;
+        const callGasLimit = 800000n;
+        const preVerificationGas = 100000n;
+        const accountGasLimits = this._packUint128(verificationGasLimit, callGasLimit);
+        const gasFees = this._packUint128(maxPriorityFeePerGas, maxFeePerGas);
+        const userOp = {
+          sender,
+          nonce,
+          initCode: "0x",
+          callData,
+          accountGasLimits,
+          preVerificationGas,
+          gasFees,
+          paymasterAndData: "0x",
+          signature: "0x"
+          // placeholder — replaced after signing
+        };
+        const userOpHash = await this.entryPoint.getUserOpHash(userOp);
+        const signature = await this._signer.signMessage(import_ethers.ethers.getBytes(userOpHash));
+        userOp.signature = signature;
+        const tx = await this.entryPoint.handleOps([userOp], await this.getSignerAddress());
+        const receipt = await tx.wait();
+        this._refreshSigner();
+        return receipt;
+      }
+      /**
+       * Execute a single call via Safe7579 account (ERC-7579 single mode)
+       * through an ERC-4337 UserOperation.
+       */
+      async exec(target, data, value = 0n) {
+        const executionCalldata = import_ethers.ethers.AbiCoder.defaultAbiCoder().encode(
+          ["address", "uint256", "bytes"],
+          [target, value, data]
+        );
+        const safe7579Iface = new import_ethers.ethers.Interface(SAFE7579_ACCOUNT_ABI);
+        const callData = safe7579Iface.encodeFunctionData("execute", [MODE_SINGLE, executionCalldata]);
+        return this._submitUserOp(callData);
+      }
+      /**
+       * Execute multiple calls via Safe7579 account (ERC-7579 batch mode)
+       * through an ERC-4337 UserOperation.
+       */
+      async batch(targets, values, datas) {
+        const executions = targets.map((t, i) => [t, values[i], datas[i]]);
+        const executionCalldata = import_ethers.ethers.AbiCoder.defaultAbiCoder().encode(
+          ["(address,uint256,bytes)[]"],
+          [executions]
+        );
+        const safe7579Iface = new import_ethers.ethers.Interface(SAFE7579_ACCOUNT_ABI);
+        const callData = safe7579Iface.encodeFunctionData("execute", [MODE_BATCH, executionCalldata]);
+        return this._submitUserOp(callData);
+      }
+      /** 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 (e) {
+            console.warn("[agether] _findActiveMarket position check failed:", e instanceof Error ? e.message : e);
+            continue;
+          }
+        }
+        const params = await this.findMarketForCollateral("WETH");
+        return { params, symbol: "WETH" };
+      }
+    };
+  }
+});
+
+// src/clients/X402Client.ts
+var X402Client_exports = {};
+__export(X402Client_exports, {
+  X402Client: () => X402Client
+});
+var import_fetch, import_client, import_client2, import_accounts, X402Client;
+var init_X402Client = __esm({
+  "src/clients/X402Client.ts"() {
+    "use strict";
+    import_fetch = require("@x402/fetch");
+    import_client = require("@x402/core/client");
+    import_client2 = require("@x402/evm/exact/client");
+    import_accounts = require("viem/accounts");
+    X402Client = class {
+      constructor(config) {
+        this.config = config;
+        let baseSigner;
+        if ("walletClient" in config && config.walletClient) {
+          const wc = config.walletClient;
+          const account = wc.account;
+          if (!account) {
+            throw new Error(
+              "X402Client: walletClient must have an attached account. Pass an account when creating the WalletClient or use privateKey mode instead."
+            );
+          }
+          this.address = account.address;
+          baseSigner = {
+            address: account.address,
+            signTypedData: (msg) => wc.signTypedData({
+              account,
+              domain: msg.domain,
+              types: msg.types,
+              primaryType: msg.primaryType,
+              message: msg.message
+            })
+          };
+        } else if ("privateKey" in config && config.privateKey) {
+          const privateKey = config.privateKey.startsWith("0x") ? config.privateKey : `0x${config.privateKey}`;
+          const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+          this.address = account.address;
+          baseSigner = account;
+        } else {
+          throw new Error(
+            "X402Client: provide either privateKey or walletClient in config."
+          );
+        }
+        let signer;
+        if (config.accountAddress) {
+          const accountAddr = config.accountAddress;
+          const inner = baseSigner;
+          signer = (0, import_accounts.toAccount)({
+            address: accountAddr,
+            async signMessage({ message }) {
+              if ("signMessage" in inner && typeof inner.signMessage === "function") {
+                return inner.signMessage({ message });
+              }
+              throw new Error("signMessage not supported by underlying signer");
+            },
+            async signTransaction(tx) {
+              if ("signTransaction" in inner && typeof inner.signTransaction === "function") {
+                return inner.signTransaction(tx);
+              }
+              throw new Error("signTransaction not supported by underlying signer");
+            },
+            async signTypedData(typedData) {
+              const sig = await inner.signTypedData(typedData);
+              return `${sig}00`;
+            }
+          });
+          this.address = accountAddr;
+        } else {
+          signer = baseSigner;
+        }
+        const client = new import_client.x402Client();
+        (0, import_client2.registerExactEvmScheme)(client, { signer });
+        this.paidFetch = (0, import_fetch.wrapFetchWithPayment)(fetch, client);
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        const dailyLimit = config.dailySpendLimitUsdc ? BigInt(Math.round(parseFloat(config.dailySpendLimitUsdc) * 1e6)) : 0n;
+        this._spendingTracker = { date: today, totalBorrowed: 0n, dailyLimit };
+      }
+      async get(url, opts) {
+        return this.request(url, { ...opts, method: "GET" });
+      }
+      async post(url, body, opts) {
+        return this.request(url, {
+          ...opts,
+          method: "POST",
+          body: body ? JSON.stringify(body) : void 0,
+          headers: { "Content-Type": "application/json", ...opts?.headers }
+        });
+      }
+      getAddress() {
+        return this.address;
+      }
+      /** Get the current spending tracker state */
+      getSpendingTracker() {
+        this._resetTrackerIfNewDay();
+        return { ...this._spendingTracker };
+      }
+      /** Get remaining daily spending allowance in USDC (human-readable) */
+      getRemainingDailyAllowance() {
+        this._resetTrackerIfNewDay();
+        if (this._spendingTracker.dailyLimit === 0n) return "unlimited";
+        const remaining = this._spendingTracker.dailyLimit - this._spendingTracker.totalBorrowed;
+        return (Number(remaining > 0n ? remaining : 0n) / 1e6).toFixed(2);
+      }
+      /**
+       * Pay with auto-draw: Make an x402 request with automatic Morpho borrowing.
+       *
+       * Flow:
+       * 1. Check USDC balance on AgentAccount
+       * 2. Probe the URL to discover payment amount (if 402)
+       * 3. If insufficient USDC, calculate deficit
+       * 4. Check spending limit
+       * 5. Borrow from Morpho via MorphoClient
+       * 6. Proceed with x402 payment
+       */
+      async payWithAutoDraw(url, opts) {
+        const { morphoClient, ...fetchOpts } = opts || {};
+        if (!this.config.autoDraw || !morphoClient) {
+          return this.request(url, fetchOpts);
+        }
+        try {
+          const usdcBalance = await morphoClient.getUsdcBalance();
+          console.log(`   [auto-draw] AgentAccount USDC balance: ${(Number(usdcBalance) / 1e6).toFixed(2)}`);
+          const paymentAmount = await this._probePaymentAmount(url, fetchOpts);
+          if (paymentAmount !== null) {
+            console.log(`   [auto-draw] Payment required: ${(Number(paymentAmount) / 1e6).toFixed(6)} USDC`);
+            const bufferStr = this.config.autoDrawBuffer || "0.5";
+            const buffer = BigInt(Math.round(parseFloat(bufferStr) * 1e6));
+            const needed = paymentAmount + buffer;
+            if (usdcBalance < needed) {
+              const deficit = needed - usdcBalance;
+              console.log(`   [auto-draw] Insufficient balance. Need to borrow ${(Number(deficit) / 1e6).toFixed(2)} USDC`);
+              const limitCheck = await this._checkSpendingLimit(deficit, morphoClient);
+              if (!limitCheck.allowed) {
+                return {
+                  success: false,
+                  error: `Auto-draw blocked: ${limitCheck.reason}`
+                };
+              }
+              const maxBorrowable = await morphoClient.getMaxBorrowable();
+              if (maxBorrowable.total < deficit) {
+                return {
+                  success: false,
+                  error: `Auto-draw failed: insufficient collateral. Need ${(Number(deficit) / 1e6).toFixed(2)} USDC but can only borrow ${(Number(maxBorrowable.total) / 1e6).toFixed(2)} USDC more.`
+                };
+              }
+              const borrowAmount = (Number(deficit) / 1e6).toFixed(6);
+              console.log(`   [auto-draw] Borrowing ${borrowAmount} USDC from Morpho...`);
+              const borrowResult = await morphoClient.borrow(borrowAmount);
+              console.log(`   [auto-draw] Borrow tx: ${borrowResult.tx}`);
+              this._trackSpending(deficit);
+              const result = await this.request(url, fetchOpts);
+              return {
+                ...result,
+                autoDrawInfo: {
+                  borrowed: borrowAmount,
+                  borrowTx: borrowResult.tx,
+                  reason: `USDC balance insufficient (had ${(Number(usdcBalance) / 1e6).toFixed(2)}, needed ${(Number(needed) / 1e6).toFixed(2)})`
+                }
+              };
+            }
+          }
+          return this.request(url, fetchOpts);
+        } catch (error) {
+          console.log(`   [auto-draw] Auto-draw check failed: ${error instanceof Error ? error.message : String(error)}. Proceeding with normal request.`);
+          return this.request(url, fetchOpts);
+        }
+      }
+      // ──────────── Core request — @x402/fetch handles 402 automatically ────────────
+      async request(url, options) {
+        try {
+          console.log(`   [x402] ${options?.method || "GET"} ${url}`);
+          const response = await this.paidFetch(url, {
+            ...options,
+            headers: {
+              ...options?.headers,
+              "X-Agent-Id": this.config.agentId || ""
+            }
+          });
+          if (response.ok) {
+            const data = await response.json();
+            const paymentResponse = response.headers.get("PAYMENT-RESPONSE");
+            let txHash;
+            if (paymentResponse) {
+              try {
+                const settlement = JSON.parse(
+                  Buffer.from(paymentResponse, "base64").toString("utf-8")
+                );
+                txHash = settlement.transaction;
+              } catch (e) {
+                console.warn("[agether] x402 payment response parse failed:", e instanceof Error ? e.message : e);
+              }
+            }
+            return {
+              success: true,
+              data,
+              ...txHash ? {
+                paymentInfo: {
+                  amount: "",
+                  asset: "USDC",
+                  network: "eip155:8453",
+                  txHash
+                }
+              } : {}
+            };
+          }
+          const errBody = await response.text();
+          return {
+            success: false,
+            error: `HTTP ${response.status}: ${errBody}`
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Request failed: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      // ──────────── Auto-Draw Helpers ────────────
+      /**
+       * Probe a URL to discover payment requirements without paying.
+       * Makes a request and parses the 402 PAYMENT-REQUIRED header.
+       * @returns Payment amount in raw USDC units (6 decimals), or null if not a 402.
+       */
+      async _probePaymentAmount(url, options) {
+        try {
+          const response = await fetch(url, {
+            ...options,
+            headers: {
+              ...options?.headers,
+              "X-Agent-Id": this.config.agentId || ""
+            }
+          });
+          if (response.status !== 402) return null;
+          const paymentHeader = response.headers.get("X-PAYMENT") || response.headers.get("PAYMENT-REQUIRED");
+          if (!paymentHeader) return null;
+          try {
+            const decoded = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
+            const requirements = Array.isArray(decoded) ? decoded : decoded.accepts || [decoded];
+            if (requirements.length > 0) {
+              const amount = requirements[0].maxAmountRequired || requirements[0].amount;
+              if (amount) {
+                return BigInt(amount);
+              }
+            }
+          } catch (e) {
+            console.warn("[agether] x402 payment header parse failed:", e instanceof Error ? e.message : e);
+          }
+          return null;
+        } catch (e) {
+          console.warn("[agether] x402 getPaymentRequired failed:", e instanceof Error ? e.message : e);
+          return null;
+        }
+      }
+      /** Reset spending tracker if it's a new day */
+      _resetTrackerIfNewDay() {
+        const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+        if (this._spendingTracker.date !== today) {
+          this._spendingTracker = {
+            date: today,
+            totalBorrowed: 0n,
+            dailyLimit: this._spendingTracker.dailyLimit
+          };
+        }
+      }
+      /** Track a new spending amount */
+      _trackSpending(amount) {
+        this._resetTrackerIfNewDay();
+        this._spendingTracker.totalBorrowed += amount;
+      }
+      /**
+       * Check if a borrow amount is within spending limits.
+       * Considers both fixed daily limits and yield-limited spending.
+       */
+      async _checkSpendingLimit(amount, morphoClient) {
+        this._resetTrackerIfNewDay();
+        if (this.config.yieldLimitedSpending) {
+          try {
+            const status = await morphoClient.getStatus();
+            let totalDailyYieldUsdc = 0;
+            for (const pos of status.positions) {
+              if (parseFloat(pos.collateral) > 0) {
+                try {
+                  const estimate = await morphoClient.getYieldEstimate(
+                    pos.collateralToken,
+                    pos.collateral,
+                    1
+                    // 1 day
+                  );
+                  totalDailyYieldUsdc += estimate.estimatedYieldUsd;
+                } catch (e) {
+                  console.warn(`[agether] yield calc failed for ${pos.collateralToken}:`, e instanceof Error ? e.message : e);
+                }
+              }
+            }
+            const yieldLimit = BigInt(Math.round(totalDailyYieldUsdc * 1e6));
+            const newTotal = this._spendingTracker.totalBorrowed + amount;
+            if (yieldLimit > 0n && newTotal > yieldLimit) {
+              return {
+                allowed: false,
+                reason: `Yield-limited spending exceeded. Daily yield cap: $${(Number(yieldLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
+              };
+            }
+          } catch (e) {
+            console.warn("[agether] yield-limited spending check failed, falling through to fixed limit:", e instanceof Error ? e.message : e);
+          }
+        }
+        if (this._spendingTracker.dailyLimit > 0n) {
+          const newTotal = this._spendingTracker.totalBorrowed + amount;
+          if (newTotal > this._spendingTracker.dailyLimit) {
+            return {
+              allowed: false,
+              reason: `Daily spending limit exceeded. Limit: $${(Number(this._spendingTracker.dailyLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
+            };
+          }
+        }
+        return { allowed: true };
+      }
+    };
+  }
+});
+
+// src/cli.ts
+var import_ethers2 = require("ethers");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CONFIG_PATH = path.join(os.homedir(), ".agether", "config.json");
+var DEFAULT_RPC = "https://base-rpc.publicnode.com";
+var DEFAULT_BACKEND = "http://95.179.189.214:3001";
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveConfig(config) {
+  const dir = path.dirname(CONFIG_PATH);
+  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 {
+      const receipt = await tx.wait();
+      if (receipt) return receipt;
+    } catch (e) {
+      if (attempt === retries) throw e;
+      console.log(`        \u23F3 Receipt fetch failed (attempt ${attempt}/${retries}), retrying...`);
+      await new Promise((r) => setTimeout(r, 2e3 * attempt));
+    }
+  }
+  throw new Error("Failed to get transaction receipt after retries");
+}
+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 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)"
+];
+var ACCOUNT_FACTORY_ABI2 = [
+  "function getAccount(uint256 agentId) view returns (address)",
+  "function accountExists(uint256 agentId) view returns (bool)",
+  "function createAccount(uint256 agentId) returns (address account)",
+  "event AccountCreated(uint256 indexed agentId, address indexed account, address indexed owner)"
+];
+var VALIDATION_REGISTRY_ABI = [
+  "function isAgentCodeApproved(uint256 agentId) view returns (bool)"
+];
+var MOCK_ERC20_ABI = [
+  "function mint(address to, uint256 amount) external"
+];
+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);
+  } catch {
+    console.error("\u274C Invalid private key");
+    process.exit(1);
+  }
+  const config = { privateKey, agentId: agentId || "0", rpcUrl, backendUrl };
+  saveConfig(config);
+  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) {
+  const config = requireConfig();
+  const provider = new import_ethers2.ethers.JsonRpcProvider(config.rpcUrl);
+  const signer = new import_ethers2.ethers.Wallet(config.privateKey, provider);
+  const agentName = name || `Agent-${signer.address.slice(0, 8)}`;
+  console.log(`\u{1F916} Registering agent: ${agentName}
+`);
+  console.log(`   Wallet: ${signer.address}`);
+  console.log("\n  [1/4] Fetching contract addresses...");
+  let contracts;
+  try {
+    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);
+  }
+  const registryAddr = contracts.agentRegistry || contracts.identityRegistry;
+  const factoryAddr = contracts.safeAgentFactory || contracts.accountFactory;
+  const validationAddr = contracts.validationRegistry;
+  if (!registryAddr || !factoryAddr) {
+    console.error("        \u274C Backend missing agentRegistry or safeAgentFactory");
+    process.exit(1);
+  }
+  console.log("  [2/4] Registering on ERC-8004 IdentityRegistry...");
+  const agentRegistry = new import_ethers2.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() === signer.address.toLowerCase()) {
+        console.log(`        \u2713 Already registered as Agent #${agentId}`);
+      } else {
+        console.error("        \u274C agentId does not belong to this wallet");
+        process.exit(1);
+      }
+    } catch {
+      console.error(`        \u274C agentId ${agentId} does not exist on-chain`);
+      process.exit(1);
+    }
+  } else {
+    const existingBalance = await agentRegistry.balanceOf(signer.address);
+    if (existingBalance > 0n) {
+      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
+      });
+      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);
+      if (transferLog && transferLog.topics.length >= 4) {
+        agentId = BigInt(transferLog.topics[3]);
+      } else {
+        console.error("        \u274C Could not parse agentId from receipt");
+        process.exit(1);
+      }
+      console.log(`        \u2713 Agent #${agentId} registered`);
+      console.log(`        TX: ${tx.hash}`);
+      config.agentId = agentId.toString();
+      saveConfig(config);
+    } catch (e) {
+      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) {
+          console.error(`        Wallet owns ${balance} token(s) but agentId unknown.`);
+          console.error("        Set manually: agether init <pk> --agent-id <id>");
+        } else {
+          console.error(`        \u274C Registration failed: ${e.message}`);
+        }
+        process.exit(1);
+      }
+    }
+  }
+  const network = await provider.getNetwork();
+  const chainId = Number(network.chainId);
+  if (chainId === 31337 || chainId === 1) {
+    console.log("  [3/4] Minting test USDC (Hardhat fork)...");
+    const deployerPk = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+    const deployer = new import_ethers2.ethers.Wallet(deployerPk, provider);
+    const usdcAddr = contracts.usdc;
+    if (usdcAddr) {
+      try {
+        const usdc = new import_ethers2.ethers.Contract(usdcAddr, MOCK_ERC20_ABI, deployer);
+        const tx = await usdc.mint(signer.address, BigInt(5e10));
+        await waitForTx(tx);
+        console.log("        \u2713 Minted $50,000 USDC");
+      } catch {
+        console.log("        \u26A0 Mint failed (probably real network)");
+      }
+    }
+  } else {
+    console.log("  [3/4] Skipping USDC mint (real network)");
+  }
+  console.log("  [4/4] Creating Safe account...");
+  if (factoryAddr) {
+    const factory = new import_ethers2.ethers.Contract(factoryAddr, ACCOUNT_FACTORY_ABI2, signer);
+    try {
+      const exists = await factory.accountExists(agentId);
+      if (exists) {
+        const addr = await factory.getAccount(agentId);
+        console.log(`        Already exists: ${addr}`);
+      } else {
+        const tx = await factory.createAccount(agentId);
+        await waitForTx(tx);
+        const addr = await factory.getAccount(agentId);
+        console.log(`        \u2713 Created: ${addr}`);
+        console.log(`        TX: ${tx.hash}`);
+      }
+    } catch (e) {
+      console.error(`        \u274C Failed: ${e.message}`);
+    }
+  }
+  if (validationAddr) {
+    const vr = new import_ethers2.ethers.Contract(validationAddr, VALIDATION_REGISTRY_ABI, provider);
+    try {
+      const approved = await vr.isAgentCodeApproved(agentId);
+      console.log(`
+  KYA Status: ${approved ? "\u2705 Approved" : "\u23F3 Pending"}`);
+    } catch {
+      console.log("\n  KYA Status: \u26A0 Could not check");
+    }
+  }
+  console.log(`
+\u2705 Agent #${agentId} ready!`);
+  console.log(`   Config: ${CONFIG_PATH}`);
+  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 cmdBalance() {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  const balances = await mc.getBalances();
+  console.log(`
+\u{1F4B0} Agent #${balances.agentId} Balances
+`);
+  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)}`);
+  }
+}
+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("\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("  \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 score = await mc.getCreditScore();
+    const { fresh, age } = await mc.isScoreFresh();
+    const ageHrs = Number(age) / 3600;
+    console.log(`
+  Credit Score: ${score} ${fresh ? "\u2705" : `\u26A0\uFE0F stale (${ageHrs.toFixed(1)}h old)`}`);
+  } catch {
+    console.log("\n  Credit Score: not yet computed");
+  }
+}
+async function cmdScore() {
+  const config = requireConfig();
+  console.log(`
+\u{1F4C8} Agent #${config.agentId} Score
+`);
+  try {
+    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("  No score on-chain yet.");
+    }
+  } catch {
+    console.log("  Could not fetch current score.");
+  }
+  console.log("\n  To compute a fresh score (x402-gated, costs USDC):");
+  console.log(`    agether x402 ${config.backendUrl}/score/${config.agentId}`);
+}
+async function cmdMarkets() {
+  const config = requireConfig();
+  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;
+  }
+  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 cmdDeposit(amount, token) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\u{1F4B0} Depositing ${amount} ${token} as collateral...
+`);
+  try {
+    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 cmdBorrow(amount, token) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\u{1F4B8} Borrowing $${amount} USDC...
+`);
+  try {
+    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 cmdDepositAndBorrow(collateralAmount, token, borrowAmount) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\uFFFD\uFFFD Depositing ${collateralAmount} ${token} + Borrowing $${borrowAmount}...
+`);
+  try {
+    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 cmdRepay(amount, token) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\u{1F4B3} Repaying $${amount} USDC...
+`);
+  try {
+    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 cmdWithdraw(amount, token) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\u{1F4E4} Withdrawing ${amount} ${token}...
+`);
+  try {
+    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 cmdSponsor(amount, token, agentId, address) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  const target = agentId ? { agentId } : { address };
+  console.log(`
+\u{1F381} Sponsoring ${amount} ${token} to ${agentId || address}...
+`);
+  try {
+    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 ${decodeError(e)}`);
+  }
+}
+async function cmdFund(amount) {
+  const config = requireConfig();
+  const mc = await getMorphoClient(config);
+  console.log(`
+\u{1F4B5} Funding AgentAccount with $${amount} USDC...
+`);
+  try {
+    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 ${decodeError(e)}`);
+  }
+}
+async function cmdX402Call(url, method = "GET", body) {
+  const config = requireConfig();
+  console.log("\n\u{1F510} x402 Paid API Call\n");
+  const x402 = await getX402Client(config);
+  console.log(`   Wallet: ${new import_ethers2.ethers.Wallet(config.privateKey).address}`);
+  console.log(`
+\u{1F4E1} ${method} ${url}`);
+  if (body) console.log(`\u{1F4E6} Body: ${body}`);
+  try {
+    let result;
+    if (method === "POST" && body) {
+      result = await x402.post(url, JSON.parse(body));
+    } else {
+      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}`);
+      }
+      console.log("\n\u{1F4C4} Response:");
+      console.log(JSON.stringify(result.data, null, 2));
+    } else {
+      console.error(`
+\u274C Failed: ${result.error}`);
+    }
+  } catch (e) {
+    console.error(`\u274C Error: ${e.message}`);
+  }
+}
+function cmdHelp() {
+  console.log(`
+\u{1F3E6} Agether CLI \u2014 Direct Morpho Blue Credit for AI Agents (Safe + Safe7579)
+
+USAGE:
+  agether <command> [options]
+
+SETUP:
+  init <private-key> [--agent-id <id>]    Initialize with private key
+  register [--name <n>]                   Register ERC-8004 + create Safe account
+
+INFO:
+  balance                                 Check ETH + USDC balances
+  status                                  Show Morpho positions & credit score
+  score                                   Get credit score
+  markets                                 List Morpho Blue USDC markets
+
+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 Safe account
+
+x402 PAYMENTS:
+  x402 <url> [--method GET|POST] [--body <json>]   Make a paid API call
+
+ENVIRONMENT:
+  AGETHER_RPC_URL       RPC endpoint (default: ${DEFAULT_RPC})
+  AGETHER_BACKEND_URL   Backend URL (default: ${DEFAULT_BACKEND})
+
+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) {
+  const command = args[0] || "help";
+  const positional = [];
+  const options = {};
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next && !next.startsWith("--")) {
+        options[key] = next;
+        i++;
+      } else {
+        options[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { command, positional, options };
+}
+async function main() {
+  const { command, positional, options } = parseArgs(process.argv.slice(2));
+  try {
+    switch (command) {
+      case "init":
+        if (!positional[0]) {
+          console.error("\u274C Private key required: agether init <private-key>");
+          process.exit(1);
+        }
+        await cmdInit(positional[0], options["agent-id"]);
+        break;
+      case "register":
+        await cmdRegister(options.name);
+        break;
+      case "balance":
+        await cmdBalance();
+        break;
+      case "status":
+        await cmdStatus();
+        break;
+      case "score":
+        await cmdScore();
+        break;
+      case "markets":
+        await cmdMarkets();
+        break;
+      case "deposit":
+        if (!options.amount || !options.token) {
+          console.error("\u274C --amount and --token required");
+          console.error("   agether deposit --amount 0.05 --token WETH");
+          process.exit(1);
+        }
+        await cmdDeposit(options.amount, options.token);
+        break;
+      case "borrow":
+        if (!options.amount) {
+          console.error("\u274C --amount required (in USD)");
+          console.error("   agether borrow --amount 100");
+          process.exit(1);
+        }
+        await cmdBorrow(options.amount, options.token);
+        break;
+      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");
+          process.exit(1);
+        }
+        await cmdRepay(options.amount, options.token);
+        break;
+      case "withdraw":
+        if (!options.amount || !options.token) {
+          console.error("\u274C --amount and --token required");
+          console.error("   agether withdraw --amount 0.05 --token WETH");
+          console.error("   agether withdraw --amount all --token WETH");
+          process.exit(1);
+        }
+        await cmdWithdraw(options.amount, options.token);
+        break;
+      case "sponsor":
+        if (!options.amount || !options.token) {
+          console.error("\u274C --amount and --token required, plus --agent-id or --address");
+          process.exit(1);
+        }
+        if (!options["agent-id"] && !options.address) {
+          console.error("\u274C --agent-id or --address required");
+          process.exit(1);
+        }
+        await cmdSponsor(
+          options.amount,
+          options.token,
+          options["agent-id"],
+          options.address
+        );
+        break;
+      case "fund":
+        if (!options.amount) {
+          console.error("\u274C --amount required (USDC)");
+          process.exit(1);
+        }
+        await cmdFund(options.amount);
+        break;
+      case "x402":
+        if (!positional[0]) {
+          console.error("\u274C URL required: agether x402 <url>");
+          process.exit(1);
+        }
+        await cmdX402Call(
+          positional[0],
+          options.method || "GET",
+          options.body
+        );
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+        cmdHelp();
+        break;
+      default:
+        console.error(`\u274C Unknown command: ${command}`);
+        cmdHelp();
+        process.exit(1);
+    }
+  } catch (e) {
+    console.error(`\u274C Error: ${e.message}`);
+    process.exit(1);
+  }
+}
+main();