@sherwoodagent/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2726 @@
+#!/usr/bin/env node
+import {
+  AGENT_REGISTRY,
+  EAS_ABI,
+  EAS_CONTRACTS,
+  EAS_SCHEMAS,
+  ERC20_ABI,
+  MOONWELL,
+  SHERWOOD,
+  STRATEGY_REGISTRY_ABI,
+  SYNDICATE_FACTORY_ABI,
+  SYNDICATE_VAULT_ABI,
+  TOKENS,
+  UNISWAP,
+  UNISWAP_QUOTER_V2_ABI,
+  VENICE,
+  VENICE_STAKING_ABI,
+  addTarget,
+  approveDepositor,
+  cacheGroupId,
+  deposit,
+  executeBatch,
+  getAccount,
+  getAgentId,
+  getAllowedTargets,
+  getAssetDecimals,
+  getBalance,
+  getChain,
+  getChainContracts,
+  getExplorerUrl,
+  getNetwork,
+  getPublicClient,
+  getRpcUrl,
+  getVaultAddress,
+  getVaultInfo,
+  getVeniceApiKey,
+  getWalletClient,
+  loadConfig,
+  ragequit,
+  registerAgent,
+  removeDepositor,
+  removeTarget,
+  resolveSyndicate,
+  resolveVaultSyndicate,
+  setAgentId,
+  setChainContract,
+  setNetwork,
+  setPrivateKey,
+  setTextRecord,
+  setVaultAddress,
+  setVeniceApiKey,
+  simulateBatch
+} from "./chunk-CR3ZNOB7.js";
+
+// src/index.ts
+import { config as loadDotenv } from "dotenv";
+import { Command } from "commander";
+import { parseUnits as parseUnits8 } from "viem";
+import chalk5 from "chalk";
+import ora5 from "ora";
+import { input, confirm } from "@inquirer/prompts";
+
+// src/providers/moonwell.ts
+import { base, baseSepolia } from "viem/chains";
+var MoonwellProvider = class {
+  info() {
+    return {
+      name: "moonwell",
+      type: "lending",
+      capabilities: [
+        "lend.deposit",
+        "lend.borrow",
+        "lend.repay",
+        "lend.withdraw",
+        "lend.positions"
+      ],
+      supportedChains: [base, baseSepolia]
+    };
+  }
+  async depositCollateral(params) {
+    throw new Error("Not implemented \u2014 wire up viem client");
+  }
+  async borrow(params) {
+    throw new Error("Not implemented");
+  }
+  async repay(params) {
+    throw new Error("Not implemented");
+  }
+  async withdrawCollateral(params) {
+    throw new Error("Not implemented");
+  }
+  async getPosition(account) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/providers/uniswap.ts
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
+var UniswapProvider = class {
+  info() {
+    return {
+      name: "uniswap",
+      type: "trading",
+      capabilities: [
+        "swap.exact-input",
+        "swap.quote"
+      ],
+      supportedChains: [base2, baseSepolia2]
+    };
+  }
+  async swap(params) {
+    throw new Error("Not implemented \u2014 wire up viem client");
+  }
+  async quote(params) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/commands/strategy-run.ts
+import { parseUnits as parseUnits2, formatUnits, isAddress } from "viem";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/strategies/levered-swap.ts
+import {
+  encodeFunctionData,
+  parseUnits,
+  parseEther
+} from "viem";
+var ERC20_ABI2 = [
+  {
+    name: "approve",
+    type: "function",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var MTOKEN_ABI = [
+  {
+    name: "mint",
+    type: "function",
+    inputs: [{ name: "mintAmount", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "borrow",
+    type: "function",
+    inputs: [{ name: "borrowAmount", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "repayBorrow",
+    type: "function",
+    inputs: [{ name: "repayAmount", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "redeemUnderlying",
+    type: "function",
+    inputs: [{ name: "redeemAmount", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var COMPTROLLER_ABI = [
+  {
+    name: "enterMarkets",
+    type: "function",
+    inputs: [{ name: "mTokens", type: "address[]" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  }
+];
+var SWAP_ROUTER_ABI = [
+  {
+    name: "exactInputSingle",
+    type: "function",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+function buildEntryBatch(config, vaultAddress, amountOutMinimum, borrowDecimals) {
+  const ZERO = "0x0000000000000000000000000000000000000000";
+  if (MOONWELL().mWETH === ZERO || MOONWELL().mUSDC === ZERO || MOONWELL().COMPTROLLER === ZERO) {
+    throw new Error("Moonwell is not deployed on this network \u2014 levered swap requires Moonwell lending markets");
+  }
+  const collateral = parseEther(config.collateralAmount);
+  const borrow = parseUnits(config.borrowAmount, borrowDecimals);
+  const calls = [
+    // 1. Approve mWETH to pull WETH from executor
+    {
+      target: TOKENS().WETH,
+      data: encodeFunctionData({
+        abi: ERC20_ABI2,
+        functionName: "approve",
+        args: [MOONWELL().mWETH, collateral]
+      }),
+      value: 0n
+    },
+    // 2. Deposit WETH as collateral (mint mWETH tokens)
+    {
+      target: MOONWELL().mWETH,
+      data: encodeFunctionData({
+        abi: MTOKEN_ABI,
+        functionName: "mint",
+        args: [collateral]
+      }),
+      value: 0n
+    },
+    // 3. Enter WETH market (enable as collateral for borrowing)
+    {
+      target: MOONWELL().COMPTROLLER,
+      data: encodeFunctionData({
+        abi: COMPTROLLER_ABI,
+        functionName: "enterMarkets",
+        args: [[MOONWELL().mWETH]]
+      }),
+      value: 0n
+    },
+    // 4. Borrow USDC against WETH collateral
+    {
+      target: MOONWELL().mUSDC,
+      data: encodeFunctionData({
+        abi: MTOKEN_ABI,
+        functionName: "borrow",
+        args: [borrow]
+      }),
+      value: 0n
+    },
+    // 5. Approve SwapRouter to pull borrowed USDC
+    {
+      target: TOKENS().USDC,
+      data: encodeFunctionData({
+        abi: ERC20_ABI2,
+        functionName: "approve",
+        args: [UNISWAP().SWAP_ROUTER, borrow]
+      }),
+      value: 0n
+    },
+    // 6. Swap USDC → target token
+    {
+      target: UNISWAP().SWAP_ROUTER,
+      data: encodeFunctionData({
+        abi: SWAP_ROUTER_ABI,
+        functionName: "exactInputSingle",
+        args: [
+          {
+            tokenIn: TOKENS().USDC,
+            tokenOut: config.targetToken,
+            fee: config.fee,
+            recipient: vaultAddress,
+            // Tokens stay in vault (delegatecall)
+            amountIn: borrow,
+            amountOutMinimum,
+            sqrtPriceLimitX96: 0n
+          }
+        ]
+      }),
+      value: 0n
+    }
+  ];
+  return calls;
+}
+
+// src/lib/quote.ts
+import { encodeFunctionData as encodeFunctionData2, decodeFunctionResult, concat, pad, numberToHex } from "viem";
+async function getQuote(params) {
+  const client = getPublicClient();
+  const calldata = encodeFunctionData2({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInputSingle",
+    args: [
+      {
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+        fee: params.fee,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
+  });
+  const { data } = await client.call({
+    to: UNISWAP().QUOTER_V2,
+    data: calldata
+  });
+  if (!data) {
+    throw new Error("Quoter returned no data \u2014 pool may not exist for this pair/fee");
+  }
+  const [amountOut, sqrtPriceX96After, , gasEstimate] = decodeFunctionResult({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInputSingle",
+    data
+  });
+  return { amountOut, sqrtPriceX96After, gasEstimate };
+}
+function applySlippage(amountOut, slippageBps) {
+  return amountOut * BigInt(1e4 - slippageBps) / 10000n;
+}
+function encodeSwapPath(tokens, fees) {
+  if (tokens.length < 2 || fees.length !== tokens.length - 1) {
+    throw new Error("Invalid path: need at least 2 tokens and (tokens-1) fees");
+  }
+  const parts = [];
+  for (let i = 0; i < tokens.length; i++) {
+    parts.push(tokens[i].toLowerCase());
+    if (i < fees.length) {
+      parts.push(pad(numberToHex(fees[i]), { size: 3 }));
+    }
+  }
+  return concat(parts);
+}
+async function getMultiHopQuote(params) {
+  const client = getPublicClient();
+  const calldata = encodeFunctionData2({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInput",
+    args: [params.path, params.amountIn]
+  });
+  const { data } = await client.call({
+    to: UNISWAP().QUOTER_V2,
+    data: calldata
+  });
+  if (!data) {
+    throw new Error("Quoter returned no data \u2014 pool may not exist for this path");
+  }
+  const [amountOut, , , gasEstimate] = decodeFunctionResult({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInput",
+    data
+  });
+  return { amountOut, sqrtPriceX96After: 0n, gasEstimate };
+}
+
+// src/lib/batch.ts
+function formatBatch(calls) {
+  return calls.map((call, i) => {
+    const selector = call.data.slice(0, 10);
+    return `  ${i + 1}. ${call.target} :: ${selector}... (${call.value > 0n ? call.value + " wei" : "no value"})`;
+  }).join("\n");
+}
+
+// src/commands/strategy-run.ts
+var VALID_FEES = [500, 3e3, 1e4];
+async function runLeveredSwap(opts) {
+  const vaultAddress = opts.vault;
+  if (!isAddress(opts.token)) {
+    console.error(chalk.red(`Invalid token address: ${opts.token}`));
+    process.exit(1);
+  }
+  const targetToken = opts.token;
+  const feeTier = Number(opts.fee);
+  if (!VALID_FEES.includes(feeTier)) {
+    console.error(chalk.red(`Invalid fee tier: ${opts.fee}. Valid: ${VALID_FEES.join(", ")}`));
+    process.exit(1);
+  }
+  const slippageBps = Number(opts.slippage);
+  const client = getPublicClient();
+  let targetDecimals;
+  let borrowDecimals;
+  try {
+    [targetDecimals, borrowDecimals] = await Promise.all([
+      client.readContract({
+        address: targetToken,
+        abi: ERC20_ABI,
+        functionName: "decimals"
+      }),
+      client.readContract({
+        address: TOKENS().USDC,
+        abi: ERC20_ABI,
+        functionName: "decimals"
+      })
+    ]);
+  } catch {
+    console.error(chalk.red(`Could not read token decimals \u2014 are the addresses valid ERC20s?`));
+    process.exit(1);
+  }
+  console.log();
+  console.log(chalk.bold("Levered Swap Strategy"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(`  Collateral:  ${opts.collateral} WETH (agent-provided)`);
+  console.log(`  Borrow:      ${opts.borrow} USDC (from Moonwell)`);
+  console.log(`  Buy:         ${targetToken} (${targetDecimals} decimals)`);
+  console.log(`  Fee tier:    ${(feeTier / 1e4 * 100).toFixed(2)}%`);
+  console.log(`  Slippage:    ${(slippageBps / 100).toFixed(2)}%`);
+  console.log(`  Vault:       ${vaultAddress}`);
+  console.log();
+  const spinner = ora("Fetching Uniswap quote...").start();
+  let amountOut;
+  let minOut;
+  try {
+    const borrowAmount = parseUnits2(opts.borrow, borrowDecimals);
+    const quote = await getQuote({
+      tokenIn: TOKENS().USDC,
+      tokenOut: targetToken,
+      amountIn: borrowAmount,
+      fee: feeTier
+    });
+    amountOut = quote.amountOut;
+    minOut = applySlippage(amountOut, slippageBps);
+    spinner.succeed(
+      `Quote: ${formatUnits(amountOut, targetDecimals)} tokens (min: ${formatUnits(minOut, targetDecimals)}, gas est: ${quote.gasEstimate})`
+    );
+  } catch (err) {
+    spinner.fail("Failed to fetch quote");
+    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+  const config = {
+    collateralAmount: opts.collateral,
+    borrowAmount: opts.borrow,
+    targetToken,
+    fee: feeTier,
+    slippageBps,
+    profitTargetBps: 2e3,
+    // 20% default
+    stopLossBps: 1e3
+    // 10% default
+  };
+  const calls = buildEntryBatch(config, vaultAddress, minOut, borrowDecimals);
+  console.log();
+  console.log(chalk.bold("Batch calls (6):"));
+  console.log(formatBatch(calls));
+  console.log();
+  const assetAmount = 0n;
+  const simSpinner = ora("Simulating via vault...").start();
+  try {
+    const results = await simulateBatch(calls);
+    const allSucceeded = results.every((r) => r.success);
+    if (allSucceeded) {
+      simSpinner.succeed("Simulation passed");
+    } else {
+      simSpinner.fail("Simulation: some calls failed");
+      for (let i = 0; i < results.length; i++) {
+        const status = results[i].success ? "\u2713" : "\u2717";
+        console.log(`  ${status} Call ${i + 1}`);
+      }
+      if (!opts.execute) {
+        process.exit(1);
+      }
+      console.log(chalk.yellow("Continuing to execution despite simulation failure..."));
+    }
+  } catch (err) {
+    simSpinner.fail("Simulation failed");
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(msg));
+    if (!opts.execute) {
+      process.exit(1);
+    }
+    console.log(chalk.yellow("Continuing to execution despite simulation failure..."));
+  }
+  if (!opts.execute) {
+    console.log();
+    console.log(chalk.yellow("Dry run complete. Add --execute to submit on-chain."));
+    console.log(chalk.dim("  Prerequisite: send WETH to vault before executing."));
+    return;
+  }
+  const execSpinner = ora("Executing batch via vault...").start();
+  try {
+    const txHash = await executeBatch(calls, assetAmount);
+    execSpinner.succeed(`Batch executed: ${txHash}`);
+    console.log(chalk.dim(`  ${getExplorerUrl(txHash)}`));
+  } catch (err) {
+    execSpinner.fail("Execution failed");
+    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+
+// src/lib/factory.ts
+import { decodeEventLog } from "viem";
+function getFactoryAddress() {
+  return SHERWOOD().FACTORY;
+}
+async function createSyndicate(params) {
+  const wallet = getWalletClient();
+  const client = getPublicClient();
+  const hash = await wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getFactoryAddress(),
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "createSyndicate",
+    args: [
+      params.creatorAgentId,
+      {
+        metadataURI: params.metadataURI,
+        asset: params.asset,
+        name: params.name,
+        symbol: params.symbol,
+        caps: {
+          maxPerTx: params.maxPerTx,
+          maxDailyTotal: params.maxDailyTotal,
+          maxBorrowRatio: params.maxBorrowRatio
+        },
+        initialTargets: params.initialTargets,
+        openDeposits: params.openDeposits,
+        subdomain: params.subdomain
+      }
+    ]
+  });
+  const receipt = await client.waitForTransactionReceipt({ hash });
+  for (const log of receipt.logs) {
+    try {
+      const event = decodeEventLog({
+        abi: SYNDICATE_FACTORY_ABI,
+        data: log.data,
+        topics: log.topics
+      });
+      if (event.eventName === "SyndicateCreated") {
+        const args = event.args;
+        return {
+          hash,
+          syndicateId: args.id,
+          vault: args.vault
+        };
+      }
+    } catch {
+    }
+  }
+  const count = await getSyndicateCount();
+  const info = await getSyndicate(count);
+  return {
+    hash,
+    syndicateId: count,
+    vault: info.vault
+  };
+}
+async function getSyndicate(id) {
+  const client = getPublicClient();
+  const result = await client.readContract({
+    address: getFactoryAddress(),
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "syndicates",
+    args: [id]
+  });
+  return {
+    id: result[0],
+    vault: result[1],
+    creator: result[2],
+    metadataURI: result[3],
+    createdAt: result[4],
+    active: result[5],
+    subdomain: result[6]
+  };
+}
+async function getSyndicateCount() {
+  const client = getPublicClient();
+  return client.readContract({
+    address: getFactoryAddress(),
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "syndicateCount"
+  });
+}
+async function getActiveSyndicates() {
+  const client = getPublicClient();
+  const result = await client.readContract({
+    address: getFactoryAddress(),
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "getActiveSyndicates"
+  });
+  return result.map((s) => ({
+    id: s.id,
+    vault: s.vault,
+    creator: s.creator,
+    metadataURI: s.metadataURI,
+    createdAt: s.createdAt,
+    active: s.active,
+    subdomain: s.subdomain
+  }));
+}
+async function updateMetadata(syndicateId, metadataURI) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getFactoryAddress(),
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "updateMetadata",
+    args: [syndicateId, metadataURI]
+  });
+}
+
+// src/lib/subgraph.ts
+function getSubgraphUrl() {
+  const url = process.env.SUBGRAPH_URL;
+  if (!url) {
+    throw new Error(
+      "SUBGRAPH_URL env var is required. Set it to your The Graph Studio query endpoint."
+    );
+  }
+  return url;
+}
+async function query(graphql, variables) {
+  const url = getSubgraphUrl();
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ query: graphql, variables })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Subgraph query failed (${response.status}): ${text}`);
+  }
+  const result = await response.json();
+  if (result.errors?.length) {
+    throw new Error(`Subgraph query error: ${result.errors.map((e) => e.message).join(", ")}`);
+  }
+  if (!result.data) {
+    throw new Error("Subgraph returned no data");
+  }
+  return result.data;
+}
+async function getActiveSyndicates2(creator) {
+  const where = creator ? `where: { active: true, creator: "${creator.toLowerCase()}" }` : `where: { active: true }`;
+  const data = await query(`
+    {
+      syndicates(${where}, orderBy: createdAt, orderDirection: desc, first: 100) {
+        id
+        vault
+        creator
+        metadataURI
+        createdAt
+        active
+        totalDeposits
+        totalWithdrawals
+      }
+    }
+  `);
+  return data.syndicates;
+}
+
+// src/lib/registry.ts
+function getRegistryAddress() {
+  return SHERWOOD().STRATEGY_REGISTRY;
+}
+async function registerStrategy(implementation, strategyTypeId, name, metadataURI) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getRegistryAddress(),
+    abi: STRATEGY_REGISTRY_ABI,
+    functionName: "registerStrategy",
+    args: [implementation, strategyTypeId, name, metadataURI]
+  });
+}
+async function getStrategy(id) {
+  const client = getPublicClient();
+  const result = await client.readContract({
+    address: getRegistryAddress(),
+    abi: STRATEGY_REGISTRY_ABI,
+    functionName: "getStrategy",
+    args: [id]
+  });
+  return {
+    id,
+    implementation: result.implementation,
+    creator: result.creator,
+    strategyTypeId: result.strategyTypeId,
+    active: result.active,
+    name: result.name,
+    metadataURI: result.metadataURI
+  };
+}
+async function listStrategies(typeId) {
+  const client = getPublicClient();
+  const registryAddress = getRegistryAddress();
+  let ids;
+  if (typeId !== void 0) {
+    ids = await client.readContract({
+      address: registryAddress,
+      abi: STRATEGY_REGISTRY_ABI,
+      functionName: "getStrategiesByType",
+      args: [typeId]
+    });
+  } else {
+    const count = await client.readContract({
+      address: registryAddress,
+      abi: STRATEGY_REGISTRY_ABI,
+      functionName: "strategyCount"
+    });
+    ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+  }
+  const strategies = [];
+  for (const id of ids) {
+    const s = await getStrategy(id);
+    strategies.push(s);
+  }
+  return strategies;
+}
+
+// src/lib/ipfs.ts
+var BUNDLED_PINATA_JWT = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySW5mb3JtYXRpb24iOnsiaWQiOiI2NDQ0MGViOC1hYTYyLTQzY2EtOGYwNC04MDZjZmNjY2Y4YTUiLCJlbWFpbCI6ImltdGhhdGNhcmxvc0BnbWFpbC5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwicGluX3BvbGljeSI6eyJyZWdpb25zIjpbeyJkZXNpcmVkUmVwbGljYXRpb25Db3VudCI6MSwiaWQiOiJGUkExIn1dLCJ2ZXJzaW9uIjoxfSwibWZhX2VuYWJsZWQiOmZhbHNlLCJzdGF0dXMiOiJBQ1RJVkUifSwiYXV0aGVudGljYXRpb25UeXBlIjoic2NvcGVkS2V5Iiwic2NvcGVkS2V5S2V5IjoiMWJhZWFmMzQwODM3MGQ0NGZkZWEiLCJzY29wZWRLZXlTZWNyZXQiOiIzNDcxMmU5MTkyYTgxNWFhMGRmNjUyYjYyMDQzODQ1MDJjMmU0YWE0MDhkZTJmOTU2NWYwOTk3YTNlY2U3NGU3IiwiZXhwIjoxODAxMjc2ODExfQ.7OMJiOATpqkSwe7Orrpt2b8H_-czH-W61vBm4AHtqfA";
+function getPinataApiKey() {
+  return process.env.PINATA_API_KEY || BUNDLED_PINATA_JWT;
+}
+async function uploadMetadata(metadata) {
+  const apiKey = getPinataApiKey();
+  const response = await fetch("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      pinataContent: metadata,
+      pinataMetadata: {
+        name: `sherwood-syndicate-${metadata.name.toLowerCase().replace(/\s+/g, "-")}`
+      }
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Pinata upload failed (${response.status}): ${text}`);
+  }
+  const result = await response.json();
+  return `ipfs://${result.IpfsHash}`;
+}
+
+// src/commands/venice.ts
+import { parseUnits as parseUnits5, formatUnits as formatUnits3, isAddress as isAddress2 } from "viem";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/strategies/venice-fund.ts
+import { encodeFunctionData as encodeFunctionData3, parseUnits as parseUnits4 } from "viem";
+var ERC20_ABI3 = [
+  {
+    name: "approve",
+    type: "function",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI = [
+  {
+    name: "exactInputSingle",
+    type: "function",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+var SWAP_ROUTER_EXACT_INPUT_ABI = [
+  {
+    name: "exactInput",
+    type: "function",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "path", type: "bytes" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+var STAKING_ABI = [
+  {
+    name: "stake",
+    type: "function",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minVVV, swapPath) {
+  const ZERO = "0x0000000000000000000000000000000000000000";
+  if (VENICE().VVV === ZERO || VENICE().STAKING === ZERO) {
+    throw new Error("Venice (VVV/sVVV) is not deployed on this network \u2014 venice fund requires Venice staking contracts");
+  }
+  const assetAmount = parseUnits4(config.amount, assetDecimals);
+  const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
+  const calls = [];
+  calls.push({
+    target: assetAddress,
+    data: encodeFunctionData3({
+      abi: ERC20_ABI3,
+      functionName: "approve",
+      args: [UNISWAP().SWAP_ROUTER, assetAmount]
+    }),
+    value: 0n
+  });
+  if (isWeth) {
+    calls.push({
+      target: UNISWAP().SWAP_ROUTER,
+      data: encodeFunctionData3({
+        abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
+        functionName: "exactInputSingle",
+        args: [
+          {
+            tokenIn: TOKENS().WETH,
+            tokenOut: VENICE().VVV,
+            fee: config.fee2,
+            recipient: vaultAddress,
+            amountIn: assetAmount,
+            amountOutMinimum: minVVV,
+            sqrtPriceLimitX96: 0n
+          }
+        ]
+      }),
+      value: 0n
+    });
+  } else {
+    calls.push({
+      target: UNISWAP().SWAP_ROUTER,
+      data: encodeFunctionData3({
+        abi: SWAP_ROUTER_EXACT_INPUT_ABI,
+        functionName: "exactInput",
+        args: [
+          {
+            path: swapPath,
+            recipient: vaultAddress,
+            amountIn: assetAmount,
+            amountOutMinimum: minVVV
+          }
+        ]
+      }),
+      value: 0n
+    });
+  }
+  calls.push({
+    target: VENICE().VVV,
+    data: encodeFunctionData3({
+      abi: ERC20_ABI3,
+      functionName: "approve",
+      args: [VENICE().STAKING, minVVV]
+    }),
+    value: 0n
+  });
+  const perAgent = minVVV / BigInt(agents.length);
+  for (const agent of agents) {
+    calls.push({
+      target: VENICE().STAKING,
+      data: encodeFunctionData3({
+        abi: STAKING_ABI,
+        functionName: "stake",
+        args: [agent, perAgent]
+      }),
+      value: 0n
+    });
+  }
+  return calls;
+}
+
+// src/lib/venice.ts
+var VENICE_API_BASE = "https://api.venice.ai/api/v1";
+async function provisionApiKey() {
+  const account = getAccount();
+  const tokenRes = await fetch(`${VENICE_API_BASE}/api_keys/generate_web3_key`);
+  if (!tokenRes.ok) {
+    throw new Error(`Failed to get validation token: ${tokenRes.status} ${tokenRes.statusText}`);
+  }
+  const tokenData = await tokenRes.json();
+  const token = tokenData.data.token;
+  const signature = await account.signMessage({ message: token });
+  const keyRes = await fetch(`${VENICE_API_BASE}/api_keys/generate_web3_key`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      address: account.address,
+      signature,
+      token,
+      apiKeyType: "INFERENCE",
+      description: "Sherwood syndicate agent"
+    })
+  });
+  if (!keyRes.ok) {
+    const body = await keyRes.text();
+    throw new Error(`Failed to generate API key: ${keyRes.status} ${body}`);
+  }
+  const keyData = await keyRes.json();
+  const apiKey = keyData.data.apiKey;
+  setVeniceApiKey(apiKey);
+  return apiKey;
+}
+async function checkApiKeyValid() {
+  const apiKey = getVeniceApiKey();
+  if (!apiKey) return false;
+  try {
+    const res = await fetch(`${VENICE_API_BASE}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/venice.ts
+var VALID_FEES2 = [500, 3e3, 1e4];
+function registerVeniceCommands(program2) {
+  const venice = program2.command("venice").description("Venice private inference \u2014 stake VVV, provision API keys");
+  venice.command("fund").description("Swap vault profits \u2192 VVV \u2192 stake \u2192 distribute sVVV to agents").requiredOption("--vault <address>", "Vault address").requiredOption("--amount <amount>", "Deposit token amount to convert (e.g. 500)").option("--fee1 <tier>", "Fee tier for asset \u2192 WETH hop (500, 3000, 10000)", "3000").option("--fee2 <tier>", "Fee tier for WETH \u2192 VVV hop", "10000").option("--slippage <bps>", "Slippage tolerance in bps", "100").option("--execute", "Execute on-chain (default: simulate only)", false).action(async (opts) => {
+    const vaultAddress = opts.vault;
+    if (!isAddress2(vaultAddress)) {
+      console.error(chalk2.red(`Invalid vault address: ${opts.vault}`));
+      process.exit(1);
+    }
+    const fee1 = Number(opts.fee1);
+    const fee2 = Number(opts.fee2);
+    if (!VALID_FEES2.includes(fee1) || !VALID_FEES2.includes(fee2)) {
+      console.error(chalk2.red(`Invalid fee tier. Valid: ${VALID_FEES2.join(", ")}`));
+      process.exit(1);
+    }
+    const slippageBps = Number(opts.slippage);
+    const client = getPublicClient();
+    const spinner = ora2("Reading vault state...").start();
+    let assetAddress;
+    let assetDecimals;
+    let assetSymbol;
+    let totalDeposited;
+    let assetBalance;
+    let agents;
+    try {
+      [assetAddress, totalDeposited, agents] = await Promise.all([
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "asset" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "totalDeposited" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "getAgentOperators" })
+      ]);
+      [assetDecimals, assetSymbol, assetBalance] = await Promise.all([
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "decimals" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "symbol" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "balanceOf", args: [vaultAddress] })
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail("Failed to read vault state");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (agents.length === 0) {
+      console.error(chalk2.red("No agents registered in vault. Register agents first."));
+      process.exit(1);
+    }
+    const requestedAmount = parseUnits5(opts.amount, assetDecimals);
+    const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
+    const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
+    console.log();
+    console.log(chalk2.bold("Venice Fund"));
+    console.log(chalk2.dim("\u2500".repeat(40)));
+    console.log(`  Asset:         ${assetSymbol} (${assetDecimals} decimals)`);
+    console.log(`  Amount:        ${opts.amount} ${assetSymbol}`);
+    console.log(`  Vault balance: ${formatUnits3(assetBalance, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Deposited:     ${formatUnits3(totalDeposited, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Profit:        ${formatUnits3(profit, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Agents:        ${agents.length} (sVVV will be split equally)`);
+    console.log(`  Routing:       ${isWeth ? `WETH \u2192 VVV (fee ${fee2})` : `${assetSymbol} \u2192 WETH (fee ${fee1}) \u2192 VVV (fee ${fee2})`}`);
+    console.log(`  Slippage:      ${(slippageBps / 100).toFixed(2)}%`);
+    console.log(`  Vault:         ${vaultAddress}`);
+    console.log();
+    if (requestedAmount > profit) {
+      console.warn(chalk2.yellow(`  Warning: amount (${opts.amount}) exceeds available profit (${formatUnits3(profit, assetDecimals)})`));
+      console.warn(chalk2.yellow("  This will use deposited capital, not just profits."));
+      console.log();
+    }
+    const quoteSpinner = ora2("Fetching Uniswap quote...").start();
+    let amountOut;
+    let minOut;
+    let swapPath = null;
+    try {
+      if (isWeth) {
+        const quote = await getQuote({
+          tokenIn: TOKENS().WETH,
+          tokenOut: VENICE().VVV,
+          amountIn: requestedAmount,
+          fee: fee2
+        });
+        amountOut = quote.amountOut;
+      } else {
+        swapPath = encodeSwapPath(
+          [assetAddress, TOKENS().WETH, VENICE().VVV],
+          [fee1, fee2]
+        );
+        const quote = await getMultiHopQuote({
+          path: swapPath,
+          amountIn: requestedAmount
+        });
+        amountOut = quote.amountOut;
+      }
+      minOut = applySlippage(amountOut, slippageBps);
+      quoteSpinner.succeed(
+        `Quote: ${formatUnits3(amountOut, 18)} VVV (min: ${formatUnits3(minOut, 18)}, per agent: ${formatUnits3(minOut / BigInt(agents.length), 18)})`
+      );
+    } catch (err) {
+      quoteSpinner.fail("Failed to fetch quote");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const config = {
+      amount: opts.amount,
+      fee1,
+      fee2,
+      slippageBps
+    };
+    const calls = buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minOut, swapPath);
+    console.log();
+    console.log(chalk2.bold(`Batch calls (${calls.length}):`));
+    console.log(formatBatch(calls));
+    console.log();
+    const simSpinner = ora2("Simulating via vault...").start();
+    try {
+      const results = await simulateBatch(calls);
+      const allSucceeded = results.every((r) => r.success);
+      if (allSucceeded) {
+        simSpinner.succeed("Simulation passed");
+      } else {
+        simSpinner.fail("Simulation: some calls failed");
+        for (let i = 0; i < results.length; i++) {
+          const status = results[i].success ? "ok" : "FAIL";
+          console.log(`  ${status} Call ${i + 1}`);
+        }
+        if (!opts.execute) process.exit(1);
+        console.log(chalk2.yellow("Continuing to execution despite simulation failure..."));
+      }
+    } catch (err) {
+      simSpinner.fail("Simulation failed");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      if (!opts.execute) process.exit(1);
+      console.log(chalk2.yellow("Continuing to execution despite simulation failure..."));
+    }
+    if (!opts.execute) {
+      console.log();
+      console.log(chalk2.yellow("Dry run complete. Add --execute to submit on-chain."));
+      return;
+    }
+    const execSpinner = ora2("Executing batch via vault...").start();
+    try {
+      const txHash = await executeBatch(calls, requestedAmount);
+      execSpinner.succeed(`Batch executed: ${txHash}`);
+      console.log(chalk2.dim(`  ${getExplorerUrl(txHash)}`));
+    } catch (err) {
+      execSpinner.fail("Execution failed");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  venice.command("provision").description("Self-provision a Venice API key (requires sVVV in wallet)").action(async () => {
+    const account = getAccount();
+    const client = getPublicClient();
+    const checkSpinner = ora2("Checking sVVV balance...").start();
+    try {
+      const sVvvBalance = await client.readContract({
+        address: VENICE().STAKING,
+        abi: VENICE_STAKING_ABI,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+      if (sVvvBalance === 0n) {
+        checkSpinner.fail("No sVVV found in wallet");
+        console.log(chalk2.yellow("  Your wallet must hold staked VVV (sVVV) to provision a Venice API key."));
+        console.log(chalk2.yellow("  Run 'sherwood venice fund' first to distribute sVVV to agents."));
+        process.exit(1);
+      }
+      checkSpinner.succeed(`sVVV balance: ${formatUnits3(sVvvBalance, 18)}`);
+    } catch (err) {
+      checkSpinner.fail("Failed to check sVVV balance");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const keySpinner = ora2("Provisioning Venice API key...").start();
+    try {
+      const apiKey = await provisionApiKey();
+      keySpinner.succeed("Venice API key provisioned");
+      console.log(chalk2.dim(`  Key: ${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`));
+      console.log(chalk2.dim("  Saved to ~/.sherwood/config.json"));
+    } catch (err) {
+      keySpinner.fail("Failed to provision API key");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  venice.command("status").description("Show Venice inference status: sVVV balances, DIEM, API key").requiredOption("--vault <address>", "Vault address").action(async (opts) => {
+    const vaultAddress = opts.vault;
+    if (!isAddress2(vaultAddress)) {
+      console.error(chalk2.red(`Invalid vault address: ${opts.vault}`));
+      process.exit(1);
+    }
+    const client = getPublicClient();
+    const account = getAccount();
+    const spinner = ora2("Loading Venice status...").start();
+    try {
+      const [assetAddress, totalDeposited, agents] = await Promise.all([
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "asset" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "totalDeposited" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "getAgentOperators" })
+      ]);
+      const [assetDecimals, assetSymbol, assetBalance] = await Promise.all([
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "decimals" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "symbol" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "balanceOf", args: [vaultAddress] })
+      ]);
+      const vaultVvvBalance = await client.readContract({
+        address: VENICE().VVV,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [vaultAddress]
+      });
+      const agentBalances = await Promise.all(
+        agents.map(async (agent) => {
+          const bal = await client.readContract({
+            address: VENICE().STAKING,
+            abi: VENICE_STAKING_ABI,
+            functionName: "balanceOf",
+            args: [agent]
+          });
+          return { agent, balance: bal };
+        })
+      );
+      const [mySvvv, myPending] = await Promise.all([
+        client.readContract({
+          address: VENICE().STAKING,
+          abi: VENICE_STAKING_ABI,
+          functionName: "balanceOf",
+          args: [account.address]
+        }),
+        client.readContract({
+          address: VENICE().STAKING,
+          abi: VENICE_STAKING_ABI,
+          functionName: "pendingRewards",
+          args: [account.address]
+        })
+      ]);
+      const apiKeyValid = await checkApiKeyValid();
+      const apiKey = getVeniceApiKey();
+      spinner.stop();
+      const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
+      console.log();
+      console.log(chalk2.bold("Venice Inference Status"));
+      console.log(chalk2.dim("\u2500".repeat(50)));
+      console.log(chalk2.bold("\n  Vault"));
+      console.log(`    Profit available:  ${formatUnits3(profit, assetDecimals)} ${assetSymbol}`);
+      console.log(`    VVV (unstaked):    ${formatUnits3(vaultVvvBalance, 18)}`);
+      console.log(chalk2.bold("\n  Agent sVVV Balances"));
+      for (const { agent, balance } of agentBalances) {
+        const isMe = agent.toLowerCase() === account.address.toLowerCase();
+        const label = isMe ? chalk2.green(`${agent} (you)`) : agent;
+        console.log(`    ${label}: ${formatUnits3(balance, 18)} sVVV`);
+      }
+      console.log(chalk2.bold("\n  Your Wallet"));
+      console.log(`    sVVV:              ${formatUnits3(mySvvv, 18)}`);
+      console.log(`    Pending rewards:   ${formatUnits3(myPending, 18)} VVV`);
+      console.log(chalk2.bold("\n  Venice API"));
+      console.log(`    Key:     ${apiKey ? `${apiKey.slice(0, 8)}...${apiKey.slice(-4)}` : chalk2.dim("not provisioned")}`);
+      console.log(`    Status:  ${apiKeyValid ? chalk2.green("valid") : chalk2.red("invalid/missing")}`);
+      console.log();
+    } catch (err) {
+      spinner.fail("Failed to load status");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/allowance.ts
+import { parseUnits as parseUnits7, formatUnits as formatUnits4, isAddress as isAddress3 } from "viem";
+import chalk3 from "chalk";
+import ora3 from "ora";
+
+// src/strategies/allowance-disburse.ts
+import { encodeFunctionData as encodeFunctionData4, parseUnits as parseUnits6 } from "viem";
+var ERC20_ABI4 = [
+  {
+    name: "approve",
+    type: "function",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI2 = [
+  {
+    name: "exactInputSingle",
+    type: "function",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+var SWAP_ROUTER_EXACT_INPUT_ABI2 = [
+  {
+    name: "exactInput",
+    type: "function",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "path", type: "bytes" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minUsdc, swapPath) {
+  const assetAmount = parseUnits6(config.amount, assetDecimals);
+  const isUsdc = assetAddress.toLowerCase() === TOKENS().USDC.toLowerCase();
+  const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
+  const calls = [];
+  if (!isUsdc) {
+    calls.push({
+      target: assetAddress,
+      data: encodeFunctionData4({
+        abi: ERC20_ABI4,
+        functionName: "approve",
+        args: [UNISWAP().SWAP_ROUTER, assetAmount]
+      }),
+      value: 0n
+    });
+    if (isWeth) {
+      calls.push({
+        target: UNISWAP().SWAP_ROUTER,
+        data: encodeFunctionData4({
+          abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI2,
+          functionName: "exactInputSingle",
+          args: [
+            {
+              tokenIn: TOKENS().WETH,
+              tokenOut: TOKENS().USDC,
+              fee: config.fee,
+              recipient: vaultAddress,
+              amountIn: assetAmount,
+              amountOutMinimum: minUsdc,
+              sqrtPriceLimitX96: 0n
+            }
+          ]
+        }),
+        value: 0n
+      });
+    } else {
+      calls.push({
+        target: UNISWAP().SWAP_ROUTER,
+        data: encodeFunctionData4({
+          abi: SWAP_ROUTER_EXACT_INPUT_ABI2,
+          functionName: "exactInput",
+          args: [
+            {
+              path: swapPath,
+              recipient: vaultAddress,
+              amountIn: assetAmount,
+              amountOutMinimum: minUsdc
+            }
+          ]
+        }),
+        value: 0n
+      });
+    }
+  }
+  const perAgent = minUsdc / BigInt(agents.length);
+  for (const agent of agents) {
+    calls.push({
+      target: TOKENS().USDC,
+      data: encodeFunctionData4({
+        abi: ERC20_ABI4,
+        functionName: "transfer",
+        args: [agent, perAgent]
+      }),
+      value: 0n
+    });
+  }
+  return calls;
+}
+
+// src/commands/allowance.ts
+var VALID_FEES3 = [500, 3e3, 1e4];
+function registerAllowanceCommands(program2) {
+  const allowance = program2.command("allowance").description("Disburse vault profits to agent wallets");
+  allowance.command("disburse").description("Swap vault profits \u2192 USDC \u2192 distribute to all agent operator wallets").requiredOption("--vault <address>", "Vault address").requiredOption("--amount <amount>", "Deposit token amount to convert & distribute (e.g. 500)").option("--fee <tier>", "Fee tier for asset \u2192 USDC swap (500, 3000, 10000)", "3000").option("--slippage <bps>", "Slippage tolerance in bps", "100").option("--execute", "Execute on-chain (default: simulate only)", false).action(async (opts) => {
+    const vaultAddress = opts.vault;
+    if (!isAddress3(vaultAddress)) {
+      console.error(chalk3.red(`Invalid vault address: ${opts.vault}`));
+      process.exit(1);
+    }
+    const fee = Number(opts.fee);
+    if (!VALID_FEES3.includes(fee)) {
+      console.error(chalk3.red(`Invalid fee tier. Valid: ${VALID_FEES3.join(", ")}`));
+      process.exit(1);
+    }
+    const slippageBps = Number(opts.slippage);
+    const client = getPublicClient();
+    const spinner = ora3("Reading vault state...").start();
+    let assetAddress;
+    let assetDecimals;
+    let assetSymbol;
+    let totalDeposited;
+    let assetBalance;
+    let agents;
+    try {
+      [assetAddress, totalDeposited, agents] = await Promise.all([
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "asset" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "totalDeposited" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "getAgentOperators" })
+      ]);
+      [assetDecimals, assetSymbol, assetBalance] = await Promise.all([
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "decimals" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "symbol" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "balanceOf", args: [vaultAddress] })
+      ]);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail("Failed to read vault state");
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (agents.length === 0) {
+      console.error(chalk3.red("No agents registered in vault. Register agents first."));
+      process.exit(1);
+    }
+    const requestedAmount = parseUnits7(opts.amount, assetDecimals);
+    const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
+    const isUsdc = assetAddress.toLowerCase() === TOKENS().USDC.toLowerCase();
+    const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
+    console.log();
+    console.log(chalk3.bold("Allowance Disburse"));
+    console.log(chalk3.dim("\u2500".repeat(40)));
+    console.log(`  Asset:         ${assetSymbol} (${assetDecimals} decimals)`);
+    console.log(`  Amount:        ${opts.amount} ${assetSymbol}`);
+    console.log(`  Vault balance: ${formatUnits4(assetBalance, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Deposited:     ${formatUnits4(totalDeposited, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Profit:        ${formatUnits4(profit, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Agents:        ${agents.length} (USDC will be split equally)`);
+    if (!isUsdc) {
+      console.log(`  Routing:       ${isWeth ? `WETH \u2192 USDC (fee ${fee})` : `${assetSymbol} \u2192 WETH \u2192 USDC (fee ${fee})`}`);
+      console.log(`  Slippage:      ${(slippageBps / 100).toFixed(2)}%`);
+    }
+    console.log(`  Vault:         ${vaultAddress}`);
+    console.log();
+    if (requestedAmount > profit) {
+      console.warn(chalk3.yellow(`  Warning: amount (${opts.amount}) exceeds available profit (${formatUnits4(profit, assetDecimals)})`));
+      console.warn(chalk3.yellow("  This will use deposited capital, not just profits."));
+      console.log();
+    }
+    let minUsdc;
+    let swapPath = null;
+    if (isUsdc) {
+      minUsdc = requestedAmount;
+    } else {
+      const quoteSpinner = ora3("Fetching Uniswap quote...").start();
+      try {
+        let amountOut;
+        if (isWeth) {
+          const quote = await getQuote({
+            tokenIn: TOKENS().WETH,
+            tokenOut: TOKENS().USDC,
+            amountIn: requestedAmount,
+            fee
+          });
+          amountOut = quote.amountOut;
+        } else {
+          swapPath = encodeSwapPath(
+            [assetAddress, TOKENS().WETH, TOKENS().USDC],
+            [fee, 500]
+            // WETH→USDC typically uses 500 (0.05%) fee tier
+          );
+          const quote = await getMultiHopQuote({
+            path: swapPath,
+            amountIn: requestedAmount
+          });
+          amountOut = quote.amountOut;
+        }
+        minUsdc = applySlippage(amountOut, slippageBps);
+        quoteSpinner.succeed(
+          `Quote: ${formatUnits4(amountOut, 6)} USDC (min: ${formatUnits4(minUsdc, 6)}, per agent: ${formatUnits4(minUsdc / BigInt(agents.length), 6)})`
+        );
+      } catch (err) {
+        quoteSpinner.fail("Failed to fetch quote");
+        console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+    const perAgent = minUsdc / BigInt(agents.length);
+    if (isUsdc) {
+      console.log(chalk3.dim(`  Per agent: ${formatUnits4(perAgent, 6)} USDC`));
+      console.log();
+    }
+    const config = {
+      amount: opts.amount,
+      fee,
+      slippageBps
+    };
+    const calls = buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minUsdc, swapPath);
+    console.log();
+    console.log(chalk3.bold(`Batch calls (${calls.length}):`));
+    console.log(formatBatch(calls));
+    console.log();
+    const simSpinner = ora3("Simulating via vault...").start();
+    try {
+      const results = await simulateBatch(calls);
+      const allSucceeded = results.every((r) => r.success);
+      if (allSucceeded) {
+        simSpinner.succeed("Simulation passed");
+      } else {
+        simSpinner.fail("Simulation: some calls failed");
+        for (let i = 0; i < results.length; i++) {
+          const status = results[i].success ? "ok" : "FAIL";
+          console.log(`  ${status} Call ${i + 1}`);
+        }
+        if (!opts.execute) process.exit(1);
+        console.log(chalk3.yellow("Continuing to execution despite simulation failure..."));
+      }
+    } catch (err) {
+      simSpinner.fail("Simulation failed");
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      if (!opts.execute) process.exit(1);
+      console.log(chalk3.yellow("Continuing to execution despite simulation failure..."));
+    }
+    if (!opts.execute) {
+      console.log();
+      console.log(chalk3.yellow("Dry run complete. Add --execute to submit on-chain."));
+      return;
+    }
+    const execSpinner = ora3("Executing batch via vault...").start();
+    try {
+      const txHash = await executeBatch(calls, requestedAmount);
+      execSpinner.succeed(`Batch executed: ${txHash}`);
+      console.log(chalk3.dim(`  ${getExplorerUrl(txHash)}`));
+    } catch (err) {
+      execSpinner.fail("Execution failed");
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  allowance.command("status").description("Show vault profit and agent USDC balances").requiredOption("--vault <address>", "Vault address").action(async (opts) => {
+    const vaultAddress = opts.vault;
+    if (!isAddress3(vaultAddress)) {
+      console.error(chalk3.red(`Invalid vault address: ${opts.vault}`));
+      process.exit(1);
+    }
+    const client = getPublicClient();
+    const spinner = ora3("Loading allowance status...").start();
+    try {
+      const [assetAddress, totalDeposited, agents] = await Promise.all([
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "asset" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "totalDeposited" }),
+        client.readContract({ address: vaultAddress, abi: SYNDICATE_VAULT_ABI, functionName: "getAgentOperators" })
+      ]);
+      const [assetDecimals, assetSymbol, assetBalance] = await Promise.all([
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "decimals" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "symbol" }),
+        client.readContract({ address: assetAddress, abi: ERC20_ABI, functionName: "balanceOf", args: [vaultAddress] })
+      ]);
+      const agentBalances = await Promise.all(
+        agents.map(async (agent) => {
+          const bal = await client.readContract({
+            address: TOKENS().USDC,
+            abi: ERC20_ABI,
+            functionName: "balanceOf",
+            args: [agent]
+          });
+          return { agent, balance: bal };
+        })
+      );
+      spinner.stop();
+      const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
+      const account = getAccount();
+      console.log();
+      console.log(chalk3.bold("Allowance Status"));
+      console.log(chalk3.dim("\u2500".repeat(50)));
+      console.log(chalk3.bold("\n  Vault"));
+      console.log(`    Asset:           ${assetSymbol}`);
+      console.log(`    Balance:         ${formatUnits4(assetBalance, assetDecimals)} ${assetSymbol}`);
+      console.log(`    Deposited:       ${formatUnits4(totalDeposited, assetDecimals)} ${assetSymbol}`);
+      console.log(`    Profit:          ${formatUnits4(profit, assetDecimals)} ${assetSymbol}`);
+      console.log(chalk3.bold("\n  Agent USDC Balances"));
+      for (const { agent, balance } of agentBalances) {
+        const isMe = agent.toLowerCase() === account.address.toLowerCase();
+        const label = isMe ? chalk3.green(`${agent} (you)`) : agent;
+        console.log(`    ${label}: ${formatUnits4(balance, 6)} USDC`);
+      }
+      console.log();
+    } catch (err) {
+      spinner.fail("Failed to load status");
+      console.error(chalk3.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/identity.ts
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { SDK } from "agent0-sdk";
+var IDENTITY_REGISTRY_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+function getAgent0SDK() {
+  const config = loadConfig();
+  const key = config.privateKey || process.env.PRIVATE_KEY;
+  if (!key) {
+    throw new Error(
+      "Private key not found. Run 'sherwood config set --private-key <key>' or set PRIVATE_KEY env var."
+    );
+  }
+  return new SDK({
+    chainId: getChain().id,
+    rpcUrl: getRpcUrl(),
+    privateKey: key.startsWith("0x") ? key : `0x${key}`
+  });
+}
+function registerIdentityCommands(program2) {
+  const identity = program2.command("identity").description("Manage ERC-8004 agent identity (via Agent0 SDK)");
+  identity.command("mint").description("Register a new ERC-8004 agent identity (required before creating/joining syndicates)").requiredOption("--name <name>", "Agent name (e.g. 'Alpha Seeker Agent')").option("--description <desc>", "Agent description", "Sherwood syndicate agent").option("--image <uri>", "Agent image URI (IPFS recommended)").action(async (opts) => {
+    const account = getAccount();
+    const existingId = getAgentId();
+    if (existingId) {
+      console.log(chalk4.yellow(`You already have an agent identity saved: #${existingId}`));
+      console.log(chalk4.dim("  Minting a new one anyway. The old ID is not affected."));
+      console.log();
+    }
+    const spinner = ora4("Initializing Agent0 SDK...").start();
+    try {
+      const sdk = getAgent0SDK();
+      spinner.text = "Creating agent profile...";
+      const agent = sdk.createAgent(opts.name, opts.description, opts.image);
+      spinner.text = "Registering on-chain (minting ERC-8004 identity)...";
+      const txHandle = await agent.registerOnChain();
+      spinner.text = "Waiting for confirmation...";
+      await txHandle.waitMined();
+      const agentId = agent.agentId;
+      if (!agentId) {
+        spinner.warn("Identity registered but could not read agentId");
+        console.log(chalk4.dim("  Check the transaction on the explorer."));
+        return;
+      }
+      const tokenId = Number(agentId.includes(":") ? agentId.split(":")[1] : agentId);
+      setAgentId(tokenId);
+      spinner.succeed(`Agent identity registered: #${tokenId}`);
+      console.log(chalk4.dim(`  Agent0 ID: ${agentId}`));
+      console.log(chalk4.dim(`  Name:      ${opts.name}`));
+      console.log(chalk4.dim(`  Owner:     ${account.address}`));
+      console.log(chalk4.dim(`  Saved to   ~/.sherwood/config.json`));
+      console.log();
+      console.log(chalk4.green("You can now create syndicates:"));
+      console.log(chalk4.dim(`  sherwood syndicate create --agent-id ${tokenId} --subdomain <name> --name <name>`));
+    } catch (err) {
+      spinner.fail("Failed to register identity");
+      console.error(chalk4.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("load").description("Load an existing ERC-8004 agent identity into your config").requiredOption("--id <tokenId>", "Agent token ID to load").action(async (opts) => {
+    const account = getAccount();
+    const client = getPublicClient();
+    const registry = AGENT_REGISTRY().IDENTITY_REGISTRY;
+    const tokenId = Number(opts.id);
+    const spinner = ora4(`Verifying ownership of agent #${tokenId}...`).start();
+    try {
+      const owner = await client.readContract({
+        address: registry,
+        abi: IDENTITY_REGISTRY_ABI,
+        functionName: "ownerOf",
+        args: [BigInt(tokenId)]
+      });
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        spinner.fail(`Agent #${tokenId} is owned by ${owner}, not your wallet`);
+        process.exit(1);
+      }
+      setAgentId(tokenId);
+      spinner.succeed(`Agent #${tokenId} loaded and saved to config`);
+      console.log(chalk4.dim(`  Owner:  ${account.address}`));
+      console.log(chalk4.dim(`  Saved to ~/.sherwood/config.json`));
+    } catch (err) {
+      spinner.fail("Failed to load identity");
+      console.error(chalk4.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("status").description("Show your agent identity status").action(async () => {
+    const account = getAccount();
+    const registry = AGENT_REGISTRY().IDENTITY_REGISTRY;
+    const client = getPublicClient();
+    const spinner = ora4("Checking identity...").start();
+    try {
+      const balance = await client.readContract({
+        address: registry,
+        abi: IDENTITY_REGISTRY_ABI,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+      spinner.stop();
+      const savedId = getAgentId();
+      console.log();
+      console.log(chalk4.bold("Agent Identity (ERC-8004)"));
+      console.log(chalk4.dim("\u2500".repeat(40)));
+      console.log(`  Wallet:     ${account.address}`);
+      console.log(`  Registry:   ${registry}`);
+      console.log(`  NFTs owned: ${balance.toString()}`);
+      if (savedId) {
+        try {
+          const owner = await client.readContract({
+            address: registry,
+            abi: IDENTITY_REGISTRY_ABI,
+            functionName: "ownerOf",
+            args: [BigInt(savedId)]
+          });
+          const isOwner = owner.toLowerCase() === account.address.toLowerCase();
+          console.log(`  Saved ID:   #${savedId} ${isOwner ? chalk4.green("(verified)") : chalk4.red("(owned by " + owner + ")")}`);
+          if (isOwner) {
+            try {
+              const sdk = getAgent0SDK();
+              const agent = await sdk.loadAgent(`${getChain().id}:${savedId}`);
+              if (agent.name) console.log(`  Name:       ${agent.name}`);
+              if (agent.description) console.log(`  Desc:       ${chalk4.dim(agent.description)}`);
+              if (agent.walletAddress) console.log(`  Wallet:     ${agent.walletAddress}`);
+            } catch {
+            }
+          }
+        } catch {
+          console.log(`  Saved ID:   #${savedId} ${chalk4.red("(token not found)")}`);
+        }
+      } else {
+        console.log(`  Saved ID:   ${chalk4.dim("none \u2014 run 'sherwood identity mint --name <name>'")}`);
+      }
+      console.log();
+    } catch (err) {
+      spinner.fail("Failed to check identity");
+      console.error(chalk4.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/lib/eas.ts
+import { encodeAbiParameters, parseAbiParameters, decodeAbiParameters } from "viem";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var JOIN_REQUEST_PARAMS = parseAbiParameters("uint256, uint256, address, string");
+var AGENT_APPROVED_PARAMS = parseAbiParameters("uint256, uint256, address");
+function assertSchemasRegistered() {
+  const schemas = EAS_SCHEMAS();
+  if (schemas.SYNDICATE_JOIN_REQUEST === ZERO_BYTES32 || schemas.AGENT_APPROVED === ZERO_BYTES32) {
+    throw new Error(
+      "EAS schemas not registered. Run: npx tsx scripts/register-eas-schemas.ts --testnet"
+    );
+  }
+}
+function getEasGraphqlUrl() {
+  return getNetwork() === "base" ? "https://base.easscan.org/graphql" : "https://base-sepolia.easscan.org/graphql";
+}
+function getEasScanUrl(uid) {
+  const host = getNetwork() === "base" ? "base.easscan.org" : "base-sepolia.easscan.org";
+  return `https://${host}/attestation/view/${uid}`;
+}
+function extractAttestationUid(receipt) {
+  for (const log of receipt.logs) {
+    if (log.topics.length === 4 && log.data.length >= 66) {
+      return "0x" + log.data.slice(2, 66);
+    }
+  }
+  throw new Error("Could not extract attestation UID from transaction receipt");
+}
+async function createJoinRequest(syndicateId, agentId, vault, creatorAddress, message) {
+  assertSchemasRegistered();
+  const wallet = getWalletClient();
+  const client = getPublicClient();
+  const data = encodeAbiParameters(JOIN_REQUEST_PARAMS, [
+    syndicateId,
+    agentId,
+    vault,
+    message
+  ]);
+  const hash = await wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: EAS_CONTRACTS().EAS,
+    abi: EAS_ABI,
+    functionName: "attest",
+    args: [{
+      schema: EAS_SCHEMAS().SYNDICATE_JOIN_REQUEST,
+      data: {
+        recipient: creatorAddress,
+        expirationTime: 0n,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data,
+        value: 0n
+      }
+    }],
+    value: 0n
+  });
+  const receipt = await client.waitForTransactionReceipt({ hash });
+  const uid = extractAttestationUid(receipt);
+  return { uid, hash };
+}
+async function createApproval(syndicateId, agentId, vault, agentAddress) {
+  assertSchemasRegistered();
+  const wallet = getWalletClient();
+  const client = getPublicClient();
+  const data = encodeAbiParameters(AGENT_APPROVED_PARAMS, [
+    syndicateId,
+    agentId,
+    vault
+  ]);
+  const hash = await wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: EAS_CONTRACTS().EAS,
+    abi: EAS_ABI,
+    functionName: "attest",
+    args: [{
+      schema: EAS_SCHEMAS().AGENT_APPROVED,
+      data: {
+        recipient: agentAddress,
+        expirationTime: 0n,
+        revocable: true,
+        refUID: ZERO_BYTES32,
+        data,
+        value: 0n
+      }
+    }],
+    value: 0n
+  });
+  const receipt = await client.waitForTransactionReceipt({ hash });
+  const uid = extractAttestationUid(receipt);
+  return { uid, hash };
+}
+async function revokeAttestation(schemaUid, attestationUid) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: EAS_CONTRACTS().EAS,
+    abi: EAS_ABI,
+    functionName: "revoke",
+    args: [{
+      schema: schemaUid,
+      data: {
+        uid: attestationUid,
+        value: 0n
+      }
+    }],
+    value: 0n
+  });
+}
+async function queryJoinRequests(recipient) {
+  assertSchemasRegistered();
+  const schemaUid = EAS_SCHEMAS().SYNDICATE_JOIN_REQUEST;
+  const url = getEasGraphqlUrl();
+  const query2 = `
+    query JoinRequests($schemaId: String!, $recipient: String!) {
+      attestations(
+        where: {
+          schemaId: { equals: $schemaId }
+          recipient: { equals: $recipient }
+          revoked: { equals: false }
+        }
+        orderBy: [{ time: desc }]
+      ) {
+        id
+        attester
+        recipient
+        time
+        data
+      }
+    }
+  `;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      query: query2,
+      variables: { schemaId: schemaUid, recipient }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`EAS GraphQL query failed: ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (!json.data?.attestations) return [];
+  return json.data.attestations.map((a) => {
+    const decoded = decodeAbiParameters(JOIN_REQUEST_PARAMS, a.data);
+    return {
+      uid: a.id,
+      attester: a.attester,
+      recipient: a.recipient,
+      time: a.time,
+      decoded: {
+        syndicateId: decoded[0],
+        agentId: decoded[1],
+        vault: decoded[2],
+        message: decoded[3]
+      }
+    };
+  });
+}
+
+// src/index.ts
+try {
+  loadDotenv();
+} catch {
+}
+async function loadXmtp() {
+  return import("./xmtp-2UPH45XE.js");
+}
+var G = chalk5.green;
+var W = chalk5.white;
+var DIM = chalk5.gray;
+var BOLD = chalk5.white.bold;
+var LABEL = chalk5.green.bold;
+var SEP = () => console.log(DIM("\u2500".repeat(60)));
+function resolveVault(opts) {
+  if (opts.vault) {
+    setVaultAddress(opts.vault);
+  }
+}
+var program = new Command();
+program.name("sherwood").description("CLI for agent-managed investment syndicates").version("0.1.0").option("--testnet", "Use Base Sepolia testnet instead of Base mainnet", false).hook("preAction", (thisCommand) => {
+  const opts = thisCommand.optsWithGlobals();
+  setNetwork(opts.testnet ? "base-sepolia" : "base");
+  if (opts.testnet) {
+    console.log(chalk5.yellow("[testnet] Base Sepolia"));
+  }
+});
+var syndicate = program.command("syndicate");
+syndicate.command("create").description("Create a new syndicate via the factory (interactive)").option("--subdomain <name>", "ENS subdomain (skip prompt)").option("--name <name>", "Syndicate name (skip prompt)").option("--agent-id <id>", "ERC-8004 agent identity token ID (skip prompt)").option("--asset <address>", "Underlying asset address").option("--max-per-tx <amount>", "Max per transaction (in asset units)").option("--max-daily <amount>", "Max daily combined spend (in asset units)").option("--borrow-ratio <bps>", "Max borrow ratio in basis points").option("--targets <addresses>", "Comma-separated allowlisted target addresses").option("--description <text>", "Short description").option("--metadata-uri <uri>", "Override metadata URI (skip IPFS upload)").option("--open-deposits", "Allow anyone to deposit (no whitelist)").option("--public-chat", "Enable dashboard spectator mode", false).action(async (opts) => {
+  try {
+    console.log();
+    console.log(LABEL("  \u25C6 Create Syndicate"));
+    SEP();
+    const wallet = getAccount();
+    console.log(DIM(`  Wallet:  ${wallet.address}`));
+    console.log(DIM(`  Network: ${getChain().name}`));
+    SEP();
+    const savedAgentId = getAgentId();
+    const name = opts.name || await input({
+      message: G("Syndicate name"),
+      validate: (v) => v.length > 0 || "Name is required"
+    });
+    const subdomain = opts.subdomain || await input({
+      message: G("ENS subdomain"),
+      default: name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, ""),
+      validate: (v) => v.length >= 3 || "Must be at least 3 characters"
+    });
+    const description = opts.description || await input({
+      message: G("Description"),
+      default: `${name} \u2014 a Sherwood syndicate`
+    });
+    const agentIdStr = opts.agentId || (savedAgentId ? await input({ message: G("Agent ID (ERC-8004)"), default: String(savedAgentId) }) : await input({ message: G("Agent ID (ERC-8004)"), validate: (v) => /^\d+$/.test(v) || "Must be a number" }));
+    const openDeposits = opts.openDeposits !== void 0 ? opts.openDeposits : await confirm({
+      message: G("Open deposits? (anyone can deposit)"),
+      default: true
+    });
+    const maxPerTx = opts.maxPerTx || await input({
+      message: G("Max per transaction (USDC)"),
+      default: "10000"
+    });
+    const maxDaily = opts.maxDaily || await input({
+      message: G("Max daily spend (USDC)"),
+      default: "50000"
+    });
+    const borrowRatio = opts.borrowRatio || await input({
+      message: G("Max borrow ratio (bps, 7500 = 75%)"),
+      default: "7500"
+    });
+    const asset = opts.asset || TOKENS().USDC;
+    const publicClient = getPublicClient();
+    const [decimals, assetSymbol] = await Promise.all([
+      publicClient.readContract({ address: asset, abi: ERC20_ABI, functionName: "decimals" }),
+      publicClient.readContract({ address: asset, abi: ERC20_ABI, functionName: "symbol" })
+    ]);
+    const symbol = `sw${assetSymbol}`;
+    const targets = opts.targets ? opts.targets.split(",").map((a) => a.trim()) : [];
+    console.log();
+    console.log(LABEL("  \u25C6 Review"));
+    SEP();
+    console.log(W(`  Name:         ${BOLD(name)}`));
+    console.log(W(`  ENS:          ${G(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W(`  Description:  ${DIM(description)}`));
+    console.log(W(`  Agent ID:     #${agentIdStr}`));
+    console.log(W(`  Asset:        ${assetSymbol} (${asset.slice(0, 10)}...)`));
+    console.log(W(`  Share token:  ${symbol}`));
+    console.log(W(`  Max per tx:   ${maxPerTx} ${assetSymbol}`));
+    console.log(W(`  Max daily:    ${maxDaily} ${assetSymbol}`));
+    console.log(W(`  Borrow ratio: ${(Number(borrowRatio) / 100).toFixed(1)}%`));
+    console.log(W(`  Open deposits: ${openDeposits ? G("yes") : chalk5.red("no (whitelist)")}`));
+    if (targets.length > 0) {
+      console.log(W(`  Targets:      ${targets.length} address(es)`));
+    }
+    SEP();
+    const go = await confirm({ message: G("Deploy syndicate?"), default: true });
+    if (!go) {
+      console.log(DIM("  Cancelled."));
+      return;
+    }
+    let metadataURI = opts.metadataUri || "";
+    if (!metadataURI) {
+      const spinner2 = ora5({ text: W("Uploading metadata to IPFS..."), color: "green" }).start();
+      try {
+        const metadata = {
+          schema: "sherwood/syndicate/v1",
+          name,
+          description,
+          chain: getChain().name,
+          strategies: [],
+          terms: {
+            ragequitEnabled: true,
+            feeModel: "none"
+          },
+          links: {}
+        };
+        metadataURI = await uploadMetadata(metadata);
+        spinner2.succeed(G(`Metadata pinned: ${DIM(metadataURI)}`));
+      } catch (err) {
+        spinner2.warn(chalk5.yellow(`IPFS upload failed \u2014 using inline metadata`));
+        const json = JSON.stringify({ name, description, subdomain, asset: assetSymbol, openDeposits, createdBy: "@sherwoodagent/cli" });
+        metadataURI = `data:application/json;base64,${Buffer.from(json).toString("base64")}`;
+      }
+    }
+    const spinner = ora5({ text: W("Deploying vault via factory..."), color: "green" }).start();
+    const result = await createSyndicate({
+      creatorAgentId: BigInt(agentIdStr),
+      metadataURI,
+      asset,
+      name,
+      symbol,
+      maxPerTx: parseUnits8(maxPerTx, decimals),
+      maxDailyTotal: parseUnits8(maxDaily, decimals),
+      maxBorrowRatio: BigInt(borrowRatio),
+      initialTargets: targets,
+      openDeposits,
+      subdomain
+    });
+    setChainContract(getChain().id, "vault", result.vault);
+    spinner.text = W("Registering creator as agent...");
+    try {
+      setVaultAddress(result.vault);
+      const creatorAddress = getAccount().address;
+      await registerAgent(
+        BigInt(agentIdStr),
+        creatorAddress,
+        // pkp = creator EOA (direct execution)
+        creatorAddress,
+        // operator = creator EOA
+        parseUnits8(maxPerTx, decimals),
+        parseUnits8(maxDaily, decimals)
+      );
+    } catch (regErr) {
+      console.warn(chalk5.yellow("\n  \u26A0 Could not auto-register creator as agent \u2014 register manually with `syndicate add`"));
+    }
+    spinner.text = W("Setting up chat...");
+    try {
+      const xmtp = await loadXmtp();
+      const xmtpClient = await xmtp.getXmtpClient();
+      const groupId = await xmtp.createSyndicateGroup(xmtpClient, subdomain, opts.publicChat);
+      await setTextRecord(subdomain, "xmtpGroupId", groupId, result.vault);
+      cacheGroupId(subdomain, groupId);
+    } catch {
+      console.warn(chalk5.yellow("\n  \u26A0 Could not create XMTP chat group"));
+      console.warn(chalk5.dim(`    Recover later with: sherwood chat ${subdomain} init`));
+    }
+    spinner.stop();
+    console.log();
+    console.log(LABEL("  \u25C6 Syndicate Created"));
+    SEP();
+    console.log(W(`  ID:       ${G(`#${result.syndicateId}`)}`));
+    console.log(W(`  Vault:    ${G(result.vault)}`));
+    console.log(W(`  ENS:      ${G(`${subdomain}.sherwoodagent.eth`)}`));
+    console.log(W(`  Metadata: ${DIM(metadataURI.length > 50 ? metadataURI.slice(0, 50) + "..." : metadataURI)}`));
+    console.log(W(`  Explorer: ${DIM(getExplorerUrl(result.hash))}`));
+    console.log(W(`  Chat:     ${DIM(`sherwood chat ${subdomain}`)}`));
+    SEP();
+    console.log(G("  \u2713 Vault saved to ~/.sherwood/config.json"));
+    console.log();
+  } catch (err) {
+    console.error(chalk5.red(`
+  \u2716 ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+});
+syndicate.command("list").description("List active syndicates (queries subgraph, falls back to on-chain)").option("--creator <address>", "Filter by creator address").action(async (opts) => {
+  const spinner = ora5("Loading syndicates...").start();
+  try {
+    let syndicates;
+    if (process.env.SUBGRAPH_URL) {
+      const result = await getActiveSyndicates2(opts.creator);
+      syndicates = result;
+    } else {
+      const result = await getActiveSyndicates();
+      syndicates = result.map((s) => ({
+        id: s.id.toString(),
+        vault: s.vault,
+        creator: s.creator,
+        metadataURI: s.metadataURI,
+        createdAt: s.createdAt.toString(),
+        subdomain: s.subdomain
+      }));
+    }
+    spinner.stop();
+    if (syndicates.length === 0) {
+      console.log(chalk5.dim("No active syndicates found."));
+      return;
+    }
+    console.log();
+    console.log(chalk5.bold(`Active Syndicates (${syndicates.length})`));
+    if (!process.env.SUBGRAPH_URL) {
+      console.log(chalk5.dim("  (Set SUBGRAPH_URL for faster indexed queries)"));
+    }
+    console.log(chalk5.dim("\u2500".repeat(70)));
+    for (const s of syndicates) {
+      const ts = typeof s.createdAt === "string" ? Number(s.createdAt) : Number(s.createdAt);
+      const date = new Date(ts * 1e3).toLocaleDateString();
+      const ensName = s.subdomain ? `${s.subdomain}.sherwoodagent.eth` : "";
+      console.log(`  #${s.id}  ${chalk5.bold(ensName || String(s.vault))}`);
+      if (ensName) console.log(`    Vault:   ${chalk5.cyan(String(s.vault))}`);
+      console.log(`    Creator: ${s.creator}`);
+      console.log(`    Created: ${date}`);
+      if (s.totalDeposits) {
+        console.log(`    Deposits: ${s.totalDeposits} USDC`);
+      }
+      if (s.metadataURI) {
+        console.log(`    Metadata: ${chalk5.dim(s.metadataURI)}`);
+      }
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail("Failed to load syndicates");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("info").description("Display syndicate details by ID").argument("<id>", "Syndicate ID").action(async (idStr) => {
+  const spinner = ora5("Loading syndicate info...").start();
+  try {
+    const id = BigInt(idStr);
+    const info = await getSyndicate(id);
+    spinner.stop();
+    if (!info.vault || info.vault === "0x0000000000000000000000000000000000000000") {
+      console.log(chalk5.red(`Syndicate #${id} not found.`));
+      process.exit(1);
+    }
+    const date = new Date(Number(info.createdAt) * 1e3).toLocaleDateString();
+    console.log();
+    console.log(chalk5.bold(`Syndicate #${info.id}`));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    if (info.subdomain) {
+      console.log(`  ENS:        ${chalk5.bold(`${info.subdomain}.sherwoodagent.eth`)}`);
+    }
+    console.log(`  Vault:      ${chalk5.cyan(info.vault)}`);
+    console.log(`  Creator:    ${info.creator}`);
+    console.log(`  Created:    ${date}`);
+    console.log(`  Active:     ${info.active ? chalk5.green("yes") : chalk5.red("no")}`);
+    if (info.metadataURI) {
+      console.log(`  Metadata:   ${chalk5.dim(info.metadataURI)}`);
+    }
+    setVaultAddress(info.vault);
+    const vaultInfo = await getVaultInfo();
+    console.log();
+    console.log(chalk5.bold("  Vault Stats"));
+    console.log(`    Total Assets: ${vaultInfo.totalAssets}`);
+    console.log(`    Agent Count:  ${vaultInfo.agentCount}`);
+    console.log(`    Daily Spend:  ${vaultInfo.dailySpendTotal}`);
+    console.log(`    Max Per Tx:   ${vaultInfo.syndicateCaps.maxPerTx}`);
+    console.log(`    Max Daily:    ${vaultInfo.syndicateCaps.maxDailyTotal}`);
+    console.log(`    Max Borrow:   ${vaultInfo.syndicateCaps.maxBorrowRatio}`);
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load syndicate info");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("update-metadata").description("Update syndicate metadata (creator only)").requiredOption("--id <id>", "Syndicate ID").option("--name <name>", "Syndicate name").option("--description <text>", "Short description").option("--uri <uri>", "Direct metadata URI (skips IPFS upload)").action(async (opts) => {
+  const spinner = ora5({ text: W("Loading syndicate..."), color: "green" }).start();
+  try {
+    const syndicateId = BigInt(opts.id);
+    let metadataURI = opts.uri;
+    if (!metadataURI) {
+      const info = await getSyndicate(syndicateId);
+      if (!info.vault || info.vault === "0x0000000000000000000000000000000000000000") {
+        spinner.fail(`Syndicate #${opts.id} not found.`);
+        process.exit(1);
+      }
+      const name = opts.name || info.subdomain;
+      const description = opts.description || `${name} \u2014 a Sherwood syndicate on ${info.subdomain}.sherwoodagent.eth`;
+      spinner.text = W("Uploading metadata to IPFS...");
+      const metadata = {
+        schema: "sherwood/syndicate/v1",
+        name,
+        description,
+        chain: getChain().name,
+        strategies: [],
+        terms: { ragequitEnabled: true },
+        links: {}
+      };
+      metadataURI = await uploadMetadata(metadata);
+      spinner.text = W("Updating on-chain metadata...");
+    }
+    const hash = await updateMetadata(syndicateId, metadataURI);
+    spinner.succeed(G(`Metadata updated`));
+    console.log(DIM(`  IPFS: ${metadataURI}`));
+    console.log(DIM(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Metadata update failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("approve-depositor").description("Approve an address to deposit (owner only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--depositor <address>", "Address to approve").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Approving depositor...").start();
+  try {
+    const hash = await approveDepositor(opts.depositor);
+    spinner.succeed(`Depositor approved: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Approval failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("remove-depositor").description("Remove an address from the depositor whitelist (owner only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--depositor <address>", "Address to remove").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Removing depositor...").start();
+  try {
+    const hash = await removeDepositor(opts.depositor);
+    spinner.succeed(`Depositor removed: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Removal failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("add").description("Register an agent on a syndicate vault (creator only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--agent-id <id>", "Agent's ERC-8004 identity token ID").requiredOption("--pkp <address>", "Agent PKP address").requiredOption("--eoa <address>", "Operator EOA address").requiredOption("--max-per-tx <amount>", "Max per transaction (in asset units)").requiredOption("--daily-limit <amount>", "Daily limit (in asset units)").action(async (opts) => {
+  const spinner = ora5("Verifying creator...").start();
+  try {
+    resolveVault(opts);
+    const vaultAddress = getVaultAddress();
+    const { creator, subdomain } = await resolveVaultSyndicate(vaultAddress);
+    const callerAddress = getAccount().address.toLowerCase();
+    if (creator.toLowerCase() !== callerAddress) {
+      spinner.fail("Only the syndicate creator can add agents");
+      process.exit(1);
+    }
+    const decimals = await getAssetDecimals();
+    const maxPerTx = parseUnits8(opts.maxPerTx, decimals);
+    const dailyLimit = parseUnits8(opts.dailyLimit, decimals);
+    spinner.text = "Registering agent...";
+    const hash = await registerAgent(
+      BigInt(opts.agentId),
+      opts.pkp,
+      opts.eoa,
+      maxPerTx,
+      dailyLimit
+    );
+    spinner.succeed(`Agent registered: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+    try {
+      const xmtp = await loadXmtp();
+      const xmtpClient = await xmtp.getXmtpClient();
+      const group = await xmtp.getGroup(xmtpClient, subdomain);
+      await xmtp.addMember(group, opts.pkp);
+      await xmtp.sendEnvelope(group, {
+        type: "AGENT_REGISTERED",
+        agent: { erc8004Id: Number(opts.agentId), address: opts.pkp },
+        syndicate: subdomain,
+        timestamp: Math.floor(Date.now() / 1e3)
+      });
+      console.log(chalk5.dim(`  Added to chat: ${subdomain}`));
+    } catch {
+      console.warn(chalk5.yellow("  \u26A0 Could not add agent to chat group"));
+      console.warn(chalk5.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
+    }
+  } catch (err) {
+    spinner.fail("Registration failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("spectator").description("Toggle dashboard spectator mode for a syndicate chat").argument("<subdomain>", "Syndicate subdomain").option("--on", "Add spectator bot").option("--off", "Remove spectator bot").action(async (subdomain, opts) => {
+  if (!opts.on && !opts.off) {
+    console.error(chalk5.red("Specify --on or --off"));
+    process.exit(1);
+  }
+  const spectatorAddress = process.env.DASHBOARD_SPECTATOR_ADDRESS;
+  if (!spectatorAddress) {
+    console.error(chalk5.red("DASHBOARD_SPECTATOR_ADDRESS env var is required"));
+    process.exit(1);
+  }
+  const spinner = ora5(`${opts.on ? "Enabling" : "Disabling"} spectator mode...`).start();
+  try {
+    const xmtp = await loadXmtp();
+    const xmtpClient = await xmtp.getXmtpClient();
+    const group = await xmtp.getGroup(xmtpClient, subdomain);
+    if (opts.on) {
+      await xmtp.addMember(group, spectatorAddress);
+      spinner.succeed("Spectator mode enabled");
+    } else {
+      await xmtp.removeMember(group, spectatorAddress);
+      spinner.succeed("Spectator mode disabled");
+    }
+  } catch (err) {
+    spinner.fail("Failed to toggle spectator mode");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("join").description("Request to join a syndicate (creates an EAS attestation)").requiredOption("--subdomain <name>", "Syndicate subdomain to join").option("--message <text>", "Message to the creator", "Requesting to join your syndicate").action(async (opts) => {
+  const spinner = ora5("Resolving syndicate...").start();
+  try {
+    const agentId = getAgentId();
+    if (!agentId) {
+      spinner.fail("No agent identity found. Run 'sherwood identity mint' first.");
+      process.exit(1);
+    }
+    const syndicate2 = await resolveSyndicate(opts.subdomain);
+    spinner.text = "Creating join request attestation...";
+    const { uid, hash } = await createJoinRequest(
+      syndicate2.id,
+      BigInt(agentId),
+      syndicate2.vault,
+      syndicate2.creator,
+      opts.message
+    );
+    try {
+      spinner.text = "Registering XMTP identity...";
+      const xmtp = await loadXmtp();
+      await xmtp.getXmtpClient();
+      spinner.succeed("Join request created (XMTP identity ready)");
+    } catch {
+      spinner.succeed("Join request created");
+      console.warn(chalk5.yellow("  \u26A0 Could not initialize XMTP identity \u2014 creator may not be able to auto-add you to chat"));
+    }
+    console.log();
+    console.log(LABEL("  \u25C6 Join Request Submitted"));
+    SEP();
+    console.log(W(`  Syndicate:    ${G(`${opts.subdomain}.sherwoodagent.eth`)}`));
+    console.log(W(`  Agent ID:     #${agentId}`));
+    console.log(W(`  Creator:      ${DIM(syndicate2.creator)}`));
+    console.log(W(`  Attestation:  ${DIM(uid)}`));
+    console.log(W(`  EAS Scan:     ${DIM(getEasScanUrl(uid))}`));
+    console.log(W(`  Explorer:     ${DIM(getExplorerUrl(hash))}`));
+    SEP();
+    console.log(G("  \u2713 The creator can review with:"));
+    console.log(DIM(`    sherwood syndicate requests --subdomain ${opts.subdomain}`));
+    console.log();
+  } catch (err) {
+    spinner.fail("Join request failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("requests").description("View pending join requests for a syndicate (creator only)").option("--subdomain <name>", "Syndicate subdomain").option("--vault <address>", "Vault address (default: from config)").action(async (opts) => {
+  const spinner = ora5("Loading join requests...").start();
+  try {
+    let creatorAddress;
+    let subdomain;
+    if (opts.subdomain) {
+      const syndicateInfo = await resolveSyndicate(opts.subdomain);
+      creatorAddress = syndicateInfo.creator;
+      subdomain = opts.subdomain;
+    } else {
+      resolveVault(opts);
+      const vaultAddress = getVaultAddress();
+      const syndicateInfo = await resolveVaultSyndicate(vaultAddress);
+      creatorAddress = syndicateInfo.creator;
+      subdomain = syndicateInfo.subdomain;
+    }
+    const callerAddress = getAccount().address.toLowerCase();
+    if (creatorAddress.toLowerCase() !== callerAddress) {
+      spinner.fail("Only the syndicate creator can view join requests");
+      process.exit(1);
+    }
+    spinner.text = "Querying EAS attestations...";
+    const requests = await queryJoinRequests(creatorAddress);
+    spinner.stop();
+    if (requests.length === 0) {
+      console.log(DIM("\n  No pending join requests.\n"));
+      return;
+    }
+    console.log();
+    console.log(LABEL(`  \u25C6 Pending Join Requests (${requests.length})`));
+    SEP();
+    for (let i = 0; i < requests.length; i++) {
+      const req = requests[i];
+      const date = new Date(req.time * 1e3).toLocaleString();
+      console.log(W(`  ${i + 1}. Agent #${req.decoded.agentId} ${DIM(`(${req.attester})`)}`));
+      console.log(DIM(`     Message:     "${req.decoded.message}"`));
+      console.log(DIM(`     Requested:   ${date}`));
+      console.log(DIM(`     Attestation: ${req.uid}`));
+      console.log();
+    }
+    console.log(G("  To approve:"));
+    console.log(DIM(`    sherwood syndicate approve --agent-id <id> --pkp <addr> --eoa <addr> --max-per-tx <amt> --daily-limit <amt>`));
+    console.log(G("  To reject:"));
+    console.log(DIM(`    sherwood syndicate reject --attestation <uid>`));
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load requests");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("approve").description("Approve an agent join request (registers agent + creates EAS approval)").option("--vault <address>", "Vault address (default: from config)").option("--subdomain <name>", "Syndicate subdomain (alternative to --vault)").requiredOption("--agent-id <id>", "Agent's ERC-8004 identity token ID").requiredOption("--pkp <address>", "Agent PKP address").requiredOption("--eoa <address>", "Operator EOA address").requiredOption("--max-per-tx <amount>", "Max per transaction (in asset units)").requiredOption("--daily-limit <amount>", "Daily limit (in asset units)").option("--revoke-request <uid>", "Revoke the join request attestation after approval").action(async (opts) => {
+  const spinner = ora5("Verifying creator...").start();
+  try {
+    if (opts.subdomain && !opts.vault) {
+      const syndicateInfo = await resolveSyndicate(opts.subdomain);
+      setVaultAddress(syndicateInfo.vault);
+    } else {
+      resolveVault(opts);
+    }
+    const vaultAddress = getVaultAddress();
+    const { creator, subdomain, id: syndicateId } = await resolveVaultSyndicate(vaultAddress);
+    const callerAddress = getAccount().address.toLowerCase();
+    if (creator.toLowerCase() !== callerAddress) {
+      spinner.fail("Only the syndicate creator can approve agents");
+      process.exit(1);
+    }
+    const decimals = await getAssetDecimals();
+    const maxPerTx = parseUnits8(opts.maxPerTx, decimals);
+    const dailyLimit = parseUnits8(opts.dailyLimit, decimals);
+    spinner.text = "Registering agent on vault...";
+    try {
+      const regHash = await registerAgent(
+        BigInt(opts.agentId),
+        opts.pkp,
+        opts.eoa,
+        maxPerTx,
+        dailyLimit
+      );
+      console.log(DIM(`  Agent registered: ${getExplorerUrl(regHash)}`));
+    } catch (regErr) {
+      const msg = regErr instanceof Error ? regErr.message : String(regErr);
+      if (msg.includes("0xe098d3ee") || msg.includes("AgentAlreadyRegistered")) {
+        console.log(DIM("  Agent already registered on vault \u2014 skipping"));
+      } else {
+        throw regErr;
+      }
+    }
+    spinner.text = "Creating approval attestation...";
+    const { uid: approvalUid } = await createApproval(
+      syndicateId,
+      BigInt(opts.agentId),
+      vaultAddress,
+      opts.eoa
+    );
+    if (opts.revokeRequest) {
+      spinner.text = "Revoking join request...";
+      await revokeAttestation(
+        EAS_SCHEMAS().SYNDICATE_JOIN_REQUEST,
+        opts.revokeRequest
+      );
+    }
+    try {
+      spinner.text = "Adding to chat...";
+      const xmtp = await loadXmtp();
+      const xmtpClient = await xmtp.getXmtpClient();
+      const group = await xmtp.getGroup(xmtpClient, subdomain);
+      await xmtp.addMember(group, opts.pkp);
+      await xmtp.sendEnvelope(group, {
+        type: "AGENT_REGISTERED",
+        agent: { erc8004Id: Number(opts.agentId), address: opts.pkp },
+        syndicate: subdomain,
+        timestamp: Math.floor(Date.now() / 1e3)
+      });
+      console.log(DIM(`  Added to chat: ${subdomain}`));
+    } catch {
+      console.warn(chalk5.yellow("  \u26A0 Could not add agent to chat group"));
+      console.warn(chalk5.dim(`    If no group exists, run: sherwood chat ${subdomain} init`));
+    }
+    spinner.succeed("Agent approved and registered");
+    console.log();
+    console.log(LABEL("  \u25C6 Agent Approved"));
+    SEP();
+    console.log(W(`  Agent ID:     #${opts.agentId}`));
+    console.log(W(`  PKP:          ${G(opts.pkp)}`));
+    console.log(W(`  EOA:          ${G(opts.eoa)}`));
+    console.log(W(`  Approval:     ${DIM(approvalUid)}`));
+    console.log(W(`  EAS Scan:     ${DIM(getEasScanUrl(approvalUid))}`));
+    SEP();
+  } catch (err) {
+    spinner.fail("Approval failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+syndicate.command("reject").description("Reject a join request by revoking its attestation").requiredOption("--attestation <uid>", "Join request attestation UID to revoke").action(async (opts) => {
+  const spinner = ora5("Revoking attestation...").start();
+  try {
+    const hash = await revokeAttestation(
+      EAS_SCHEMAS().SYNDICATE_JOIN_REQUEST,
+      opts.attestation
+    );
+    spinner.succeed("Join request rejected");
+    console.log(DIM(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Rejection failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var vaultCmd = program.command("vault");
+vaultCmd.command("deposit").description("Deposit into a vault").option("--vault <address>", "Vault address (default: from config)").requiredOption("--amount <amount>", "Amount to deposit (in asset units)").action(async (opts) => {
+  resolveVault(opts);
+  const decimals = await getAssetDecimals();
+  const amount = parseUnits8(opts.amount, decimals);
+  const spinner = ora5(`Depositing ${opts.amount}...`).start();
+  try {
+    const hash = await deposit(amount);
+    spinner.succeed(`Deposited: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Deposit failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("ragequit").description("Withdraw all shares from a vault").option("--vault <address>", "Vault address (default: from config)").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Ragequitting...").start();
+  try {
+    const hash = await ragequit();
+    spinner.succeed(`Ragequit: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Ragequit failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("info").description("Display vault state").option("--vault <address>", "Vault address (default: from config)").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Loading vault info...").start();
+  try {
+    const info = await getVaultInfo();
+    spinner.stop();
+    console.log();
+    console.log(chalk5.bold("Vault Info"));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    console.log(`  Address:        ${info.address}`);
+    console.log(`  Total Assets:   ${info.totalAssets}`);
+    console.log(`  Agent Count:    ${info.agentCount}`);
+    console.log(`  Daily Spend:    ${info.dailySpendTotal}`);
+    console.log();
+    console.log(chalk5.bold("  Syndicate Caps"));
+    console.log(`    Max Per Tx:     ${info.syndicateCaps.maxPerTx}`);
+    console.log(`    Max Daily:      ${info.syndicateCaps.maxDailyTotal}`);
+    console.log(`    Max Borrow:     ${info.syndicateCaps.maxBorrowRatio}`);
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load vault info");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("balance").description("Show LP share balance and asset value").option("--vault <address>", "Vault address (default: from config)").option("--address <address>", "Address to check (default: your wallet)").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Loading balance...").start();
+  try {
+    const balance = await getBalance(opts.address);
+    spinner.stop();
+    console.log();
+    console.log(chalk5.bold("LP Position"));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    console.log(`  Shares:       ${balance.shares.toString()}`);
+    console.log(`  Asset Value:  ${balance.assetsValue}`);
+    console.log(`  % of Vault:   ${balance.percentOfVault}`);
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load balance");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("add-target").description("Add a target to the vault allowlist (owner only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--target <address>", "Target address to allow").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Adding target...").start();
+  try {
+    const hash = await addTarget(opts.target);
+    spinner.succeed(`Target added: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Failed to add target");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("remove-target").description("Remove a target from the vault allowlist (owner only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--target <address>", "Target address to remove").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Removing target...").start();
+  try {
+    const hash = await removeTarget(opts.target);
+    spinner.succeed(`Target removed: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Failed to remove target");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+vaultCmd.command("targets").description("List allowed targets for a vault").option("--vault <address>", "Vault address (default: from config)").action(async (opts) => {
+  resolveVault(opts);
+  const spinner = ora5("Loading targets...").start();
+  try {
+    const targets = await getAllowedTargets();
+    spinner.stop();
+    console.log();
+    console.log(chalk5.bold(`Allowed Targets (${targets.length})`));
+    console.log(chalk5.dim("\u2500".repeat(50)));
+    for (const t of targets) {
+      console.log(`  ${t}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load targets");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+var strategy = program.command("strategy");
+strategy.command("list").description("List registered strategies").option("--type <id>", "Filter by strategy type").action(async (opts) => {
+  const spinner = ora5("Loading strategies...").start();
+  try {
+    const strategies = await listStrategies(
+      opts.type ? BigInt(opts.type) : void 0
+    );
+    spinner.stop();
+    if (strategies.length === 0) {
+      console.log(chalk5.dim("No strategies registered."));
+      return;
+    }
+    console.log();
+    console.log(chalk5.bold(`Strategies (${strategies.length})`));
+    console.log(chalk5.dim("\u2500".repeat(70)));
+    for (const s of strategies) {
+      const status = s.active ? chalk5.green("active") : chalk5.red("inactive");
+      console.log(`  #${s.id}  ${chalk5.bold(s.name)}  [type: ${s.strategyTypeId}]  ${status}`);
+      console.log(`    Creator:        ${s.creator}`);
+      console.log(`    Implementation: ${s.implementation}`);
+      if (s.metadataURI) {
+        console.log(`    Metadata:       ${chalk5.dim(s.metadataURI)}`);
+      }
+      console.log();
+    }
+  } catch (err) {
+    spinner.fail("Failed to load strategies");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+strategy.command("info").description("Show strategy details").argument("<id>", "Strategy ID").action(async (idStr) => {
+  const spinner = ora5("Loading strategy...").start();
+  try {
+    const s = await getStrategy(BigInt(idStr));
+    spinner.stop();
+    console.log();
+    console.log(chalk5.bold(`Strategy #${s.id}`));
+    console.log(chalk5.dim("\u2500".repeat(40)));
+    console.log(`  Name:           ${s.name}`);
+    console.log(`  Type:           ${s.strategyTypeId}`);
+    console.log(`  Active:         ${s.active ? chalk5.green("yes") : chalk5.red("no")}`);
+    console.log(`  Creator:        ${s.creator}`);
+    console.log(`  Implementation: ${s.implementation}`);
+    if (s.metadataURI) {
+      console.log(`  Metadata:       ${chalk5.dim(s.metadataURI)}`);
+    }
+    console.log();
+  } catch (err) {
+    spinner.fail("Failed to load strategy");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+strategy.command("register").description("Register a new strategy on-chain").requiredOption("--implementation <address>", "Strategy contract address").requiredOption("--type <id>", "Strategy type ID").requiredOption("--name <name>", "Strategy name").option("--metadata <uri>", "Metadata URI (IPFS/Arweave)", "").action(async (opts) => {
+  const spinner = ora5("Registering strategy...").start();
+  try {
+    const hash = await registerStrategy(
+      opts.implementation,
+      BigInt(opts.type),
+      opts.name,
+      opts.metadata
+    );
+    spinner.succeed(`Strategy registered: ${hash}`);
+    console.log(chalk5.dim(`  ${getExplorerUrl(hash)}`));
+  } catch (err) {
+    spinner.fail("Registration failed");
+    console.error(chalk5.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+});
+strategy.command("run").description("Execute the levered swap strategy").option("--vault <address>", "Vault address (default: from config)").requiredOption("--collateral <amount>", "WETH collateral amount (e.g. 1.0)").requiredOption("--borrow <amount>", "USDC to borrow against collateral").requiredOption("--token <address>", "Target token address to buy").option("--fee <tier>", "Uniswap fee tier in bps (500, 3000, 10000)", "500").option("--slippage <bps>", "Slippage tolerance in bps", "100").option("--execute", "Actually execute on-chain (default: simulate only)", false).action(async (opts) => {
+  resolveVault(opts);
+  await runLeveredSwap(opts);
+});
+program.command("providers").description("List available DeFi providers").action(() => {
+  const providers = [new MoonwellProvider(), new UniswapProvider()];
+  for (const p of providers) {
+    const info = p.info();
+    console.log(`
+${info.name} (${info.type})`);
+    console.log(`  Capabilities: ${info.capabilities.join(", ")}`);
+    console.log(`  Chains: ${info.supportedChains.map((c) => c.name).join(", ")}`);
+  }
+});
+try {
+  const { registerChatCommands } = await import("./commands/chat.js");
+  registerChatCommands(program);
+} catch {
+  program.command("chat <name> [action] [actionArgs...]").description("Syndicate chat (XMTP) \u2014 requires native bindings").action(() => {
+    console.error(chalk5.red("XMTP native bindings not available."));
+    console.error(chalk5.dim("Chat requires native dependencies that can't be embedded in standalone binaries."));
+    console.error(chalk5.dim("Install via npm:  npm i -g @sherwoodagent/cli"));
+    console.error(chalk5.dim("Or from source:   cd cli && npm i && npm run dev -- chat <name>"));
+    process.exit(1);
+  });
+}
+registerVeniceCommands(program);
+registerAllowanceCommands(program);
+registerIdentityCommands(program);
+var configCmd = program.command("config");
+configCmd.command("set").description("Save settings to ~/.sherwood/config.json (persists across sessions)").option("--private-key <key>", "Wallet private key (0x-prefixed)").option("--vault <address>", "Default SyndicateVault address").action((opts) => {
+  let saved = false;
+  if (opts.privateKey) {
+    setPrivateKey(opts.privateKey);
+    const account = getAccount();
+    console.log(chalk5.green("Private key saved to ~/.sherwood/config.json"));
+    console.log(chalk5.dim(`  Wallet: ${account.address}`));
+    saved = true;
+  }
+  if (opts.vault) {
+    const chainId = getChain().id;
+    setChainContract(chainId, "vault", opts.vault);
+    console.log(chalk5.green(`Vault saved to ~/.sherwood/config.json (chain ${chainId})`));
+    console.log(chalk5.dim(`  Vault: ${opts.vault}`));
+    saved = true;
+  }
+  if (!saved) {
+    console.log(chalk5.red("Provide at least one of: --private-key, --vault"));
+    process.exit(1);
+  }
+});
+configCmd.command("show").description("Display current config for the active network").action(() => {
+  const chainId = getChain().id;
+  const contracts = getChainContracts(chainId);
+  const config = loadConfig();
+  console.log();
+  console.log(chalk5.bold(`Sherwood Config (chain ${chainId})`));
+  console.log(chalk5.dim("\u2500".repeat(50)));
+  console.log(`  Wallet:     ${config.privateKey ? chalk5.green("configured") : chalk5.dim("not set")}`);
+  console.log(`  Agent ID:   ${config.agentId ?? chalk5.dim("not set")}`);
+  console.log(`  Vault:      ${contracts.vault ?? chalk5.dim("not set")}`);
+  console.log();
+  console.log(chalk5.dim("  Config file: ~/.sherwood/config.json"));
+  console.log();
+});
+program.parse();
+//# sourceMappingURL=index.js.map