@sherwoodagent/cli 0.22.8 → 0.25.1

package/dist/index.js

@@ -1,4 +1,22 @@
 #!/usr/bin/env node
+import {
+  approveDepositor,
+  deposit,
+  depositWithEthWrap,
+  executeBatch,
+  getAssetDecimals,
+  getBalance,
+  getVaultAddress,
+  getVaultInfo,
+  isAgent,
+  preflightDeposit,
+  registerAgent,
+  removeDepositor,
+  resolveSyndicate,
+  resolveVaultSyndicate,
+  setTextRecord,
+  setVaultAddress
+} from "./chunk-QBNWBWD3.js";
 import {
   UniswapProvider,
   applySlippage,
@@ -9,7 +27,7 @@ import {
   getQuote,
   listModels,
   provisionApiKey
-} from "./chunk-Y7LS6DEF.js";
+} from "./chunk-VQIFAXUY.js";
 import {
   PROPOSAL_STATE,
   PROPOSAL_STATES,
@@ -40,7 +58,7 @@ import {
   setVotingPeriod,
   settleProposal,
   vote
-} from "./chunk-VO6DCRWV.js";
+} from "./chunk-7PCI3WHQ.js";
 import {
   fetchMetadata,
   uploadMetadata
@@ -54,43 +72,28 @@ import {
   queryJoinRequests,
   revokeAttestation,
   stripReferrerPrefix
-} from "./chunk-4Y6Y4SVH.js";
-import {
-  approveDepositor,
-  deposit,
-  depositWithEthWrap,
-  executeBatch,
-  getAssetDecimals,
-  getBalance,
-  getVaultAddress,
-  getVaultInfo,
-  isAgent,
-  preflightDeposit,
-  registerAgent,
-  removeDepositor,
-  resolveSyndicate,
-  resolveVaultSyndicate,
-  setTextRecord,
-  setVaultAddress
-} from "./chunk-G7JQRLQE.js";
+} from "./chunk-JEVBC7DV.js";
 import {
   AERODROME,
   AGENT_REGISTRY,
   BASE_STRATEGY_ABI,
+  CHAINLINK,
   EAS_SCHEMAS,
   ERC20_ABI,
   MOONWELL,
+  PORTFOLIO_STRATEGY_ABI,
   SHERWOOD,
   STRATEGY_TEMPLATES,
   SWAP_ROUTER_ABI,
   SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
   SYNDICATE_FACTORY_ABI,
   SYNDICATE_VAULT_ABI,
+  SYNTHRA,
   TOKENS,
   UNISWAP,
   VENICE,
   VENICE_STAKING_ABI
-} from "./chunk-JR5K5WVR.js";
+} from "./chunk-ZPLUJT4V.js";
 import {
   formatContractError,
   getAccount,
@@ -98,8 +101,9 @@ import {
   sendTxWithRetry,
   waitForReceipt,
   writeContractWithRetry
-} from "./chunk-ASJTFFZH.js";
+} from "./chunk-SBVHGUQJ.js";
 import {
+  CHAIN_REGISTRY,
   VALID_NETWORKS,
   getChain,
   getExplorerUrl,
@@ -107,11 +111,13 @@ import {
   getRpcUrl,
   isTestnet,
   setNetwork
-} from "./chunk-LVPBJ7MI.js";
+} from "./chunk-GWIW6DDG.js";
 import {
   addSyndicate,
   cacheGroupId,
+  cacheSwapRoute,
   getAgentId,
+  getCachedSwapRoute,
   getChainContracts,
   getNotifyTo,
   getPrimarySyndicate,
@@ -127,7 +133,7 @@ import {
   setPrivateKey,
   setUniswapApiKey,
   setVeniceApiKey
-} from "./chunk-B42ZCCZ7.js";
+} from "./chunk-RGOTBJIN.js";
 
 // src/index.ts
 import { config as loadDotenv } from "dotenv";
@@ -173,7 +179,7 @@ var MoonwellProvider = class {
 };
 
 // src/commands/strategy-template.ts
-import { parseUnits, isAddress, erc20Abi } from "viem";
+import { parseUnits, formatUnits, isAddress, erc20Abi, encodeAbiParameters as encodeAbiParameters7, decodeAbiParameters } from "viem";
 import chalk from "chalk";
 import ora from "ora";
 import { writeFileSync, mkdirSync } from "fs";
@@ -483,8 +489,189 @@ function buildSettleCalls5(clone) {
   ];
 }
 
+// src/strategies/portfolio-template.ts
+import { encodeAbiParameters as encodeAbiParameters6, encodeFunctionData as encodeFunctionData6 } from "viem";
+function buildInitData6(asset, swapAdapter, chainlinkVerifier, allocations, totalAmount, maxSlippageBps) {
+  const tokens = allocations.map((a) => a.token);
+  const weightsBps = allocations.map((a) => BigInt(a.weightBps));
+  const swapExtraData = allocations.map((a) => a.swapExtraData);
+  return encodeAbiParameters6(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "address" },
+      { type: "address[]" },
+      { type: "uint256[]" },
+      { type: "uint256" },
+      { type: "uint256" },
+      { type: "bytes[]" }
+    ],
+    [
+      asset,
+      swapAdapter,
+      chainlinkVerifier,
+      tokens,
+      weightsBps,
+      totalAmount,
+      BigInt(maxSlippageBps),
+      swapExtraData
+    ]
+  );
+}
+function buildExecuteCalls6(clone, asset, totalAmount) {
+  return [
+    {
+      target: asset,
+      data: encodeFunctionData6({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, totalAmount]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData6({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
+    }
+  ];
+}
+function buildSettleCalls6(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData6({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
+}
+
 // src/commands/strategy-template.ts
+import { concat as concat2, numberToHex } from "viem";
 var ZERO = "0x0000000000000000000000000000000000000000";
+function encodeV3Path(tokens, fees) {
+  if (tokens.length !== fees.length + 1) throw new Error("tokens.length must be fees.length + 1");
+  const parts = [];
+  for (let i = 0; i < tokens.length; i++) {
+    parts.push(tokens[i].toLowerCase());
+    if (i < fees.length) {
+      parts.push(numberToHex(fees[i], { size: 3 }));
+    }
+  }
+  return concat2(parts);
+}
+function buildSwapExtraData(network, tokenIn, tokenOut, feeTier, hop) {
+  if (network === "robinhood-testnet") {
+    return encodeAbiParameters7([{ type: "uint24" }], [feeTier]);
+  }
+  if (hop) {
+    const path = encodeV3Path([tokenIn, hop.via, tokenOut], [hop.feeIn, hop.feeOut]);
+    const encoded2 = encodeAbiParameters7([{ type: "bytes" }], [path]);
+    return `0x01${encoded2.slice(2)}`;
+  }
+  const encoded = encodeAbiParameters7([{ type: "uint24" }], [feeTier]);
+  return `0x00${encoded.slice(2)}`;
+}
+async function detectSwapRoute(asset, token, preferredFeeTier) {
+  const network = getNetwork();
+  if (network === "robinhood-testnet") {
+    return {
+      extraData: buildSwapExtraData(network, asset, token, preferredFeeTier),
+      routeDesc: `direct (fee ${preferredFeeTier})`
+    };
+  }
+  const chainId = CHAIN_REGISTRY[network].chain.id;
+  const cached = getCachedSwapRoute(chainId, asset, token);
+  if (cached) {
+    const extraData = cached.hop ? buildSwapExtraData(network, asset, token, 0, {
+      via: cached.hop.via,
+      feeIn: cached.hop.feeIn,
+      feeOut: cached.hop.feeOut
+    }) : buildSwapExtraData(network, asset, token, cached.feeTier);
+    const desc = cached.hop ? `cached multi-hop: ${cached.hop.feeIn}\u2192WETH\u2192${cached.hop.feeOut}` : `cached direct (fee ${cached.feeTier})`;
+    return { extraData, routeDesc: desc };
+  }
+  const publicClient = getPublicClient();
+  const quoterAddr = UNISWAP().QUOTER_V2;
+  const quoterAbi = [{
+    type: "function",
+    name: "quoteExactInputSingle",
+    inputs: [{ type: "tuple", components: [
+      { type: "address", name: "tokenIn" },
+      { type: "address", name: "tokenOut" },
+      { type: "uint256", name: "amountIn" },
+      { type: "uint24", name: "fee" },
+      { type: "uint160", name: "sqrtPriceLimitX96" }
+    ] }],
+    outputs: [
+      { type: "uint256" },
+      { type: "uint160" },
+      { type: "uint32" },
+      { type: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  }];
+  const testAmount = asset.toLowerCase() === TOKENS().USDC.toLowerCase() ? 1000000n : 1000000000000000n;
+  const feeTiers = [preferredFeeTier, 1e4, 3e3, 500].filter((v, i, a) => a.indexOf(v) === i);
+  for (const fee of feeTiers) {
+    try {
+      await publicClient.simulateContract({
+        address: quoterAddr,
+        abi: quoterAbi,
+        functionName: "quoteExactInputSingle",
+        args: [{ tokenIn: asset, tokenOut: token, amountIn: testAmount, fee, sqrtPriceLimitX96: 0n }]
+      });
+      cacheSwapRoute(chainId, asset, token, { mode: "direct", feeTier: fee, detectedAt: Math.floor(Date.now() / 1e3) });
+      return {
+        extraData: buildSwapExtraData(network, asset, token, fee),
+        routeDesc: `direct (fee ${fee})`
+      };
+    } catch {
+    }
+  }
+  const weth = TOKENS().WETH;
+  if (asset.toLowerCase() === weth.toLowerCase()) return null;
+  let bestAssetToWethFee = null;
+  for (const fee of [500, 3e3, 1e4]) {
+    try {
+      await publicClient.simulateContract({
+        address: quoterAddr,
+        abi: quoterAbi,
+        functionName: "quoteExactInputSingle",
+        args: [{ tokenIn: asset, tokenOut: weth, amountIn: testAmount, fee, sqrtPriceLimitX96: 0n }]
+      });
+      bestAssetToWethFee = fee;
+      break;
+    } catch {
+    }
+  }
+  if (!bestAssetToWethFee) return null;
+  const wethTestAmount = 1000000000000000n;
+  for (const fee of feeTiers) {
+    try {
+      await publicClient.simulateContract({
+        address: quoterAddr,
+        abi: quoterAbi,
+        functionName: "quoteExactInputSingle",
+        args: [{ tokenIn: weth, tokenOut: token, amountIn: wethTestAmount, fee, sqrtPriceLimitX96: 0n }]
+      });
+      const hop = { via: weth, feeIn: bestAssetToWethFee, feeOut: fee };
+      cacheSwapRoute(chainId, asset, token, { mode: "multi-hop", feeTier: 0, hop, detectedAt: Math.floor(Date.now() / 1e3) });
+      return {
+        extraData: buildSwapExtraData(network, asset, token, 0, hop),
+        routeDesc: `multi-hop: ${bestAssetToWethFee}\u2192WETH\u2192${fee}`
+      };
+    } catch {
+    }
+  }
+  return null;
+}
 var TEMPLATES = [
   {
     name: "Moonwell Supply",
@@ -515,6 +702,12 @@ var TEMPLATES = [
     key: "mamo-yield",
     description: "Deposit into Mamo for optimized yield across Moonwell + Morpho vaults",
     addressKey: "MAMO_YIELD"
+  },
+  {
+    name: "Portfolio",
+    key: "portfolio",
+    description: "Weighted portfolio of tokens (stock tokens, crypto) with rebalancing",
+    addressKey: "PORTFOLIO"
   }
 ];
 function resolveTemplate(key) {
@@ -709,6 +902,67 @@ async function buildInitDataForTemplate(templateKey, opts, vault) {
       assetAmount: amount
     };
   }
+  if (templateKey === "portfolio") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for portfolio template"));
+      process.exit(1);
+    }
+    if (!opts.tokens || !opts.weights) {
+      console.error(chalk.red("--tokens and --weights are required for portfolio template"));
+      console.error(chalk.dim("  --tokens: comma-separated token addresses or symbols"));
+      console.error(chalk.dim("  --weights: comma-separated bps (must sum to 10000)"));
+      process.exit(1);
+    }
+    const tokens = TOKENS();
+    const defaultAsset = getNetwork() === "robinhood-testnet" ? "WETH" : "USDC";
+    const assetSymbol = opts.asset || defaultAsset;
+    const asset = resolveToken(assetSymbol);
+    const decimals = assetSymbol.toUpperCase() === "USDC" ? 6 : 18;
+    const totalAmount = parseUnits(opts.amount, decimals);
+    const maxSlippageBps = Number(opts.maxSlippage || "500");
+    const feeTier = opts.feeTier || "3000";
+    const tokenAddrs = opts.tokens.split(",").map((t) => {
+      const trimmed = t.trim();
+      if (isAddress(trimmed)) return trimmed;
+      const allTokens = tokens;
+      const resolved = allTokens[trimmed.toUpperCase()];
+      if (resolved && resolved !== ZERO) return resolved;
+      console.error(chalk.red(`Unknown token: ${trimmed}`));
+      process.exit(1);
+    });
+    const weightsBps = opts.weights.split(",").map((w) => Number(w.trim()));
+    if (tokenAddrs.length !== weightsBps.length) {
+      console.error(chalk.red("--tokens and --weights must have same length"));
+      process.exit(1);
+    }
+    if (weightsBps.reduce((a, b) => a + b, 0) !== 1e4) {
+      console.error(chalk.red(`Weights must sum to 10000`));
+      process.exit(1);
+    }
+    const swapAdapter = opts.swapAdapter || resolveSwapAdapter();
+    const chainlinkVerifier = CHAINLINK().VERIFIER_PROXY;
+    console.log(chalk.dim("  Detecting swap routes..."));
+    const allocations = [];
+    for (let i = 0; i < tokenAddrs.length; i++) {
+      const token = tokenAddrs[i];
+      const route = await detectSwapRoute(asset, token, Number(feeTier));
+      if (!route) {
+        console.error(chalk.red(`No swap route found for ${token}. No Uniswap V3 pool (direct or via WETH).`));
+        process.exit(1);
+      }
+      console.log(chalk.dim(`    ${token.slice(0, 10)}... \u2192 ${route.routeDesc}`));
+      allocations.push({
+        token,
+        weightBps: weightsBps[i],
+        swapExtraData: route.extraData
+      });
+    }
+    return {
+      initData: buildInitData6(asset, swapAdapter, chainlinkVerifier, allocations, totalAmount, maxSlippageBps),
+      asset,
+      assetAmount: totalAmount
+    };
+  }
   throw new Error(`No init builder for template: ${templateKey}`);
 }
 function buildCallsForTemplate(templateKey, clone, asset, assetAmount, extraApprovals) {
@@ -744,8 +998,28 @@ function buildCallsForTemplate(templateKey, clone, asset, assetAmount, extraAppr
       settleCalls: buildSettleCalls5(clone)
     };
   }
+  if (templateKey === "portfolio") {
+    return {
+      executeCalls: buildExecuteCalls6(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls6(clone)
+    };
+  }
   throw new Error(`No call builder for template: ${templateKey}`);
 }
+function resolveSwapAdapter() {
+  const network = getNetwork();
+  if (network === "robinhood-testnet") {
+    if (SYNTHRA().ROUTER === ZERO) {
+      console.error(chalk.red("Synthra DEX not available"));
+      process.exit(1);
+    }
+    return "0xdae81cDCfcB14c56fCeB788A147Fcd6CbEdfEeca";
+  }
+  const adapterAddr = UNISWAP().SWAP_ADAPTER;
+  if (adapterAddr !== ZERO) return adapterAddr;
+  console.error(chalk.red("UniswapSwapAdapter not deployed yet. Use --swap-adapter to specify manually."));
+  process.exit(1);
+}
 function resolveToken(symbolOrAddress) {
   if (isAddress(symbolOrAddress)) return symbolOrAddress;
   const upper = symbolOrAddress.toUpperCase();
@@ -792,23 +1066,39 @@ function serializeCalls(calls) {
 function registerStrategyTemplateCommands(strategy2) {
   strategy2.command("list").description("List available strategy templates").action(() => {
     const templates = STRATEGY_TEMPLATES();
+    const network = getNetwork();
     console.log();
-    console.log(chalk.bold("Strategy Templates"));
+    console.log(chalk.bold("Strategy Templates"), chalk.dim(`(${network})`));
     console.log(chalk.dim("\u2500".repeat(60)));
+    let availableCount = 0;
     for (const t of TEMPLATES) {
       const addr = templates[t.addressKey];
-      const deployed = addr !== ZERO;
+      if (addr !== ZERO) {
+        availableCount++;
+        console.log();
+        console.log(`  ${chalk.bold(t.name)} (${chalk.cyan(t.key)})`);
+        console.log(`    ${t.description}`);
+        console.log(`    Template: ${chalk.green(addr)}`);
+      }
+    }
+    if (availableCount === 0) {
       console.log();
-      console.log(`  ${chalk.bold(t.name)} (${chalk.cyan(t.key)})`);
-      console.log(`    ${t.description}`);
-      console.log(`    Template: ${deployed ? chalk.green(addr) : chalk.red("not deployed")}`);
+      console.log(chalk.yellow("  No strategy templates deployed on this network."));
+    }
+    const unavailable = TEMPLATES.filter((t) => templates[t.addressKey] === ZERO);
+    if (unavailable.length > 0) {
+      console.log();
+      console.log(chalk.dim(`  Not available on ${network}:`));
+      for (const t of unavailable) {
+        console.log(chalk.dim(`    ${t.name} (${t.key})`));
+      }
     }
     console.log();
     console.log(chalk.dim("Clone a template:  sherwood strategy clone <template> --vault <addr> ..."));
     console.log(chalk.dim("Full proposal:     sherwood strategy propose <template> --vault <addr> ..."));
     console.log();
   });
-  strategy2.command("clone").description("Clone a strategy template and initialize it").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield").requiredOption("--vault <address>", "Vault address").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").action(async (templateKey, opts) => {
+  strategy2.command("clone").description("Clone a strategy template and initialize it").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield, portfolio").requiredOption("--vault <address>", "Vault address").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").option("--tokens <list>", "Comma-separated token addresses or symbols (Portfolio)").option("--weights <list>", "Comma-separated weights in bps, must sum to 10000 (Portfolio)").option("--max-slippage <bps>", "Max slippage bps (Portfolio, default: 500)").option("--fee-tier <n>", "Pool fee tier (Portfolio, default: 3000)").option("--swap-adapter <address>", "Swap adapter address (Portfolio)").action(async (templateKey, opts) => {
     const vault = opts.vault;
     if (!isAddress(vault)) {
       console.error(chalk.red("Invalid vault address"));
@@ -856,7 +1146,7 @@ function registerStrategyTemplateCommands(strategy2) {
     console.log(chalk.dim("Use this address in your proposal batch calls."));
     console.log();
   });
-  strategy2.command("init").description("Initialize an already-deployed but uninitialized strategy clone").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield").requiredOption("--clone <address>", "Clone address to initialize").requiredOption("--vault <address>", "Vault address").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").action(async (templateKey, opts) => {
+  strategy2.command("init").description("Initialize an already-deployed but uninitialized strategy clone").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield, portfolio").requiredOption("--clone <address>", "Clone address to initialize").requiredOption("--vault <address>", "Vault address").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").option("--tokens <list>", "Comma-separated token addresses or symbols (Portfolio)").option("--weights <list>", "Comma-separated weights in bps, must sum to 10000 (Portfolio)").option("--max-slippage <bps>", "Max slippage bps (Portfolio, default: 500)").option("--fee-tier <n>", "Pool fee tier (Portfolio, default: 3000)").option("--swap-adapter <address>", "Swap adapter address (Portfolio)").action(async (templateKey, opts) => {
     const clone = opts.clone;
     const vault = opts.vault;
     if (!isAddress(clone)) {
@@ -912,7 +1202,7 @@ function registerStrategyTemplateCommands(strategy2) {
     console.log(`  Proposer: ${chalk.green(getAccount().address)}`);
     console.log();
   });
-  strategy2.command("propose").description("Clone + init + build calls + submit governance proposal (all-in-one)").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield").requiredOption("--vault <address>", "Vault address").option("--write-calls <dir>", "Write execute/settle JSON to directory (skip proposal submission)").option("--name <name>", "Proposal name").option("--description <text>", "Proposal description").option("--performance-fee <bps>", "Agent fee in bps").option("--duration <duration>", "Strategy duration (7d, 24h, etc.)").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").action(async (templateKey, opts) => {
+  strategy2.command("propose").description("Clone + init + build calls + submit governance proposal (all-in-one)").argument("<template>", "Template: moonwell-supply, aerodrome-lp, venice-inference, wsteth-moonwell, mamo-yield, portfolio").requiredOption("--vault <address>", "Vault address").option("--write-calls <dir>", "Write execute/settle JSON to directory (skip proposal submission)").option("--name <name>", "Proposal name").option("--description <text>", "Proposal description").option("--performance-fee <bps>", "Agent fee in bps").option("--duration <duration>", "Strategy duration (7d, 24h, etc.)").option("--amount <n>", "Asset amount to deploy").option("--min-redeem <n>", "Min asset on settlement (Moonwell)").option("--token <symbol>", "Asset token symbol (default: USDC)").option("--asset <symbol>", "Asset token (USDC, VVV, or address)").option("--agent <address>", "Agent wallet (Venice, default: your wallet)").option("--min-vvv <n>", "Min VVV from swap (Venice)").option("--single-hop", "Single-hop Aerodrome swap (Venice)").option("--token-a <address>", "Token A (Aerodrome)").option("--token-b <address>", "Token B (Aerodrome)").option("--amount-a <n>", "Token A amount (Aerodrome)").option("--amount-b <n>", "Token B amount (Aerodrome)").option("--stable", "Stable pool (Aerodrome)").option("--gauge <address>", "Gauge address (Aerodrome)").option("--lp-token <address>", "LP token address (Aerodrome)").option("--min-a-out <n>", "Min token A on settle (Aerodrome)").option("--min-b-out <n>", "Min token B on settle (Aerodrome)").option("--slippage <bps>", "Slippage tolerance in bps (wstETH, default: 500 = 5%)").option("--mamo-factory <address>", "Mamo StrategyFactory address (Mamo)").option("--tokens <list>", "Comma-separated token addresses or symbols (Portfolio)").option("--weights <list>", "Comma-separated weights in bps, must sum to 10000 (Portfolio)").option("--max-slippage <bps>", "Max slippage bps (Portfolio, default: 500)").option("--fee-tier <n>", "Pool fee tier (Portfolio, default: 3000)").option("--swap-adapter <address>", "Swap adapter address (Portfolio)").action(async (templateKey, opts) => {
     const vault = opts.vault;
     if (!isAddress(vault)) {
       console.error(chalk.red("Invalid vault address"));
@@ -1003,9 +1293,9 @@ function registerStrategyTemplateCommands(strategy2) {
       console.error(chalk.red("Missing --name, --performance-fee, or --duration. Use --write-calls to skip proposal submission."));
       process.exit(1);
     }
-    const { propose: propose2 } = await import("./governor-ZKRSAHG4.js");
+    const { propose: propose2 } = await import("./governor-YPDAOT3S.js");
     const { pinJSON } = await import("./ipfs-22YLNQ2C.js");
-    const { parseDuration: parseDuration2 } = await import("./governor-ZKRSAHG4.js");
+    const { parseDuration: parseDuration2 } = await import("./governor-YPDAOT3S.js");
     const performanceFeeBps = BigInt(opts.performanceFee);
     if (performanceFeeBps < 0n || performanceFeeBps > 10000n) {
       console.error(chalk.red("--performance-fee must be 0-10000 (basis points)"));
@@ -1063,6 +1353,380 @@ function registerStrategyTemplateCommands(strategy2) {
     }
     console.log();
   });
+  strategy2.command("status").description("Show portfolio strategy status \u2014 allocations, balances, drift, PnL (Portfolio only)").argument("<clone>", "Strategy clone address").option("--json", "Output machine-readable JSON for agent consumption").action(async (cloneArg, opts) => {
+    if (!isAddress(cloneArg)) {
+      console.error(chalk.red("Invalid clone address"));
+      process.exit(1);
+    }
+    const clone = cloneArg;
+    const publicClient = getPublicClient();
+    const network = getNetwork();
+    const jsonMode = !!opts.json;
+    const spinner = jsonMode ? null : ora("Reading strategy state...").start();
+    try {
+      const [stateRaw, vault, proposer, assetAddr, totalAmount, maxSlippage, allocations, swapExtraData] = await Promise.all([
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "state" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "vault" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "proposer" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "asset" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "totalAmount" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "maxSlippageBps" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "getAllocations" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "getSwapExtraData" })
+      ]);
+      const stateNames = ["Pending", "Executed", "Settled"];
+      const stateStr = stateNames[Number(stateRaw)] || `Unknown(${stateRaw})`;
+      const [assetDecimals, assetSymbol] = await Promise.all([
+        publicClient.readContract({ address: assetAddr, abi: erc20Abi, functionName: "decimals" }),
+        publicClient.readContract({ address: assetAddr, abi: erc20Abi, functionName: "symbol" })
+      ]);
+      const tokenReads = allocations.map((a) => Promise.all([
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "balanceOf", args: [clone] }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "symbol" }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "decimals" })
+      ]));
+      const tokenData = await Promise.all(tokenReads);
+      const assetBalance = await publicClient.readContract({
+        address: assetAddr,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [clone]
+      });
+      const feeTiers = swapExtraData.map((data) => {
+        try {
+          const [fee] = decodeAbiParameters([{ type: "uint24" }], data);
+          return Number(fee) > 0 && Number(fee) <= 1e5 ? Number(fee) : 3e3;
+        } catch {
+          return 3e3;
+        }
+      });
+      let prices = [];
+      let priceSource = null;
+      try {
+        const { getTokenPricesInAsset } = await import("./price-SWNEGWO4.js");
+        prices = await getTokenPricesInAsset({
+          tokens: allocations.map((a, i) => ({
+            token: a.token,
+            tokenDecimals: tokenData[i][2],
+            feeTier: feeTiers[i]
+          })),
+          asset: assetAddr,
+          assetDecimals
+        });
+        priceSource = prices.find((p) => p !== null)?.source ?? null;
+      } catch {
+      }
+      const pricesAvailable = prices.some((p) => p !== null);
+      const assetBalanceNum = Number(formatUnits(assetBalance, assetDecimals));
+      let totalPortfolioValue = assetBalanceNum;
+      let totalInvested = 0n;
+      const allocStatuses = allocations.map((alloc, i) => {
+        const [balance, symbol, decimals] = tokenData[i];
+        const balanceNum = Number(formatUnits(balance, decimals));
+        const investedNum = Number(formatUnits(alloc.investedAmount, assetDecimals));
+        totalInvested += alloc.investedAmount;
+        const price = prices[i];
+        let currentValue = null;
+        if (price) {
+          currentValue = balanceNum * price.price;
+          totalPortfolioValue += currentValue;
+        }
+        return {
+          token: alloc.token,
+          symbol,
+          decimals,
+          targetWeightBps: Number(alloc.targetWeightBps),
+          balance: formatUnits(balance, decimals),
+          balanceRaw: balance.toString(),
+          investedAmount: formatUnits(alloc.investedAmount, assetDecimals),
+          currentPrice: price?.price ?? null,
+          currentValue,
+          actualWeightBps: null,
+          // computed after totals
+          driftBps: null,
+          pnl: currentValue !== null ? currentValue - investedNum : null,
+          pnlPct: currentValue !== null && investedNum > 0 ? (currentValue - investedNum) / investedNum * 100 : null
+        };
+      });
+      let maxDriftBps = 0;
+      let maxDriftToken = "";
+      if (pricesAvailable && totalPortfolioValue > 0) {
+        for (const a of allocStatuses) {
+          if (a.currentValue !== null) {
+            a.actualWeightBps = Math.round(a.currentValue / totalPortfolioValue * 1e4);
+            a.driftBps = a.actualWeightBps - a.targetWeightBps;
+            if (Math.abs(a.driftBps) > Math.abs(maxDriftBps)) {
+              maxDriftBps = a.driftBps;
+              maxDriftToken = a.symbol;
+            }
+          }
+        }
+      }
+      const totalInvestedNum = Number(formatUnits(totalInvested, assetDecimals));
+      const totalPnl = pricesAvailable ? totalPortfolioValue - totalInvestedNum : null;
+      const totalPnlPct = totalPnl !== null && totalInvestedNum > 0 ? totalPnl / totalInvestedNum * 100 : null;
+      spinner?.succeed("Strategy state loaded");
+      if (jsonMode) {
+        const result = {
+          clone,
+          vault,
+          proposer,
+          state: stateStr,
+          network,
+          asset: { address: assetAddr, symbol: assetSymbol, decimals: assetDecimals },
+          totalDeployed: formatUnits(totalAmount, assetDecimals),
+          maxSlippageBps: Number(maxSlippage),
+          assetBalance: formatUnits(assetBalance, assetDecimals),
+          pricesAvailable,
+          priceSource,
+          portfolio: {
+            totalValue: pricesAvailable ? totalPortfolioValue : null,
+            totalPnl,
+            totalPnlPct
+          },
+          allocations: allocStatuses,
+          maxDriftBps: pricesAvailable ? maxDriftBps : null,
+          maxDriftToken: pricesAvailable ? maxDriftToken : null,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        process.stdout.write(JSON.stringify(result) + "\n");
+        return;
+      }
+      const stateColor = stateStr === "Executed" ? chalk.green : stateStr === "Settled" ? chalk.blue : chalk.yellow;
+      console.log();
+      console.log(chalk.bold("Portfolio Strategy Status"));
+      console.log(chalk.dim("\u2500".repeat(70)));
+      console.log(`  Clone:       ${chalk.cyan(clone)}`);
+      console.log(`  Vault:       ${chalk.cyan(vault)}`);
+      console.log(`  Proposer:    ${chalk.cyan(proposer)}`);
+      console.log(`  State:       ${stateColor(stateStr)}`);
+      console.log(`  Asset:       ${assetSymbol} (${assetAddr})`);
+      console.log(`  Deployed:    ${formatUnits(totalAmount, assetDecimals)} ${assetSymbol}`);
+      console.log(`  Max Slip:    ${Number(maxSlippage) / 100}%`);
+      console.log(`  Asset held:  ${formatUnits(assetBalance, assetDecimals)} ${assetSymbol}`);
+      if (pricesAvailable) {
+        const pvStr = totalPortfolioValue.toFixed(6);
+        const pnlStr = totalPnl !== null ? (totalPnl >= 0 ? "+" : "") + totalPnl.toFixed(6) : "n/a";
+        const pnlPctStr = totalPnlPct !== null ? (totalPnlPct >= 0 ? "+" : "") + totalPnlPct.toFixed(1) + "%" : "";
+        const pnlColor = totalPnl !== null && totalPnl >= 0 ? chalk.green : chalk.red;
+        console.log(`  Value:       ${pvStr} ${assetSymbol}  |  PnL: ${pnlColor(`${pnlStr} (${pnlPctStr})`)}`);
+        console.log(`  Price src:   ${priceSource}`);
+      }
+      console.log();
+      console.log(chalk.bold("Allocations"));
+      console.log(chalk.dim("\u2500".repeat(70)));
+      if (pricesAvailable) {
+        console.log(
+          chalk.dim("  Token".padEnd(10)) + chalk.dim("Target".padEnd(9)) + chalk.dim("Actual".padEnd(9)) + chalk.dim("Drift".padEnd(8)) + chalk.dim("Value".padEnd(16)) + chalk.dim("PnL".padEnd(16)) + chalk.dim("Balance")
+        );
+        for (const a of allocStatuses) {
+          const targetStr = (a.targetWeightBps / 100).toFixed(1) + "%";
+          const actualStr = a.actualWeightBps !== null ? (a.actualWeightBps / 100).toFixed(1) + "%" : "\u2014";
+          const driftStr = a.driftBps !== null ? (a.driftBps >= 0 ? "+" : "") + a.driftBps : "\u2014";
+          const driftColor = a.driftBps !== null ? Math.abs(a.driftBps) > 500 ? chalk.red : Math.abs(a.driftBps) > 200 ? chalk.yellow : chalk.dim : chalk.dim;
+          const valueStr = a.currentValue !== null ? a.currentValue.toFixed(6) : "\u2014";
+          const pnlPctStr = a.pnlPct !== null ? (a.pnlPct >= 0 ? "+" : "") + a.pnlPct.toFixed(1) + "%" : "\u2014";
+          const pnlColor = a.pnlPct !== null ? a.pnlPct >= 0 ? chalk.green : chalk.red : chalk.dim;
+          console.log(
+            `  ${chalk.bold(a.symbol.padEnd(8))}${targetStr.padEnd(9)}${actualStr.padEnd(9)}${driftColor(driftStr.toString().padEnd(8))}${valueStr.padEnd(16)}${pnlColor(pnlPctStr.padEnd(16))}${a.balance}`
+          );
+        }
+      } else {
+        console.log(chalk.dim("  Prices unavailable \u2014 showing raw balances only."));
+        console.log();
+        console.log(
+          chalk.dim("  Token".padEnd(12)) + chalk.dim("Weight".padEnd(10)) + chalk.dim("Invested".padEnd(18)) + chalk.dim("Balance".padEnd(18)) + chalk.dim("Address")
+        );
+        for (const a of allocStatuses) {
+          const weightPct = (a.targetWeightBps / 100).toFixed(1) + "%";
+          console.log(
+            `  ${chalk.bold(a.symbol.padEnd(10))}${weightPct.padEnd(10)}${a.investedAmount.padEnd(18)}${a.balance.padEnd(18)}${chalk.dim(a.token)}`
+          );
+        }
+      }
+      console.log(chalk.dim("\u2500".repeat(70)));
+      console.log(`  Total invested: ${formatUnits(totalInvested, assetDecimals)} ${assetSymbol}`);
+      if (pricesAvailable && maxDriftToken) {
+        const absMaxDrift = Math.abs(maxDriftBps);
+        const driftColor = absMaxDrift > 500 ? chalk.red : absMaxDrift > 200 ? chalk.yellow : chalk.green;
+        console.log(`  Max drift:      ${driftColor(`${maxDriftBps > 0 ? "+" : ""}${maxDriftBps} bps`)} (${maxDriftToken})`);
+      }
+      if (stateStr === "Executed") {
+        console.log();
+        console.log(chalk.dim("Rebalance:  sherwood strategy rebalance " + clone));
+        console.log(chalk.dim("With new weights: sherwood strategy rebalance " + clone + " --new-weights 2500,2500,2000,1500,1500"));
+      }
+      console.log();
+    } catch (err) {
+      spinner?.fail("Failed to read strategy state");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  strategy2.command("rebalance").description("Rebalance a portfolio strategy \u2014 sell all positions, re-buy at target weights (Portfolio only)").argument("<clone>", "Strategy clone address").option("--new-weights <list>", "Comma-separated new weights in bps (must sum to 10000). Updates weights before rebalancing.").option("--max-slippage <bps>", "New max slippage bps (used with --new-weights)").option("--dry-run", "Show what would happen without executing").action(async (cloneArg, opts) => {
+    if (!isAddress(cloneArg)) {
+      console.error(chalk.red("Invalid clone address"));
+      process.exit(1);
+    }
+    const clone = cloneArg;
+    const publicClient = getPublicClient();
+    const account = getAccount();
+    const chain = getChain();
+    const verifySpinner = ora("Verifying strategy state...").start();
+    try {
+      const [stateRaw, proposer, assetAddr, allocations] = await Promise.all([
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "state" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "proposer" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "asset" }),
+        publicClient.readContract({ address: clone, abi: PORTFOLIO_STRATEGY_ABI, functionName: "getAllocations" })
+      ]);
+      if (Number(stateRaw) !== 1) {
+        const stateNames = ["Pending", "Executed", "Settled"];
+        verifySpinner.fail(`Strategy is ${stateNames[Number(stateRaw)] || "Unknown"}, must be Executed to rebalance`);
+        process.exit(1);
+      }
+      if (proposer.toLowerCase() !== account.address.toLowerCase()) {
+        verifySpinner.fail(`Only the proposer (${proposer}) can rebalance. Your wallet: ${account.address}`);
+        process.exit(1);
+      }
+      const [assetDecimals, assetSymbol] = await Promise.all([
+        publicClient.readContract({ address: assetAddr, abi: erc20Abi, functionName: "decimals" }),
+        publicClient.readContract({ address: assetAddr, abi: erc20Abi, functionName: "symbol" })
+      ]);
+      const tokenReads = allocations.map((a) => Promise.all([
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "balanceOf", args: [clone] }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "symbol" }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "decimals" })
+      ]));
+      const tokenData = await Promise.all(tokenReads);
+      verifySpinner.succeed("Strategy is Executed \u2014 ready to rebalance");
+      console.log();
+      console.log(chalk.bold("Current Allocations"));
+      console.log(chalk.dim("\u2500".repeat(50)));
+      for (let i = 0; i < allocations.length; i++) {
+        const alloc = allocations[i];
+        const [balance, symbol, decimals] = tokenData[i];
+        const weightPct = (Number(alloc.targetWeightBps) / 100).toFixed(1) + "%";
+        console.log(
+          `  ${chalk.bold(symbol.padEnd(8))} ${weightPct.padEnd(8)} bal: ${formatUnits(balance, decimals)}`
+        );
+      }
+      let newWeightsBps;
+      if (opts.newWeights) {
+        newWeightsBps = opts.newWeights.split(",").map((w) => Number(w.trim()));
+        if (newWeightsBps.length !== allocations.length) {
+          console.error(chalk.red(`--new-weights must have ${allocations.length} values (one per token)`));
+          process.exit(1);
+        }
+        const weightSum = newWeightsBps.reduce((a, b) => a + b, 0);
+        if (weightSum !== 1e4) {
+          console.error(chalk.red(`Weights must sum to 10000, got ${weightSum}`));
+          process.exit(1);
+        }
+        console.log();
+        console.log(chalk.bold("New Target Weights"));
+        console.log(chalk.dim("\u2500".repeat(50)));
+        for (let i = 0; i < allocations.length; i++) {
+          const [, symbol] = tokenData[i];
+          const oldPct = (Number(allocations[i].targetWeightBps) / 100).toFixed(1);
+          const newPct = (newWeightsBps[i] / 100).toFixed(1);
+          const arrow = oldPct !== newPct ? chalk.yellow("\u2192") : chalk.dim("\u2192");
+          console.log(`  ${chalk.bold(symbol.padEnd(8))} ${oldPct}% ${arrow} ${newPct}%`);
+        }
+      }
+      if (opts.dryRun) {
+        console.log();
+        console.log(chalk.yellow("Dry run \u2014 no transactions sent."));
+        console.log(chalk.dim("The rebalance would:"));
+        console.log(chalk.dim("  1. Sell all current token positions back to " + assetSymbol));
+        console.log(chalk.dim("  2. Re-buy at " + (newWeightsBps ? "new" : "current") + " target weights"));
+        console.log();
+        return;
+      }
+      if (newWeightsBps) {
+        const maxSlip = Number(opts.maxSlippage || "0");
+        const swapData = await publicClient.readContract({
+          address: clone,
+          abi: PORTFOLIO_STRATEGY_ABI,
+          functionName: "getSwapExtraData"
+        });
+        const updateSpinner = ora("Updating target weights...").start();
+        try {
+          const innerData = encodeAbiParameters7(
+            [{ type: "uint256[]" }, { type: "uint256" }, { type: "bytes[]" }],
+            [newWeightsBps.map((w) => BigInt(w)), BigInt(maxSlip), swapData]
+          );
+          const updateHash = await writeContractWithRetry({
+            account,
+            chain,
+            address: clone,
+            abi: PORTFOLIO_STRATEGY_ABI,
+            functionName: "updateParams",
+            args: [innerData]
+          });
+          const receipt = await waitForReceipt(updateHash);
+          if (receipt.status === "reverted") throw new Error("updateParams reverted");
+          updateSpinner.succeed("Target weights updated");
+          console.log(chalk.dim(`  Tx: ${getExplorerUrl(updateHash)}`));
+        } catch (err) {
+          updateSpinner.fail("Failed to update weights");
+          console.error(chalk.red(formatContractError(err)));
+          process.exit(1);
+        }
+      }
+      const rebalanceSpinner = ora("Rebalancing portfolio (sell all \u2192 re-buy at targets)...").start();
+      try {
+        const rebalanceHash = await writeContractWithRetry({
+          account,
+          chain,
+          address: clone,
+          abi: PORTFOLIO_STRATEGY_ABI,
+          functionName: "rebalance"
+        });
+        const receipt = await waitForReceipt(rebalanceHash);
+        if (receipt.status === "reverted") throw new Error("rebalance() reverted on-chain");
+        rebalanceSpinner.succeed("Portfolio rebalanced");
+        console.log(chalk.dim(`  Tx: ${getExplorerUrl(rebalanceHash)}`));
+      } catch (err) {
+        rebalanceSpinner.fail("Rebalance failed");
+        console.error(chalk.red(formatContractError(err)));
+        process.exit(1);
+      }
+      const postSpinner = ora("Reading updated allocations...").start();
+      const postAllocations = await publicClient.readContract({
+        address: clone,
+        abi: PORTFOLIO_STRATEGY_ABI,
+        functionName: "getAllocations"
+      });
+      const postReads = postAllocations.map((a) => Promise.all([
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "balanceOf", args: [clone] }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "symbol" }),
+        publicClient.readContract({ address: a.token, abi: erc20Abi, functionName: "decimals" })
+      ]));
+      const postData = await Promise.all(postReads);
+      postSpinner.succeed("Updated allocations");
+      console.log();
+      console.log(chalk.bold("Post-Rebalance Allocations"));
+      console.log(chalk.dim("\u2500".repeat(50)));
+      for (let i = 0; i < postAllocations.length; i++) {
+        const alloc = postAllocations[i];
+        const [balance, symbol, decimals] = postData[i];
+        const weightPct = (Number(alloc.targetWeightBps) / 100).toFixed(1) + "%";
+        const investedStr = formatUnits(alloc.investedAmount, assetDecimals);
+        console.log(
+          `  ${chalk.bold(symbol.padEnd(8))} ${weightPct.padEnd(8)} invested: ${investedStr.padEnd(14)} bal: ${formatUnits(balance, decimals)}`
+        );
+      }
+      console.log();
+      console.log(chalk.green("\u2713 Rebalance complete"));
+      console.log();
+    } catch (err) {
+      if (err.code === "ERR_MODULE_NOT_FOUND" || err instanceof TypeError) throw err;
+      verifySpinner.fail("Pre-flight check failed");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
 }
 
 // src/lib/factory.ts
@@ -1250,7 +1914,7 @@ async function getActiveSyndicates2(creator) {
 }
 
 // src/commands/venice.ts
-import { formatUnits as formatUnits2, isAddress as isAddress2 } from "viem";
+import { formatUnits as formatUnits3, isAddress as isAddress2 } from "viem";
 import chalk2 from "chalk";
 import ora2 from "ora";
 import { readFileSync } from "fs";
@@ -1273,7 +1937,7 @@ function registerVeniceCommands(program2) {
         console.log(chalk2.yellow("  Use the VeniceInferenceStrategy via a proposal to distribute sVVV to agents."));
         process.exit(1);
       }
-      checkSpinner.succeed(`sVVV balance: ${formatUnits2(sVvvBalance, 18)}`);
+      checkSpinner.succeed(`sVVV balance: ${formatUnits3(sVvvBalance, 18)}`);
     } catch (err) {
       checkSpinner.fail("Failed to check sVVV balance");
       console.error(chalk2.red(formatContractError(err)));
@@ -1286,7 +1950,7 @@ function registerVeniceCommands(program2) {
       console.log(chalk2.dim(`  Key: ${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`));
       console.log(chalk2.dim("  Saved to ~/.sherwood/config.json"));
       try {
-        const { createVeniceProvisionAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-X5UIEM6D.js");
+        const { createVeniceProvisionAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-YZIHYQAI.js");
         const { uid } = await createVeniceProvisionAttestation(account.address);
         if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
           console.log(chalk2.dim(`  Attested: ${getEasScanUrl2(uid)}`));
@@ -1358,17 +2022,17 @@ function registerVeniceCommands(program2) {
       console.log(chalk2.bold("Venice Inference Status"));
       console.log(chalk2.dim("\u2500".repeat(50)));
       console.log(chalk2.bold("\n  Vault"));
-      console.log(`    Profit available:  ${formatUnits2(profit, assetDecimals)} ${assetSymbol}`);
-      console.log(`    VVV (unstaked):    ${formatUnits2(vaultVvvBalance, 18)}`);
+      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}: ${formatUnits2(balance, 18)} sVVV`);
+        console.log(`    ${label}: ${formatUnits3(balance, 18)} sVVV`);
       }
       console.log(chalk2.bold("\n  Your Wallet"));
-      console.log(`    sVVV:              ${formatUnits2(mySvvv, 18)}`);
-      console.log(`    Pending rewards:   ${formatUnits2(myPending, 18)} VVV`);
+      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")}`);
@@ -1437,10 +2101,10 @@ ${opts.prompt}`;
         console.log(chalk2.dim(`Model: ${result.model} | Tokens: ${result.usage.promptTokens} in, ${result.usage.completionTokens} out, ${result.usage.totalTokens} total`));
       }
       try {
-        const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-X5UIEM6D.js");
+        const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-YZIHYQAI.js");
         const { keccak256, toHex, isAddress: isAddr } = await import("viem");
-        const { getChainContracts: getChainContracts2 } = await import("./config-BGS5MX4D.js");
-        const { getChain: getActiveChain } = await import("./network-UTSOP7EF.js");
+        const { getChainContracts: getChainContracts2 } = await import("./config-YXZKPSZB.js");
+        const { getChain: getActiveChain } = await import("./network-QEMP3DSP.js");
         const vaultRecipient = opts.vault && isAddr(opts.vault) ? opts.vault : getChainContracts2(getActiveChain().id).vault;
         const promptHash = keccak256(toHex(userContent)).slice(0, 18);
         const { uid } = await createVeniceInferenceAttestation(
@@ -1464,12 +2128,12 @@ ${opts.prompt}`;
 }
 
 // src/commands/allowance.ts
-import { parseUnits as parseUnits4, formatUnits as formatUnits3, isAddress as isAddress3 } from "viem";
+import { parseUnits as parseUnits4, formatUnits as formatUnits4, isAddress as isAddress3 } from "viem";
 import chalk3 from "chalk";
 import ora3 from "ora";
 
 // src/strategies/allowance-disburse.ts
-import { encodeFunctionData as encodeFunctionData6, parseUnits as parseUnits3 } from "viem";
+import { encodeFunctionData as encodeFunctionData7, parseUnits as parseUnits3 } from "viem";
 function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minUsdc, swapPath) {
   const assetAmount = parseUnits3(config.amount, assetDecimals);
   const isUsdc = assetAddress.toLowerCase() === TOKENS().USDC.toLowerCase();
@@ -1478,7 +2142,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
   if (!isUsdc) {
     calls.push({
       target: assetAddress,
-      data: encodeFunctionData6({
+      data: encodeFunctionData7({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [UNISWAP().SWAP_ROUTER, assetAmount]
@@ -1488,7 +2152,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     if (isWeth) {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData6({
+        data: encodeFunctionData7({
           abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
           functionName: "exactInputSingle",
           args: [
@@ -1508,7 +2172,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     } else {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData6({
+        data: encodeFunctionData7({
           abi: SWAP_ROUTER_ABI,
           functionName: "exactInput",
           args: [
@@ -1528,7 +2192,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
   for (const agent of agents) {
     calls.push({
       target: TOKENS().USDC,
-      data: encodeFunctionData6({
+      data: encodeFunctionData7({
         abi: ERC20_ABI,
         functionName: "transfer",
         args: [agent, perAgent]
@@ -1593,9 +2257,9 @@ function registerAllowanceCommands(program2) {
     console.log(chalk3.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(`  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})`}`);
@@ -1604,7 +2268,7 @@ function registerAllowanceCommands(program2) {
     console.log(`  Vault:         ${vaultAddress}`);
     console.log();
     if (requestedAmount > profit) {
-      console.warn(chalk3.yellow(`  Warning: amount (${opts.amount}) exceeds available profit (${formatUnits3(profit, assetDecimals)})`));
+      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();
     }
@@ -1638,7 +2302,7 @@ function registerAllowanceCommands(program2) {
         }
         minUsdc = applySlippage(amountOut, slippageBps);
         quoteSpinner.succeed(
-          `Quote: ${formatUnits3(amountOut, 6)} USDC (min: ${formatUnits3(minUsdc, 6)}, per agent: ${formatUnits3(minUsdc / BigInt(agents.length), 6)})`
+          `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");
@@ -1648,7 +2312,7 @@ function registerAllowanceCommands(program2) {
     }
     const perAgent = minUsdc / BigInt(agents.length);
     if (isUsdc) {
-      console.log(chalk3.dim(`  Per agent: ${formatUnits3(perAgent, 6)} USDC`));
+      console.log(chalk3.dim(`  Per agent: ${formatUnits4(perAgent, 6)} USDC`));
       console.log();
     }
     const config = {
@@ -1715,14 +2379,14 @@ function registerAllowanceCommands(program2) {
       console.log(chalk3.dim("\u2500".repeat(50)));
       console.log(chalk3.bold("\n  Vault"));
       console.log(`    Asset:           ${assetSymbol}`);
-      console.log(`    Balance:         ${formatUnits3(assetBalance, assetDecimals)} ${assetSymbol}`);
-      console.log(`    Deposited:       ${formatUnits3(totalDeposited, assetDecimals)} ${assetSymbol}`);
-      console.log(`    Profit:          ${formatUnits3(profit, assetDecimals)} ${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}: ${formatUnits3(balance, 6)} USDC`);
+        console.log(`    ${label}: ${formatUnits4(balance, 6)} USDC`);
       }
       console.log();
     } catch (err) {
@@ -1927,7 +2591,7 @@ function parseBigIntArg(value, name) {
 }
 
 // src/lib/simulate.ts
-import { decodeFunctionData, encodeFunctionData as encodeFunctionData7 } from "viem";
+import { decodeFunctionData, encodeFunctionData as encodeFunctionData8 } from "viem";
 import chalk5 from "chalk";
 var G = chalk5.green;
 var W = chalk5.white;
@@ -2446,7 +3110,7 @@ async function simulateViaApi(vault, calls) {
 async function simulateViaEthCall(vault, calls) {
   const governor = getGovernorAddress();
   const client = getPublicClient();
-  const input2 = encodeFunctionData7({
+  const input2 = encodeFunctionData8({
     abi: SYNDICATE_VAULT_ABI,
     functionName: "executeGovernorBatch",
     args: [calls.map((c) => ({ target: c.target, data: c.data, value: c.value }))]
@@ -2569,8 +3233,8 @@ function printSimulationResult(result, callType) {
 }
 async function sendSimulationAlert(subdomain, proposalId, vault, execResult, settleResult) {
   try {
-    const xmtp = await import("./xmtp-XKHXATPQ.js");
-    const { getAccount: getAccount2 } = await import("./client-SCIY6SUP.js");
+    const xmtp = await import("./xmtp-YNOGIZ4G.js");
+    const { getAccount: getAccount2 } = await import("./client-CWQFYZ5Z.js");
     const group = await xmtp.getGroup("", subdomain);
     const allRisks = [...execResult.risks, ...settleResult?.risks ?? []];
     const criticals = allRisks.filter((r) => r.level === "critical");
@@ -3262,7 +3926,7 @@ try {
 var require2 = createRequire(import.meta.url);
 var { version: CLI_VERSION } = require2("../package.json");
 async function loadXmtp() {
-  return import("./xmtp-XKHXATPQ.js");
+  return import("./xmtp-YNOGIZ4G.js");
 }
 async function loadCron() {
   return import("./cron-EOULYO3R.js");
@@ -3508,8 +4172,11 @@ syndicate.command("create").description("Create a new syndicate via the factory
       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);
+      try {
+        await setTextRecord(subdomain, "xmtpGroupId", groupId, result.vault);
+      } catch {
+      }
     } catch {
       console.warn(chalk8.yellow("\n  \u26A0 Could not create XMTP chat group"));
       console.warn(chalk8.dim(`    Recover later with: sherwood chat ${subdomain} init`));
@@ -4222,7 +4889,7 @@ vaultCmd.command("balance").description("Show LP share balance and asset value")
 var strategy = program.command("strategy").description("Strategy templates \u2014 list, clone, propose");
 registerStrategyTemplateCommands(strategy);
 program.command("providers").description("List available DeFi providers").action(async () => {
-  const { MessariProvider, NansenProvider } = await import("./research-W3M3VZBD.js");
+  const { MessariProvider, NansenProvider } = await import("./research-ZX7T2ZIJ.js");
   const providers = [new MoonwellProvider(), new UniswapProvider(), new MessariProvider(), new NansenProvider()];
   for (const p of providers) {
     const info = p.info();
@@ -4233,7 +4900,7 @@ ${info.name} (${info.type})`);
   }
 });
 try {
-  const { registerChatCommands } = await import("./chat-JYAJMP4D.js");
+  const { registerChatCommands } = await import("./chat-52PWNH7Y.js");
   registerChatCommands(program);
 } catch {
   program.command("chat <name> [action] [actionArgs...]").description("Syndicate chat (XMTP) \u2014 requires @xmtp/cli").action(() => {
@@ -4243,16 +4910,16 @@ try {
     process.exit(1);
   });
 }
-var { registerSessionCommands } = await import("./session-XZNKLK3I.js");
+var { registerSessionCommands } = await import("./session-NMA4RLKC.js");
 registerSessionCommands(program);
 registerVeniceCommands(program);
 registerAllowanceCommands(program);
 registerIdentityCommands(program);
 registerProposalCommands(program);
 registerGovernorCommands(program);
-var { registerResearchCommands } = await import("./research-EWH43HFN.js");
+var { registerResearchCommands } = await import("./research-PH77VSE4.js");
 registerResearchCommands(program);
-var { registerTradeCommands } = await import("./trade-VKSXEHWW.js");
+var { registerTradeCommands } = await import("./trade-N2A74UPX.js");
 registerTradeCommands(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").option("--rpc <url>", "Custom RPC URL for the active --chain network").option("--notify-to <id>", "Destination for cron summaries (Telegram chat ID, phone, etc.)").option("--uniswap-api-key <key>", "Uniswap Trading API key (from developers.uniswap.org)").option("--venice-api-key <key>", "Venice AI inference API key").action((opts) => {