@sherwoodagent/cli 0.15.3 → 0.17.1

package/dist/index.js

@@ -1,4 +1,35 @@
 #!/usr/bin/env node
+import {
+  PROPOSAL_STATE,
+  PROPOSAL_STATES,
+  VOTE_TYPE,
+  cancelProposal,
+  emergencyCancel,
+  emergencySettle,
+  executeProposal,
+  getCapitalSnapshot,
+  getExecuteCalls,
+  getGovernorAddress,
+  getGovernorParams,
+  getProposal,
+  getProposalState,
+  getRegisteredVaults,
+  getSettlementCalls,
+  getVoteWeight,
+  hasVoted,
+  parseDuration,
+  proposalCount,
+  propose,
+  setCooldownPeriod,
+  setExecutionWindow,
+  setMaxPerformanceFeeBps,
+  setMaxStrategyDuration,
+  setProtocolFeeBps,
+  setVetoThresholdBps,
+  setVotingPeriod,
+  settleProposal,
+  vote
+} from "./chunk-A4F6KTXA.js";
 import {
   fetchMetadata,
   uploadMetadata
@@ -10,7 +41,7 @@ import {
   queryApprovals,
   queryJoinRequests,
   revokeAttestation
-} from "./chunk-AK7BD7KH.js";
+} from "./chunk-X3L57WGW.js";
 import {
   approveDepositor,
   deposit,
@@ -26,23 +57,24 @@ import {
   resolveVaultSyndicate,
   setTextRecord,
   setVaultAddress
-} from "./chunk-LACUMLU4.js";
+} from "./chunk-EMPYAZNP.js";
 import {
+  AERODROME,
   AGENT_REGISTRY,
+  BASE_STRATEGY_ABI,
   EAS_SCHEMAS,
   ERC20_ABI,
   MOONWELL,
   SHERWOOD,
-  STRATEGY_REGISTRY_ABI,
+  STRATEGY_TEMPLATES,
   SYNDICATE_FACTORY_ABI,
-  SYNDICATE_GOVERNOR_ABI,
   SYNDICATE_VAULT_ABI,
   TOKENS,
   UNISWAP,
   UNISWAP_QUOTER_V2_ABI,
   VENICE,
   VENICE_STAKING_ABI
-} from "./chunk-GC5J54OC.js";
+} from "./chunk-UQKNCRDW.js";
 import {
   getAccount,
   getPublicClient,
@@ -76,7 +108,7 @@ import {
 import { config as loadDotenv } from "dotenv";
 import { createRequire } from "module";
 import { Command, Option } from "commander";
-import { parseUnits as parseUnits8, isAddress as isAddress5 } from "viem";
+import { parseUnits as parseUnits7, isAddress as isAddress5 } from "viem";
 import chalk7 from "chalk";
 import ora7 from "ora";
 import { input, confirm, select } from "@inquirer/prompts";
@@ -137,342 +169,622 @@ var UniswapProvider = class {
   }
 };
 
-// src/commands/strategy-run.ts
-import { parseUnits as parseUnits2, formatUnits, isAddress } from "viem";
+// src/commands/strategy-template.ts
+import { parseUnits, isAddress, erc20Abi } from "viem";
 import chalk from "chalk";
 import ora from "ora";
+import { writeFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
 
-// 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[]" }]
+// src/lib/clone.ts
+import { concat } from "viem";
+async function cloneTemplate(template) {
+  const creationCode = concat([
+    "0x3d602d80600a3d3981f3363d3d373d3d3d363d73",
+    template,
+    "0x5af43d82803e903d91602b57fd5bf3"
+  ]);
+  const wallet = getWalletClient();
+  const account = getAccount();
+  const chain = getChain();
+  const hash = await wallet.sendTransaction({
+    account,
+    chain,
+    data: creationCode,
+    value: 0n
+  });
+  const receipt = await getPublicClient().waitForTransactionReceipt({ hash });
+  if (!receipt.contractAddress) {
+    throw new Error(`Clone deployment failed \u2014 no contract address in receipt (tx: ${hash})`);
   }
-];
-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" }
-        ]
-      }
+  return { clone: receipt.contractAddress, hash };
+}
+
+// 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/strategies/moonwell-supply-template.ts
+import { encodeAbiParameters, encodeFunctionData } from "viem";
+function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount) {
+  return encodeAbiParameters(
+    [
+      { type: "address" },
+      { type: "address" },
+      { type: "uint256" },
+      { type: "uint256" }
     ],
-    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
+    [underlying, mToken, supplyAmount, minRedeemAmount]
+  );
+}
+function buildExecuteCalls(clone, underlying, supplyAmount) {
+  return [
     {
-      target: TOKENS().WETH,
+      target: underlying,
       data: encodeFunctionData({
-        abi: ERC20_ABI2,
+        abi: ERC20_ABI,
         functionName: "approve",
-        args: [MOONWELL().mWETH, collateral]
+        args: [clone, supplyAmount]
       }),
       value: 0n
     },
-    // 2. Deposit WETH as collateral (mint mWETH tokens)
     {
-      target: MOONWELL().mWETH,
+      target: clone,
       data: encodeFunctionData({
-        abi: MTOKEN_ABI,
-        functionName: "mint",
-        args: [collateral]
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
       }),
       value: 0n
-    },
-    // 3. Enter WETH market (enable as collateral for borrowing)
+    }
+  ];
+}
+function buildSettleCalls(clone) {
+  return [
     {
-      target: MOONWELL().COMPTROLLER,
+      target: clone,
       data: encodeFunctionData({
-        abi: COMPTROLLER_ABI,
-        functionName: "enterMarkets",
-        args: [[MOONWELL().mWETH]]
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
       }),
       value: 0n
-    },
-    // 4. Borrow USDC against WETH collateral
+    }
+  ];
+}
+
+// src/strategies/venice-inference-template.ts
+import { encodeAbiParameters as encodeAbiParameters2, encodeFunctionData as encodeFunctionData2 } from "viem";
+var INIT_PARAMS_TYPES = [
+  {
+    type: "tuple",
+    components: [
+      { name: "asset", type: "address" },
+      { name: "weth", type: "address" },
+      { name: "vvv", type: "address" },
+      { name: "sVVV", type: "address" },
+      { name: "aeroRouter", type: "address" },
+      { name: "aeroFactory", type: "address" },
+      { name: "agent", type: "address" },
+      { name: "assetAmount", type: "uint256" },
+      { name: "minVVV", type: "uint256" },
+      { name: "deadlineOffset", type: "uint256" },
+      { name: "singleHop", type: "bool" }
+    ]
+  }
+];
+function buildInitData2(params) {
+  return encodeAbiParameters2(INIT_PARAMS_TYPES, [params]);
+}
+function buildExecuteCalls2(clone, asset, assetAmount) {
+  return [
     {
-      target: MOONWELL().mUSDC,
-      data: encodeFunctionData({
-        abi: MTOKEN_ABI,
-        functionName: "borrow",
-        args: [borrow]
+      target: asset,
+      data: encodeFunctionData2({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, assetAmount]
       }),
       value: 0n
     },
-    // 5. Approve SwapRouter to pull borrowed USDC
     {
-      target: TOKENS().USDC,
-      data: encodeFunctionData({
-        abi: ERC20_ABI2,
-        functionName: "approve",
-        args: [UNISWAP().SWAP_ROUTER, borrow]
+      target: clone,
+      data: encodeFunctionData2({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
       }),
       value: 0n
-    },
-    // 6. Swap USDC → target token
+    }
+  ];
+}
+function buildSettleCalls2(clone) {
+  return [
     {
-      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
-          }
-        ]
+      target: clone,
+      data: encodeFunctionData2({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
       }),
       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
-      }
+// src/strategies/aerodrome-lp-template.ts
+import { encodeAbiParameters as encodeAbiParameters3, encodeFunctionData as encodeFunctionData3 } from "viem";
+var INIT_PARAMS_TYPES2 = [
+  {
+    type: "tuple",
+    components: [
+      { name: "tokenA", type: "address" },
+      { name: "tokenB", type: "address" },
+      { name: "stable", type: "bool" },
+      { name: "factory", type: "address" },
+      { name: "router", type: "address" },
+      { name: "gauge", type: "address" },
+      { name: "lpToken", type: "address" },
+      { name: "amountADesired", type: "uint256" },
+      { name: "amountBDesired", type: "uint256" },
+      { name: "amountAMin", type: "uint256" },
+      { name: "amountBMin", type: "uint256" },
+      { name: "minAmountAOut", type: "uint256" },
+      { name: "minAmountBOut", type: "uint256" }
     ]
-  });
-  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 buildInitData3(params) {
+  return encodeAbiParameters3(INIT_PARAMS_TYPES2, [params]);
 }
-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 }));
+function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
+  return [
+    {
+      target: tokenA,
+      data: encodeFunctionData3({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, amountA]
+      }),
+      value: 0n
+    },
+    {
+      target: tokenB,
+      data: encodeFunctionData3({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [clone, amountB]
+      }),
+      value: 0n
+    },
+    {
+      target: clone,
+      data: encodeFunctionData3({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "execute"
+      }),
+      value: 0n
     }
-  }
-  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");
+function buildSettleCalls3(clone) {
+  return [
+    {
+      target: clone,
+      data: encodeFunctionData3({
+        abi: BASE_STRATEGY_ABI,
+        functionName: "settle"
+      }),
+      value: 0n
+    }
+  ];
 }
 
-// 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}`));
+// src/commands/strategy-template.ts
+var ZERO = "0x0000000000000000000000000000000000000000";
+var TEMPLATES = [
+  {
+    name: "Moonwell Supply",
+    key: "moonwell-supply",
+    description: "Supply tokens to Moonwell lending market, earn yield",
+    addressKey: "MOONWELL_SUPPLY"
+  },
+  {
+    name: "Aerodrome LP",
+    key: "aerodrome-lp",
+    description: "Provide liquidity on Aerodrome DEX + optional gauge staking",
+    addressKey: "AERODROME_LP"
+  },
+  {
+    name: "Venice Inference",
+    key: "venice-inference",
+    description: "Stake VVV for sVVV \u2014 Venice private AI inference",
+    addressKey: "VENICE_INFERENCE"
+  }
+];
+function resolveTemplate(key) {
+  const def = TEMPLATES.find((t) => t.key === key);
+  if (!def) {
+    console.error(chalk.red(`Unknown template: ${key}`));
+    console.error(chalk.dim(`Available: ${TEMPLATES.map((t) => t.key).join(", ")}`));
     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(", ")}`));
+  const address = STRATEGY_TEMPLATES()[def.addressKey];
+  if (address === ZERO) {
+    console.error(chalk.red(`Template "${def.name}" not deployed on this network.`));
     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"
-      })
+  return { def, address };
+}
+async function buildInitDataForTemplate(templateKey, opts, vault) {
+  if (templateKey === "moonwell-supply") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for moonwell-supply template"));
+      process.exit(1);
+    }
+    const token = opts.token || "USDC";
+    const underlying = resolveToken(token);
+    const mToken = resolveMToken(token);
+    const decimals = token.toUpperCase() === "USDC" ? 6 : 18;
+    const supplyAmount = parseUnits(opts.amount, decimals);
+    const minRedeem = parseUnits(opts.minRedeem || opts.amount, decimals);
+    return {
+      initData: buildInitData(underlying, mToken, supplyAmount, minRedeem),
+      asset: underlying,
+      assetAmount: supplyAmount
+    };
+  }
+  if (templateKey === "venice-inference") {
+    if (!opts.amount) {
+      console.error(chalk.red("--amount is required for venice-inference template"));
+      process.exit(1);
+    }
+    const assetSymbol = opts.asset || "USDC";
+    const asset = resolveToken(assetSymbol);
+    const vvv = VENICE().VVV;
+    const isDirect = asset.toLowerCase() === vvv.toLowerCase();
+    const decimals = assetSymbol.toUpperCase() === "USDC" ? 6 : 18;
+    const assetAmount = parseUnits(opts.amount, decimals);
+    const agent = opts.agent || getAccount().address;
+    const params = {
+      asset,
+      weth: isDirect ? ZERO : TOKENS().WETH,
+      vvv,
+      sVVV: VENICE().STAKING,
+      aeroRouter: isDirect ? ZERO : AERODROME().ROUTER,
+      aeroFactory: isDirect ? ZERO : AERODROME().FACTORY,
+      agent,
+      assetAmount,
+      minVVV: isDirect ? 0n : parseUnits(opts.minVvv || "0", 18),
+      deadlineOffset: 300n,
+      singleHop: !!opts.singleHop
+    };
+    return {
+      initData: buildInitData2(params),
+      asset,
+      assetAmount
+    };
+  }
+  if (templateKey === "aerodrome-lp") {
+    for (const flag of ["tokenA", "tokenB", "amountA", "amountB", "lpToken"]) {
+      if (!opts[flag]) {
+        console.error(chalk.red(`--${flag.replace(/([A-Z])/g, "-$1").toLowerCase()} is required for aerodrome-lp template`));
+        process.exit(1);
+      }
+    }
+    const tokenA = opts.tokenA;
+    const tokenB = opts.tokenB;
+    const publicClient = getPublicClient();
+    const [decimalsA, decimalsB] = await Promise.all([
+      publicClient.readContract({ address: tokenA, abi: erc20Abi, functionName: "decimals" }),
+      publicClient.readContract({ address: tokenB, abi: erc20Abi, functionName: "decimals" })
     ]);
-  } catch {
-    console.error(chalk.red(`Could not read token decimals \u2014 are the addresses valid ERC20s?`));
-    process.exit(1);
+    const amountA = parseUnits(opts.amountA, decimalsA);
+    const amountB = parseUnits(opts.amountB, decimalsB);
+    const minAOut = parseUnits(opts.minAOut || "0", decimalsA);
+    const minBOut = parseUnits(opts.minBOut || "0", decimalsB);
+    const params = {
+      tokenA,
+      tokenB,
+      stable: !!opts.stable,
+      factory: AERODROME().FACTORY,
+      router: AERODROME().ROUTER,
+      gauge: opts.gauge || ZERO,
+      lpToken: opts.lpToken,
+      amountADesired: amountA,
+      amountBDesired: amountB,
+      amountAMin: amountA,
+      // use desired as min for now
+      amountBMin: amountB,
+      minAmountAOut: minAOut,
+      minAmountBOut: minBOut
+    };
+    return {
+      initData: buildInitData3(params),
+      asset: tokenA,
+      assetAmount: amountA,
+      extraApprovals: [{ token: tokenB, amount: amountB }]
+    };
   }
-  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);
+  throw new Error(`No init builder for template: ${templateKey}`);
+}
+function buildCallsForTemplate(templateKey, clone, asset, assetAmount, extraApprovals) {
+  if (templateKey === "moonwell-supply") {
+    return {
+      executeCalls: buildExecuteCalls(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls(clone)
+    };
   }
-  const config = {
-    collateralAmount: opts.collateral,
-    borrowAmount: opts.borrow,
-    targetToken,
-    fee: feeTier,
-    slippageBps,
-    profitTargetBps: 2e3,
-    // 20% default
-    stopLossBps: 1e3
-    // 10% default
+  if (templateKey === "venice-inference") {
+    return {
+      executeCalls: buildExecuteCalls2(clone, asset, assetAmount),
+      settleCalls: buildSettleCalls2(clone)
+    };
+  }
+  if (templateKey === "aerodrome-lp") {
+    const tokenB = extraApprovals?.[0]?.token ?? ZERO;
+    const amountB = extraApprovals?.[0]?.amount ?? 0n;
+    return {
+      executeCalls: buildExecuteCalls3(clone, asset, assetAmount, tokenB, amountB),
+      settleCalls: buildSettleCalls3(clone)
+    };
+  }
+  throw new Error(`No call builder for template: ${templateKey}`);
+}
+function resolveToken(symbolOrAddress) {
+  if (isAddress(symbolOrAddress)) return symbolOrAddress;
+  const upper = symbolOrAddress.toUpperCase();
+  const tokens = TOKENS();
+  const tokenMap = {
+    USDC: tokens.USDC,
+    WETH: tokens.WETH,
+    DAI: tokens.DAI,
+    AERO: tokens.AERO,
+    VVV: VENICE().VVV
   };
-  const calls = buildEntryBatch(config, vaultAddress, minOut, borrowDecimals);
-  console.log();
-  console.log(chalk.bold("Batch calls (6):"));
-  console.log(formatBatch(calls));
-  console.log();
-  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 addr = tokenMap[upper];
+  if (!addr || addr === ZERO) {
+    console.error(chalk.red(`Unknown token: ${symbolOrAddress}`));
+    process.exit(1);
   }
-  const execSpinner = ora("Executing batch via vault...").start();
-  try {
-    const txHash = await executeBatch(calls);
-    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)));
+  return addr;
+}
+function resolveMToken(tokenSymbol) {
+  const upper = tokenSymbol.toUpperCase();
+  const moonwell = MOONWELL();
+  const mTokenMap = {
+    USDC: moonwell.mUSDC,
+    WETH: moonwell.mWETH
+  };
+  const addr = mTokenMap[upper];
+  if (!addr || addr === ZERO) {
+    console.error(chalk.red(`No Moonwell market for: ${tokenSymbol}`));
     process.exit(1);
   }
+  return addr;
+}
+function serializeCalls(calls) {
+  return JSON.stringify(
+    calls.map((c) => ({
+      target: c.target,
+      data: c.data,
+      value: c.value.toString()
+    })),
+    null,
+    2
+  );
+}
+function registerStrategyTemplateCommands(strategy2) {
+  strategy2.command("list").description("List available strategy templates").action(() => {
+    const templates = STRATEGY_TEMPLATES();
+    console.log();
+    console.log(chalk.bold("Strategy Templates"));
+    console.log(chalk.dim("\u2500".repeat(60)));
+    for (const t of TEMPLATES) {
+      const addr = templates[t.addressKey];
+      const deployed = addr !== ZERO;
+      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();
+    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").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)").action(async (templateKey, opts) => {
+    const vault = opts.vault;
+    if (!isAddress(vault)) {
+      console.error(chalk.red("Invalid vault address"));
+      process.exit(1);
+    }
+    const { def, address: templateAddr } = resolveTemplate(templateKey);
+    const cloneSpinner = ora(`Cloning ${def.name} template...`).start();
+    let clone;
+    let cloneHash;
+    try {
+      const result = await cloneTemplate(templateAddr);
+      clone = result.clone;
+      cloneHash = result.hash;
+      cloneSpinner.succeed(`Cloned: ${chalk.green(clone)}`);
+      console.log(chalk.dim(`  Tx: ${getExplorerUrl(cloneHash)}`));
+    } catch (err) {
+      cloneSpinner.fail("Clone failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const initSpinner = ora("Initializing strategy...").start();
+    try {
+      const { initData } = await buildInitDataForTemplate(templateKey, opts, vault);
+      const account = getAccount();
+      const wallet = getWalletClient();
+      const initHash = await wallet.writeContract({
+        account,
+        chain: getChain(),
+        address: clone,
+        abi: BASE_STRATEGY_ABI,
+        functionName: "initialize",
+        args: [vault, account.address, initData]
+      });
+      await getPublicClient().waitForTransactionReceipt({ hash: initHash });
+      initSpinner.succeed("Initialized");
+    } catch (err) {
+      initSpinner.fail("Initialize failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    console.log();
+    console.log(chalk.bold("Strategy clone ready:"), chalk.green(clone));
+    console.log(chalk.dim("Use this address in your proposal batch calls."));
+    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").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)").action(async (templateKey, opts) => {
+    const vault = opts.vault;
+    if (!isAddress(vault)) {
+      console.error(chalk.red("Invalid vault address"));
+      process.exit(1);
+    }
+    const { def, address: templateAddr } = resolveTemplate(templateKey);
+    const cloneSpinner = ora(`Cloning ${def.name} template...`).start();
+    let clone;
+    try {
+      const result = await cloneTemplate(templateAddr);
+      clone = result.clone;
+      cloneSpinner.succeed(`Cloned: ${chalk.green(clone)}`);
+      console.log(chalk.dim(`  Tx: ${getExplorerUrl(result.hash)}`));
+    } catch (err) {
+      cloneSpinner.fail("Clone failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const initSpinner = ora("Initializing strategy...").start();
+    let asset;
+    let assetAmount;
+    let extraApprovals;
+    try {
+      const built = await buildInitDataForTemplate(templateKey, opts, vault);
+      asset = built.asset;
+      assetAmount = built.assetAmount;
+      extraApprovals = built.extraApprovals;
+      const account2 = getAccount();
+      const wallet = getWalletClient();
+      const initHash = await wallet.writeContract({
+        account: account2,
+        chain: getChain(),
+        address: clone,
+        abi: BASE_STRATEGY_ABI,
+        functionName: "initialize",
+        args: [vault, account2.address, built.initData]
+      });
+      await getPublicClient().waitForTransactionReceipt({ hash: initHash });
+      initSpinner.succeed("Initialized");
+    } catch (err) {
+      initSpinner.fail("Initialize failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const { executeCalls, settleCalls } = buildCallsForTemplate(
+      templateKey,
+      clone,
+      asset,
+      assetAmount,
+      extraApprovals
+    );
+    console.log();
+    console.log(chalk.bold(`Execute calls (${executeCalls.length}):`));
+    console.log(formatBatch(executeCalls));
+    console.log(chalk.bold(`Settle calls (${settleCalls.length}):`));
+    console.log(formatBatch(settleCalls));
+    if (opts.writeCalls) {
+      const dir = resolve(opts.writeCalls);
+      mkdirSync(dir, { recursive: true });
+      const execPath = resolve(dir, "execute.json");
+      const settlePath = resolve(dir, "settle.json");
+      writeFileSync(execPath, serializeCalls(executeCalls));
+      writeFileSync(settlePath, serializeCalls(settleCalls));
+      console.log();
+      console.log(chalk.green(`Execute calls:  ${execPath}`));
+      console.log(chalk.green(`Settle calls:   ${settlePath}`));
+      console.log(chalk.green(`Clone address:  ${clone}`));
+      console.log();
+      console.log(chalk.dim("Submit with:"));
+      console.log(chalk.dim(`  sherwood proposal create \\`));
+      console.log(chalk.dim(`    --vault ${vault} \\`));
+      console.log(chalk.dim(`    --name "..." --description "..." \\`));
+      console.log(chalk.dim(`    --performance-fee 0 --duration 7d \\`));
+      console.log(chalk.dim(`    --execute-calls ${execPath} \\`));
+      console.log(chalk.dim(`    --settle-calls ${settlePath}`));
+      if (templateKey === "venice-inference") {
+        console.log();
+        console.log(chalk.yellow("Reminder: agent must pre-approve sVVV clawback:"));
+        console.log(chalk.yellow(`  sVVV.approve(${clone}, <amount>)`));
+      }
+      console.log();
+      return;
+    }
+    if (!opts.name || !opts.performanceFee || !opts.duration) {
+      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-P6YV4YR7.js");
+    const { pinJSON } = await import("./ipfs-6XVOOHSR.js");
+    const { parseDuration: parseDuration2 } = await import("./governor-P6YV4YR7.js");
+    const performanceFeeBps = BigInt(opts.performanceFee);
+    if (performanceFeeBps < 0n || performanceFeeBps > 10000n) {
+      console.error(chalk.red("--performance-fee must be 0-10000 (basis points)"));
+      process.exit(1);
+    }
+    const strategyDuration = parseDuration2(opts.duration);
+    const account = getAccount();
+    const metaSpinner = ora("Pinning metadata to IPFS...").start();
+    let metadataURI;
+    try {
+      const metadata = {
+        name: opts.name,
+        description: opts.description || "",
+        proposer: account.address,
+        vault,
+        strategyClone: clone,
+        template: def.key,
+        performanceFeeBps: Number(performanceFeeBps),
+        strategyDuration: Number(strategyDuration),
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      metadataURI = await pinJSON(metadata, opts.name);
+      metaSpinner.succeed(`Metadata pinned: ${metadataURI}`);
+    } catch (err) {
+      metaSpinner.fail("IPFS pin failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    const proposeSpinner = ora("Submitting proposal...").start();
+    try {
+      const { hash, proposalId } = await propose2(
+        vault,
+        metadataURI,
+        performanceFeeBps,
+        strategyDuration,
+        executeCalls,
+        settleCalls
+      );
+      proposeSpinner.succeed(`Proposal #${proposalId} created`);
+      console.log(chalk.dim(`  Tx: ${getExplorerUrl(hash)}`));
+      console.log(chalk.dim(`  Clone: ${clone}`));
+    } catch (err) {
+      proposeSpinner.fail("Proposal failed");
+      console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    if (templateKey === "venice-inference") {
+      console.log();
+      console.log(chalk.yellow("Next steps:"));
+      console.log(chalk.yellow(`  1. Pre-approve sVVV clawback: sVVV.approve(${clone}, <amount>)`));
+      console.log(chalk.yellow("  2. After execution: sherwood venice provision"));
+      console.log(chalk.yellow("  3. Use inference: sherwood venice infer --model <id> --prompt '...'"));
+    }
+    console.log();
+  });
 }
 
 // src/lib/factory.ts
@@ -652,74 +964,83 @@ async function getActiveSyndicates2(creator) {
   return data.syndicates;
 }
 
-// src/lib/registry.ts
-function getRegistryAddress() {
-  return "0x0000000000000000000000000000000000000000";
-}
-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) {
+// src/commands/venice.ts
+import { parseUnits as parseUnits4, formatUnits as formatUnits2, isAddress as isAddress2 } from "viem";
+import chalk2 from "chalk";
+import ora2 from "ora";
+
+// src/lib/quote.ts
+import { encodeFunctionData as encodeFunctionData4, decodeFunctionResult, concat as concat2, pad, numberToHex } from "viem";
+async function getQuote(params) {
   const client = getPublicClient();
-  const result = await client.readContract({
-    address: getRegistryAddress(),
-    abi: STRATEGY_REGISTRY_ABI,
-    functionName: "getStrategy",
-    args: [id]
+  const calldata = encodeFunctionData4({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInputSingle",
+    args: [
+      {
+        tokenIn: params.tokenIn,
+        tokenOut: params.tokenOut,
+        amountIn: params.amountIn,
+        fee: params.fee,
+        sqrtPriceLimitX96: 0n
+      }
+    ]
   });
-  return {
-    id,
-    implementation: result.implementation,
-    creator: result.creator,
-    strategyTypeId: result.strategyTypeId,
-    active: result.active,
-    name: result.name,
-    metadataURI: result.metadataURI
-  };
+  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 };
 }
-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));
+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 }));
+    }
   }
-  const strategies = [];
-  for (const id of ids) {
-    const s = await getStrategy(id);
-    strategies.push(s);
+  return concat2(parts);
+}
+async function getMultiHopQuote(params) {
+  const client = getPublicClient();
+  const calldata = encodeFunctionData4({
+    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");
   }
-  return strategies;
+  const [amountOut, , , gasEstimate] = decodeFunctionResult({
+    abi: UNISWAP_QUOTER_V2_ABI,
+    functionName: "quoteExactInput",
+    data
+  });
+  return { amountOut, sqrtPriceX96After: 0n, gasEstimate };
 }
 
-// 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 = [
+import { encodeFunctionData as encodeFunctionData5, parseUnits as parseUnits3 } from "viem";
+var ERC20_ABI2 = [
   {
     name: "approve",
     type: "function",
@@ -783,17 +1104,17 @@ var STAKING_ABI = [
   }
 ];
 function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minVVV, swapPath) {
-  const ZERO = "0x0000000000000000000000000000000000000000";
-  if (VENICE().VVV === ZERO || VENICE().STAKING === ZERO) {
+  const ZERO2 = "0x0000000000000000000000000000000000000000";
+  if (VENICE().VVV === ZERO2 || VENICE().STAKING === ZERO2) {
     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 assetAmount = parseUnits3(config.amount, assetDecimals);
   const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
   const calls = [];
   calls.push({
     target: assetAddress,
-    data: encodeFunctionData3({
-      abi: ERC20_ABI3,
+    data: encodeFunctionData5({
+      abi: ERC20_ABI2,
       functionName: "approve",
       args: [UNISWAP().SWAP_ROUTER, assetAmount]
     }),
@@ -802,7 +1123,7 @@ function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimal
   if (isWeth) {
     calls.push({
       target: UNISWAP().SWAP_ROUTER,
-      data: encodeFunctionData3({
+      data: encodeFunctionData5({
         abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
         functionName: "exactInputSingle",
         args: [
@@ -822,7 +1143,7 @@ function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimal
   } else {
     calls.push({
       target: UNISWAP().SWAP_ROUTER,
-      data: encodeFunctionData3({
+      data: encodeFunctionData5({
         abi: SWAP_ROUTER_EXACT_INPUT_ABI,
         functionName: "exactInput",
         args: [
@@ -839,8 +1160,8 @@ function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimal
   }
   calls.push({
     target: VENICE().VVV,
-    data: encodeFunctionData3({
-      abi: ERC20_ABI3,
+    data: encodeFunctionData5({
+      abi: ERC20_ABI2,
       functionName: "approve",
       args: [VENICE().STAKING, minVVV]
     }),
@@ -850,7 +1171,7 @@ function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimal
   for (const agent of agents) {
     calls.push({
       target: VENICE().STAKING,
-      data: encodeFunctionData3({
+      data: encodeFunctionData5({
         abi: STAKING_ABI,
         functionName: "stake",
         args: [agent, perAgent]
@@ -865,16 +1186,22 @@ function buildFundBatch(config, vaultAddress, agents, assetAddress, assetDecimal
 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`);
+  const tokenRes = await fetch(`${VENICE_API_BASE}/api_keys/generate_web3_key`, {
+    signal: AbortSignal.timeout(15e3)
+  });
   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 token = tokenData?.data?.token;
+  if (!token) {
+    throw new Error("Venice API returned no validation 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" },
+    signal: AbortSignal.timeout(15e3),
     body: JSON.stringify({
       address: account.address,
       signature,
@@ -888,28 +1215,92 @@ async function provisionApiKey() {
     throw new Error(`Failed to generate API key: ${keyRes.status} ${body}`);
   }
   const keyData = await keyRes.json();
-  const apiKey = keyData.data.apiKey;
+  const apiKey = keyData?.data?.apiKey;
+  if (!apiKey) {
+    throw new Error("Venice API returned no API key");
+  }
   setVeniceApiKey(apiKey);
   return apiKey;
 }
-async function checkApiKeyValid() {
+async function checkApiKeyValid() {
+  const apiKey = getVeniceApiKey();
+  if (!apiKey) return false;
+  try {
+    const res = await fetch(`${VENICE_API_BASE}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(15e3)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function chatCompletion(opts) {
+  const apiKey = getVeniceApiKey();
+  if (!apiKey) {
+    throw new Error("No Venice API key configured. Run 'sherwood venice provision' first.");
+  }
+  const body = {
+    model: opts.model,
+    messages: opts.messages
+  };
+  if (opts.temperature !== void 0) body.temperature = opts.temperature;
+  if (opts.maxTokens !== void 0) body.max_tokens = opts.maxTokens;
+  const veniceParams = {};
+  if (opts.enableWebSearch) veniceParams.enable_web_search = "on";
+  if (opts.disableThinking) veniceParams.disable_thinking = true;
+  if (Object.keys(veniceParams).length > 0) body.venice_parameters = veniceParams;
+  const res = await fetch(`${VENICE_API_BASE}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    signal: AbortSignal.timeout(12e4),
+    // inference can be slow
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const errBody = await res.text();
+    throw new Error(`Venice inference failed: ${res.status} ${errBody}`);
+  }
+  const data = await res.json();
+  const choice = data.choices?.[0];
+  if (!choice) {
+    throw new Error("Venice returned no choices");
+  }
+  return {
+    content: choice.message?.content ?? "",
+    model: data.model ?? opts.model,
+    usage: {
+      promptTokens: data.usage?.prompt_tokens ?? 0,
+      completionTokens: data.usage?.completion_tokens ?? 0,
+      totalTokens: data.usage?.total_tokens ?? 0
+    }
+  };
+}
+async function listModels() {
   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;
+  if (!apiKey) {
+    throw new Error("No Venice API key configured. Run 'sherwood venice provision' first.");
+  }
+  const res = await fetch(`${VENICE_API_BASE}/models`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to list Venice models: ${res.status} ${res.statusText}`);
   }
+  const data = await res.json();
+  return (data.data ?? []).map((m) => m.id);
 }
 
 // src/commands/venice.ts
-var VALID_FEES2 = [500, 3e3, 1e4];
+import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
+var VALID_FEES = [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) => {
+  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).option("--write-calls <path>", "Write batch calls to JSON file for proposal create (skips execution)").action(async (opts) => {
     const vaultAddress = opts.vault;
     if (!isAddress2(vaultAddress)) {
       console.error(chalk2.red(`Invalid vault address: ${opts.vault}`));
@@ -917,8 +1308,8 @@ function registerVeniceCommands(program2) {
     }
     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(", ")}`));
+    if (!VALID_FEES.includes(fee1) || !VALID_FEES.includes(fee2)) {
+      console.error(chalk2.red(`Invalid fee tier. Valid: ${VALID_FEES.join(", ")}`));
       process.exit(1);
     }
     const slippageBps = Number(opts.slippage);
@@ -951,7 +1342,7 @@ function registerVeniceCommands(program2) {
       console.error(chalk2.red("No agents registered in vault. Register agents first."));
       process.exit(1);
     }
-    const requestedAmount = parseUnits5(opts.amount, assetDecimals);
+    const requestedAmount = parseUnits4(opts.amount, assetDecimals);
     const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
     const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
     console.log();
@@ -959,16 +1350,16 @@ function registerVeniceCommands(program2) {
     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(`  Vault balance: ${formatUnits2(assetBalance, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Deposited:     ${formatUnits2(totalDeposited, assetDecimals)} ${assetSymbol}`);
+    console.log(`  Profit:        ${formatUnits2(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(`  Warning: amount (${opts.amount}) exceeds available profit (${formatUnits2(profit, assetDecimals)})`));
       console.warn(chalk2.yellow("  This will use deposited capital, not just profits."));
       console.log();
     }
@@ -998,7 +1389,7 @@ function registerVeniceCommands(program2) {
       }
       minOut = applySlippage(amountOut, slippageBps);
       quoteSpinner.succeed(
-        `Quote: ${formatUnits3(amountOut, 18)} VVV (min: ${formatUnits3(minOut, 18)}, per agent: ${formatUnits3(minOut / BigInt(agents.length), 18)})`
+        `Quote: ${formatUnits2(amountOut, 18)} VVV (min: ${formatUnits2(minOut, 18)}, per agent: ${formatUnits2(minOut / BigInt(agents.length), 18)})`
       );
     } catch (err) {
       quoteSpinner.fail("Failed to fetch quote");
@@ -1016,9 +1407,24 @@ function registerVeniceCommands(program2) {
     console.log(chalk2.bold(`Batch calls (${calls.length}):`));
     console.log(formatBatch(calls));
     console.log();
+    if (opts.writeCalls) {
+      const callsJson = calls.map((c) => ({
+        target: c.target,
+        data: c.data,
+        value: c.value.toString()
+      }));
+      writeFileSync2(opts.writeCalls, JSON.stringify(callsJson, null, 2));
+      const settlePath = `${opts.writeCalls}.settle.json`;
+      writeFileSync2(settlePath, "[]");
+      console.log(chalk2.green(`Execute calls written to: ${opts.writeCalls}`));
+      console.log(chalk2.green(`Settlement calls written to: ${settlePath}`));
+      console.log();
+      console.log(chalk2.dim("Use with: sherwood proposal create --execute-calls <path> --settle-calls <path>"));
+      return;
+    }
     if (!opts.execute) {
       console.log();
-      console.log(chalk2.yellow("Dry run complete. Add --execute to submit on-chain."));
+      console.log(chalk2.yellow("Dry run complete. Add --execute to submit on-chain, or --write-calls <path> to export for proposals."));
       return;
     }
     const execSpinner = ora2("Executing batch via vault...").start();
@@ -1049,7 +1455,7 @@ function registerVeniceCommands(program2) {
         console.log(chalk2.yellow("  Run 'sherwood venice fund' first to distribute sVVV to agents."));
         process.exit(1);
       }
-      checkSpinner.succeed(`sVVV balance: ${formatUnits3(sVvvBalance, 18)}`);
+      checkSpinner.succeed(`sVVV balance: ${formatUnits2(sVvvBalance, 18)}`);
     } catch (err) {
       checkSpinner.fail("Failed to check sVVV balance");
       console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
@@ -1126,17 +1532,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:  ${formatUnits3(profit, assetDecimals)} ${assetSymbol}`);
-      console.log(`    VVV (unstaked):    ${formatUnits3(vaultVvvBalance, 18)}`);
+      console.log(`    Profit available:  ${formatUnits2(profit, assetDecimals)} ${assetSymbol}`);
+      console.log(`    VVV (unstaked):    ${formatUnits2(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(`    ${label}: ${formatUnits2(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(`    sVVV:              ${formatUnits2(mySvvv, 18)}`);
+      console.log(`    Pending rewards:   ${formatUnits2(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")}`);
@@ -1147,16 +1553,79 @@ function registerVeniceCommands(program2) {
       process.exit(1);
     }
   });
+  venice.command("models").description("List available Venice inference models").action(async () => {
+    const spinner = ora2("Fetching Venice models...").start();
+    try {
+      const models = await listModels();
+      spinner.succeed(`${models.length} models available`);
+      console.log();
+      for (const model of models) {
+        console.log(`  ${model}`);
+      }
+      console.log();
+    } catch (err) {
+      spinner.fail("Failed to list models");
+      console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+  });
+  venice.command("infer").description("Run private inference via Venice chat completions").requiredOption("--prompt <text>", "User prompt").requiredOption("--model <id>", "Venice model ID (use 'venice models' to list)").option("--system <text>", "System prompt").option("--data <path>", "Path to data file \u2014 contents prepended to prompt as context").option("--web-search", "Enable Venice web search", false).option("--no-thinking", "Disable chain-of-thought reasoning").option("--temperature <n>", "Sampling temperature (0-2)").option("--max-tokens <n>", "Maximum completion tokens").option("--json", "Output raw JSON response", false).action(async (opts) => {
+    const messages = [];
+    if (opts.system) {
+      messages.push({ role: "system", content: opts.system });
+    }
+    let userContent = opts.prompt;
+    if (opts.data) {
+      try {
+        const data = readFileSync(opts.data, "utf-8");
+        userContent = `Context data:
+\`\`\`
+${data}
+\`\`\`
+
+${opts.prompt}`;
+      } catch (err) {
+        console.error(chalk2.red(`Failed to read data file: ${opts.data}`));
+        console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+    }
+    messages.push({ role: "user", content: userContent });
+    const spinner = ora2(`Running inference (${opts.model})...`).start();
+    try {
+      const result = await chatCompletion({
+        model: opts.model,
+        messages,
+        temperature: opts.temperature !== void 0 ? Number(opts.temperature) : void 0,
+        maxTokens: opts.maxTokens !== void 0 ? Number(opts.maxTokens) : void 0,
+        enableWebSearch: opts.webSearch,
+        disableThinking: opts.thinking === false
+      });
+      spinner.succeed("Inference complete");
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log();
+        console.log(result.content);
+        console.log();
+        console.log(chalk2.dim(`Model: ${result.model} | Tokens: ${result.usage.promptTokens} in, ${result.usage.completionTokens} out, ${result.usage.totalTokens} total`));
+      }
+    } catch (err) {
+      spinner.fail("Inference failed");
+      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 { parseUnits as parseUnits6, formatUnits as formatUnits3, 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 = [
+import { encodeFunctionData as encodeFunctionData6, parseUnits as parseUnits5 } from "viem";
+var ERC20_ABI3 = [
   {
     name: "approve",
     type: "function",
@@ -1218,15 +1687,15 @@ var SWAP_ROUTER_EXACT_INPUT_ABI2 = [
   }
 ];
 function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDecimals, minUsdc, swapPath) {
-  const assetAmount = parseUnits6(config.amount, assetDecimals);
+  const assetAmount = parseUnits5(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,
+      data: encodeFunctionData6({
+        abi: ERC20_ABI3,
         functionName: "approve",
         args: [UNISWAP().SWAP_ROUTER, assetAmount]
       }),
@@ -1235,7 +1704,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     if (isWeth) {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData4({
+        data: encodeFunctionData6({
           abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI2,
           functionName: "exactInputSingle",
           args: [
@@ -1255,7 +1724,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     } else {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData4({
+        data: encodeFunctionData6({
           abi: SWAP_ROUTER_EXACT_INPUT_ABI2,
           functionName: "exactInput",
           args: [
@@ -1275,8 +1744,8 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
   for (const agent of agents) {
     calls.push({
       target: TOKENS().USDC,
-      data: encodeFunctionData4({
-        abi: ERC20_ABI4,
+      data: encodeFunctionData6({
+        abi: ERC20_ABI3,
         functionName: "transfer",
         args: [agent, perAgent]
       }),
@@ -1287,7 +1756,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
 }
 
 // src/commands/allowance.ts
-var VALID_FEES3 = [500, 3e3, 1e4];
+var VALID_FEES2 = [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) => {
@@ -1297,8 +1766,8 @@ function registerAllowanceCommands(program2) {
       process.exit(1);
     }
     const fee = Number(opts.fee);
-    if (!VALID_FEES3.includes(fee)) {
-      console.error(chalk3.red(`Invalid fee tier. Valid: ${VALID_FEES3.join(", ")}`));
+    if (!VALID_FEES2.includes(fee)) {
+      console.error(chalk3.red(`Invalid fee tier. Valid: ${VALID_FEES2.join(", ")}`));
       process.exit(1);
     }
     const slippageBps = Number(opts.slippage);
@@ -1331,7 +1800,7 @@ function registerAllowanceCommands(program2) {
       console.error(chalk3.red("No agents registered in vault. Register agents first."));
       process.exit(1);
     }
-    const requestedAmount = parseUnits7(opts.amount, assetDecimals);
+    const requestedAmount = parseUnits6(opts.amount, assetDecimals);
     const profit = assetBalance > totalDeposited ? assetBalance - totalDeposited : 0n;
     const isUsdc = assetAddress.toLowerCase() === TOKENS().USDC.toLowerCase();
     const isWeth = assetAddress.toLowerCase() === TOKENS().WETH.toLowerCase();
@@ -1340,9 +1809,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: ${formatUnits4(assetBalance, assetDecimals)} ${assetSymbol}`);
-    console.log(`  Deposited:     ${formatUnits4(totalDeposited, assetDecimals)} ${assetSymbol}`);
-    console.log(`  Profit:        ${formatUnits4(profit, assetDecimals)} ${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} (USDC will be split equally)`);
     if (!isUsdc) {
       console.log(`  Routing:       ${isWeth ? `WETH \u2192 USDC (fee ${fee})` : `${assetSymbol} \u2192 WETH \u2192 USDC (fee ${fee})`}`);
@@ -1351,7 +1820,7 @@ function registerAllowanceCommands(program2) {
     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(`  Warning: amount (${opts.amount}) exceeds available profit (${formatUnits3(profit, assetDecimals)})`));
       console.warn(chalk3.yellow("  This will use deposited capital, not just profits."));
       console.log();
     }
@@ -1385,7 +1854,7 @@ function registerAllowanceCommands(program2) {
         }
         minUsdc = applySlippage(amountOut, slippageBps);
         quoteSpinner.succeed(
-          `Quote: ${formatUnits4(amountOut, 6)} USDC (min: ${formatUnits4(minUsdc, 6)}, per agent: ${formatUnits4(minUsdc / BigInt(agents.length), 6)})`
+          `Quote: ${formatUnits3(amountOut, 6)} USDC (min: ${formatUnits3(minUsdc, 6)}, per agent: ${formatUnits3(minUsdc / BigInt(agents.length), 6)})`
         );
       } catch (err) {
         quoteSpinner.fail("Failed to fetch quote");
@@ -1395,7 +1864,7 @@ function registerAllowanceCommands(program2) {
     }
     const perAgent = minUsdc / BigInt(agents.length);
     if (isUsdc) {
-      console.log(chalk3.dim(`  Per agent: ${formatUnits4(perAgent, 6)} USDC`));
+      console.log(chalk3.dim(`  Per agent: ${formatUnits3(perAgent, 6)} USDC`));
       console.log();
     }
     const config = {
@@ -1462,14 +1931,14 @@ function registerAllowanceCommands(program2) {
       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(`    Balance:         ${formatUnits3(assetBalance, assetDecimals)} ${assetSymbol}`);
+      console.log(`    Deposited:       ${formatUnits3(totalDeposited, assetDecimals)} ${assetSymbol}`);
+      console.log(`    Profit:          ${formatUnits3(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(`    ${label}: ${formatUnits3(balance, 6)} USDC`);
       }
       console.log();
     } catch (err) {
@@ -1641,348 +2110,7 @@ function registerIdentityCommands(program2) {
 import { isAddress as isAddress4 } from "viem";
 import chalk5 from "chalk";
 import ora5 from "ora";
-import { readFileSync } from "fs";
-
-// src/lib/governor.ts
-var PROPOSAL_STATES = [
-  "Draft",
-  "Pending",
-  "Approved",
-  "Rejected",
-  "Expired",
-  "Executed",
-  "Settled",
-  "Cancelled"
-];
-var PROPOSAL_STATE = {
-  Draft: 0,
-  Pending: 1,
-  Approved: 2,
-  Rejected: 3,
-  Expired: 4,
-  Executed: 5,
-  Settled: 6,
-  Cancelled: 7
-};
-var VOTE_TYPE = {
-  For: 0,
-  Against: 1,
-  Abstain: 2
-};
-function parseDuration(input2) {
-  const match = input2.match(/^(\d+)(d|h|m|s)?$/);
-  if (!match) throw new Error(`Invalid duration: ${input2}`);
-  const value = BigInt(match[1]);
-  switch (match[2]) {
-    case "d":
-      return value * 86400n;
-    case "h":
-      return value * 3600n;
-    case "m":
-      return value * 60n;
-    case "s":
-    case void 0:
-      return value;
-    default:
-      throw new Error(`Unknown duration unit: ${match[2]}`);
-  }
-}
-function getGovernorAddress() {
-  return SHERWOOD().GOVERNOR;
-}
-async function getGovernorParams() {
-  const client = getPublicClient();
-  const result = await client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getGovernorParams"
-  });
-  return result;
-}
-async function getProposal(id) {
-  const client = getPublicClient();
-  const result = await client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getProposal",
-    args: [id]
-  });
-  return result;
-}
-async function getProposalState(id) {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getProposalState",
-    args: [id]
-  });
-}
-async function proposalCount() {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "proposalCount"
-  });
-}
-async function getVoteWeight(proposalId, voter) {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getVoteWeight",
-    args: [proposalId, voter]
-  });
-}
-async function hasVoted(proposalId, voter) {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "hasVoted",
-    args: [proposalId, voter]
-  });
-}
-async function getExecuteCalls(proposalId) {
-  const client = getPublicClient();
-  const result = await client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getExecuteCalls",
-    args: [proposalId]
-  });
-  return result.map((c) => ({ target: c.target, data: c.data, value: c.value }));
-}
-async function getSettlementCalls(proposalId) {
-  const client = getPublicClient();
-  const result = await client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getSettlementCalls",
-    args: [proposalId]
-  });
-  return result.map((c) => ({ target: c.target, data: c.data, value: c.value }));
-}
-async function getRegisteredVaults() {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getRegisteredVaults"
-  });
-}
-async function getCapitalSnapshot(proposalId) {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "getCapitalSnapshot",
-    args: [proposalId]
-  });
-}
-async function propose(vault, metadataURI, performanceFeeBps, strategyDuration, executeCalls, settlementCalls, coProposers = []) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "propose",
-    args: [vault, metadataURI, performanceFeeBps, strategyDuration, executeCalls, settlementCalls, coProposers]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  let proposalId;
-  try {
-    proposalId = await proposalCount();
-  } catch {
-    proposalId = 0n;
-  }
-  return { hash: receipt.transactionHash, proposalId };
-}
-async function vote(proposalId, support) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "vote",
-    args: [proposalId, support]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function executeProposal(proposalId) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "executeProposal",
-    args: [proposalId]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function settleProposal(proposalId) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "settleProposal",
-    args: [proposalId]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function emergencySettle(proposalId, calls) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "emergencySettle",
-    args: [proposalId, calls]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function cancelProposal(proposalId) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "cancelProposal",
-    args: [proposalId]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function emergencyCancel(proposalId) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "emergencyCancel",
-    args: [proposalId]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setVotingPeriod(seconds) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setVotingPeriod",
-    args: [seconds]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setExecutionWindow(seconds) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setExecutionWindow",
-    args: [seconds]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setVetoThresholdBps(bps) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setVetoThresholdBps",
-    args: [bps]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setMaxPerformanceFeeBps(bps) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setMaxPerformanceFeeBps",
-    args: [bps]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setMaxStrategyDuration(seconds) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setMaxStrategyDuration",
-    args: [seconds]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setCooldownPeriod(seconds) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setCooldownPeriod",
-    args: [seconds]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
-async function setProtocolFeeBps(bps) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getGovernorAddress(),
-    abi: SYNDICATE_GOVERNOR_ABI,
-    functionName: "setProtocolFeeBps",
-    args: [bps]
-  });
-  const receipt = await client.waitForTransactionReceipt({ hash });
-  return receipt.transactionHash;
-}
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/lib/format.ts
 function formatDurationShort(seconds) {
@@ -2026,7 +2154,7 @@ function formatTimestamp(ts) {
   return new Date(Number(ts) * 1e3).toLocaleString();
 }
 function parseCallsFile(path) {
-  const raw = readFileSync(path, "utf-8");
+  const raw = readFileSync2(path, "utf-8");
   const parsed = JSON.parse(raw);
   return parsed.map((c) => ({
     target: c.target,
@@ -2512,7 +2640,7 @@ try {
 var require2 = createRequire(import.meta.url);
 var { version: CLI_VERSION } = require2("../package.json");
 async function loadXmtp() {
-  return import("./xmtp-BSTLCZWG.js");
+  return import("./xmtp-DX73F6I4.js");
 }
 async function loadCron() {
   return import("./cron-SKYKVZ6K.js");
@@ -3189,7 +3317,7 @@ 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 amount = parseUnits7(opts.amount, decimals);
   const spinner = ora7(`Depositing ${opts.amount}...`).start();
   try {
     const hash = await deposit(amount);
@@ -3241,81 +3369,8 @@ vaultCmd.command("balance").description("Show LP share balance and asset value")
     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 = ora7("Loading strategies...").start();
-  try {
-    const strategies = await listStrategies(
-      opts.type ? BigInt(opts.type) : void 0
-    );
-    spinner.stop();
-    if (strategies.length === 0) {
-      console.log(chalk7.dim("No strategies registered."));
-      return;
-    }
-    console.log();
-    console.log(chalk7.bold(`Strategies (${strategies.length})`));
-    console.log(chalk7.dim("\u2500".repeat(70)));
-    for (const s of strategies) {
-      const status = s.active ? chalk7.green("active") : chalk7.red("inactive");
-      console.log(`  #${s.id}  ${chalk7.bold(s.name)}  [type: ${s.strategyTypeId}]  ${status}`);
-      console.log(`    Creator:        ${s.creator}`);
-      console.log(`    Implementation: ${s.implementation}`);
-      if (s.metadataURI) {
-        console.log(`    Metadata:       ${chalk7.dim(s.metadataURI)}`);
-      }
-      console.log();
-    }
-  } catch (err) {
-    spinner.fail("Failed to load strategies");
-    console.error(chalk7.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 = ora7("Loading strategy...").start();
-  try {
-    const s = await getStrategy(BigInt(idStr));
-    spinner.stop();
-    console.log();
-    console.log(chalk7.bold(`Strategy #${s.id}`));
-    console.log(chalk7.dim("\u2500".repeat(40)));
-    console.log(`  Name:           ${s.name}`);
-    console.log(`  Type:           ${s.strategyTypeId}`);
-    console.log(`  Active:         ${s.active ? chalk7.green("yes") : chalk7.red("no")}`);
-    console.log(`  Creator:        ${s.creator}`);
-    console.log(`  Implementation: ${s.implementation}`);
-    if (s.metadataURI) {
-      console.log(`  Metadata:       ${chalk7.dim(s.metadataURI)}`);
-    }
-    console.log();
-  } catch (err) {
-    spinner.fail("Failed to load strategy");
-    console.error(chalk7.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 = ora7("Registering strategy...").start();
-  try {
-    const hash = await registerStrategy(
-      opts.implementation,
-      BigInt(opts.type),
-      opts.name,
-      opts.metadata
-    );
-    spinner.succeed(`Strategy registered: ${hash}`);
-    console.log(chalk7.dim(`  ${getExplorerUrl(hash)}`));
-  } catch (err) {
-    spinner.fail("Registration failed");
-    console.error(chalk7.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);
-});
+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-IUHVRHR3.js");
   const providers = [new MoonwellProvider(), new UniswapProvider(), new MessariProvider(), new NansenProvider()];
@@ -3328,7 +3383,7 @@ ${info.name} (${info.type})`);
   }
 });
 try {
-  const { registerChatCommands } = await import("./chat-A2ORZVU3.js");
+  const { registerChatCommands } = await import("./chat-G5TRNY5S.js");
   registerChatCommands(program);
 } catch {
   program.command("chat <name> [action] [actionArgs...]").description("Syndicate chat (XMTP) \u2014 requires @xmtp/cli").action(() => {
@@ -3338,14 +3393,14 @@ try {
     process.exit(1);
   });
 }
-var { registerSessionCommands } = await import("./session-3YRZI426.js");
+var { registerSessionCommands } = await import("./session-VEF5BZIX.js");
 registerSessionCommands(program);
 registerVeniceCommands(program);
 registerAllowanceCommands(program);
 registerIdentityCommands(program);
 registerProposalCommands(program);
 registerGovernorCommands(program);
-var { registerResearchCommands } = await import("./research-63D7YID3.js");
+var { registerResearchCommands } = await import("./research-FNH3VT57.js");
 registerResearchCommands(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.)").action((opts) => {