@sherwoodagent/cli 0.59.18 → 0.65.0

package/dist/index.js

@@ -171,7 +171,7 @@ import {
 import { config as loadDotenv } from "dotenv";
 import { createRequire } from "module";
 import { Command, Option } from "commander";
-import { parseUnits as parseUnits7, formatUnits as formatUnits5, isAddress as isAddress6 } from "viem";
+import { parseUnits as parseUnits7, formatUnits as formatUnits6, isAddress as isAddress7 } from "viem";
 import chalk15 from "chalk";
 import ora8 from "ora";
 import { input, confirm, select } from "@inquirer/prompts";
@@ -211,7 +211,7 @@ var MoonwellProvider = class {
 };
 
 // src/commands/strategy-template.ts
-import { parseUnits, formatUnits, isAddress, erc20Abi, encodeAbiParameters as encodeAbiParameters9, decodeAbiParameters } from "viem";
+import { parseUnits, formatUnits as formatUnits2, isAddress as isAddress2, erc20Abi, encodeAbiParameters as encodeAbiParameters11, decodeAbiParameters } from "viem";
 import chalk from "chalk";
 import ora from "ora";
 import { writeFileSync, mkdirSync } from "fs";
@@ -281,10 +281,1700 @@ function formatBatch(calls) {
   }).join("\n");
 }
 
+// src/lib/calldata.ts
+var _calldataOnly = false;
+function setCalldataOnly(value) {
+  _calldataOnly = value;
+}
+function isCalldataOnly() {
+  return _calldataOnly;
+}
+function emitCalldata(action) {
+  process.stdout.write(JSON.stringify(action, null, 2) + "\n");
+}
+
+// ../sdk/dist/types.js
+var CHAIN_IDS = {
+  BASE: 8453,
+  HYPEREVM: 999,
+  ROBINHOOD_L2: 46630
+};
+var SUPPORTED_CHAIN_IDS = [
+  CHAIN_IDS.BASE,
+  CHAIN_IDS.HYPEREVM,
+  CHAIN_IDS.ROBINHOOD_L2
+];
+
+// ../sdk/dist/errors.js
+var SdkError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "SdkError";
+  }
+};
+var usage = (message) => new SdkError("USAGE", message);
+var unsupported = (message) => new SdkError("UNSUPPORTED", message);
+var unavailable = (message, cause) => new SdkError("UNAVAILABLE", message, cause);
+
+// ../sdk/dist/abis.js
+var SYNDICATE_VAULT_ABI2 = [
+  // ERC-4626
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }]
+  },
+  {
+    name: "redeem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "receiver", type: "address" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "requestRedeem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "requestId", type: "uint256" }]
+  },
+  // Reads
+  {
+    name: "asset",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "totalAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "owner",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "governor",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "redemptionsLocked",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "paused",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "openDeposits",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "getAgentCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isApprovedDepositor",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Owner-side write surface
+  {
+    name: "approveDepositor",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "removeDepositor",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "registerAgent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentAddress", type: "address" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var SYNDICATE_GOVERNOR_ABI = [
+  // Propose (multi-arg). Order MUST match contract: vault, strategy,
+  // metadataURI, performanceFeeBps, strategyDuration, executeCalls,
+  // settlementCalls, coProposers.
+  {
+    name: "propose",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "strategy", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "performanceFeeBps", type: "uint256" },
+      { name: "strategyDuration", type: "uint256" },
+      {
+        name: "executeCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      {
+        name: "settlementCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      {
+        name: "coProposers",
+        type: "tuple[]",
+        components: [
+          { name: "agent", type: "address" },
+          { name: "splitBps", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "proposalId", type: "uint256" }]
+  },
+  // Lifecycle writes
+  {
+    name: "vote",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "proposalId", type: "uint256" },
+      { name: "support", type: "uint8" }
+    ],
+    outputs: []
+  },
+  {
+    name: "executeProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "settleProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "cancelProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "vetoProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  // Emergency settlement (GovernorEmergency, V1.5). `unstick` is the
+  // owner-instant pre-committed-calls path; `emergencySettleWithCalls` commits
+  // a new calldata hash and opens a guardian-reviewed window. The removed
+  // `emergencySettle` is intentionally absent — it is not on the deployed impl.
+  {
+    name: "unstick",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "emergencySettleWithCalls",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "proposalId", type: "uint256" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  // Parameter setters (GovernorParameters, V1.5 — owner-instant, no timelock).
+  { name: "setVotingPeriod", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setExecutionWindow", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setVetoThresholdBps", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setMaxPerformanceFeeBps", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setMaxStrategyDuration", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setCooldownPeriod", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setProtocolFeeBps", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  // Reads
+  {
+    name: "getProposal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "proposer", type: "address" },
+          { name: "vault", type: "address" },
+          { name: "strategy", type: "address" },
+          { name: "metadataURI", type: "string" },
+          { name: "performanceFeeBps", type: "uint256" },
+          { name: "strategyDuration", type: "uint256" },
+          { name: "votesFor", type: "uint256" },
+          { name: "votesAgainst", type: "uint256" },
+          { name: "votesAbstain", type: "uint256" },
+          { name: "snapshotTimestamp", type: "uint256" },
+          { name: "voteEnd", type: "uint256" },
+          { name: "reviewEnd", type: "uint256" },
+          { name: "executeBy", type: "uint256" },
+          { name: "executedAt", type: "uint256" },
+          { name: "state", type: "uint8" },
+          { name: "vetoThresholdBps", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getProposalState",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "getActiveProposal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "vault", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "proposalCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getGovernorParams",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "votingPeriod", type: "uint256" },
+          { name: "executionWindow", type: "uint256" },
+          { name: "vetoThresholdBps", type: "uint256" },
+          { name: "maxPerformanceFeeBps", type: "uint256" },
+          { name: "cooldownPeriod", type: "uint256" },
+          { name: "collaborationWindow", type: "uint256" },
+          { name: "maxCoProposers", type: "uint256" },
+          { name: "minStrategyDuration", type: "uint256" },
+          { name: "maxStrategyDuration", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "protocolFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "guardianFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "protocolFeeRecipient",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+var SYNDICATE_FACTORY_ABI = [
+  {
+    name: "createSyndicate",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "creatorAgentId", type: "uint256" },
+      {
+        name: "config",
+        type: "tuple",
+        components: [
+          { name: "metadataURI", type: "string" },
+          { name: "asset", type: "address" },
+          { name: "name", type: "string" },
+          { name: "symbol", type: "string" },
+          { name: "openDeposits", type: "bool" },
+          { name: "subdomain", type: "string" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "syndicateId", type: "uint256" },
+      { name: "vault", type: "address" }
+    ]
+  },
+  {
+    name: "syndicateCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "subdomainToSyndicate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "subdomain", type: "string" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "vaultToSyndicate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "vault", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "syndicates",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "uint256" }],
+    outputs: [
+      { name: "id", type: "uint256" },
+      { name: "vault", type: "address" },
+      { name: "creator", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "createdAt", type: "uint256" },
+      { name: "active", type: "bool" },
+      { name: "subdomain", type: "string" }
+    ]
+  },
+  {
+    name: "getAllActiveSyndicates",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "vault", type: "address" },
+          { name: "creator", type: "address" },
+          { name: "metadataURI", type: "string" },
+          { name: "createdAt", type: "uint256" },
+          { name: "active", type: "bool" },
+          { name: "subdomain", type: "string" }
+        ]
+      }
+    ]
+  }
+];
+var GUARDIAN_REGISTRY_ABI = [
+  // Guardian stake
+  {
+    name: "stakeAsGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "requestUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "cancelUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "claimUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  // Delegation
+  {
+    name: "delegateStake",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "delegate", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "requestUnstakeDelegation",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "delegate", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "cancelUnstakeDelegation",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "delegate", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "claimUnstakeDelegation",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "delegate", type: "address" }],
+    outputs: []
+  },
+  // Commission
+  {
+    name: "setCommission",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "bps", type: "uint16" }],
+    outputs: []
+  },
+  // Claims
+  {
+    name: "claimProposalReward",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "claimDelegatorProposalReward",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "delegate", type: "address" },
+      { name: "proposalId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  // Reads
+  {
+    name: "guardianStake",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isActiveGuardian",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var ERC20_ABI2 = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+var IDENTITY_REGISTRY_ABI = [
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }]
+  }
+];
+var EAS_ABI = [
+  {
+    name: "attest",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "request",
+        type: "tuple",
+        components: [
+          { name: "schema", type: "bytes32" },
+          {
+            name: "data",
+            type: "tuple",
+            components: [
+              { name: "recipient", type: "address" },
+              { name: "expirationTime", type: "uint64" },
+              { name: "revocable", type: "bool" },
+              { name: "refUID", type: "bytes32" },
+              { name: "data", type: "bytes" },
+              { name: "value", type: "uint256" }
+            ]
+          }
+        ]
+      }
+    ],
+    outputs: [{ name: "", type: "bytes32" }]
+  }
+];
+var STRATEGY_FACTORY_ABI = [
+  {
+    name: "cloneAndInit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "template", type: "address" },
+      { name: "vault", type: "address" },
+      { name: "proposer", type: "address" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: [{ name: "clone", type: "address" }]
+  },
+  {
+    name: "cloneAndInitDeterministic",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "template", type: "address" },
+      { name: "vault", type: "address" },
+      { name: "proposer", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "salt", type: "bytes32" }
+    ],
+    outputs: [{ name: "clone", type: "address" }]
+  },
+  {
+    name: "syndicateFactory",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+
+// ../sdk/dist/addresses.js
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var BASE_EAS = {
+  chainId: CHAIN_IDS.BASE,
+  address: "0x4200000000000000000000000000000000000021",
+  schemas: {
+    joinRequest: "0x1e7ce17b16233977ba913b156033e98f52029f4bee273a4abefe6c15ce11d5ef",
+    agentApproved: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607"
+  }
+};
+var NO_EAS = {
+  chainId: CHAIN_IDS.BASE,
+  address: ZERO_ADDRESS,
+  schemas: { joinRequest: ZERO_BYTES32, agentApproved: ZERO_BYTES32 }
+};
+var BASE = {
+  chainId: CHAIN_IDS.BASE,
+  name: "Base",
+  slug: "base",
+  sherwood: {
+    factory: "0xAC74EC56858d7F1f7618c8e77F65Fc26aDf33c82",
+    governor: "0x9Fd3c87B34F254e3c5652A0394B9780c2F05d367",
+    guardianRegistry: "0x49E4163b5e4b23F8f3d469Cf6fa197FB6b06A26E",
+    vaultImpl: "0xfce4bcE08E9C047E4736f75C2B8557e2754Ce36A",
+    batchExecutorLib: "0xbC79FbD5036C1Cc4A9d10BDf8628BF09a558496E",
+    // Not yet deployed on Base — fill in `STRATEGY_FACTORY` from
+    // contracts/chains/8453.json when it lands (issue #387).
+    strategyFactory: ZERO_ADDRESS
+  },
+  identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  eas: BASE_EAS,
+  tokens: {
+    usdc: {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      symbol: "USDC",
+      decimals: 6
+    },
+    weth: {
+      address: "0x4200000000000000000000000000000000000006",
+      symbol: "WETH",
+      decimals: 18
+    }
+  },
+  explorer: "https://basescan.org",
+  rpcs: ["https://mainnet.base.org"]
+};
+var HYPEREVM = {
+  chainId: CHAIN_IDS.HYPEREVM,
+  name: "HyperEVM",
+  slug: "hyperevm",
+  sherwood: {
+    factory: "0xd05Ae0E8bcf13075C29817c805d6Cc14F214393a",
+    governor: "0x67AD3D5F3d127Ef923Fd6f67b178633c408D3fd3",
+    guardianRegistry: "0x8b5710EB4e2fA639F364Dcc3F3B30c8f12F460b9",
+    vaultImpl: "0x2cbBe36Cf907A2BB410bacB0e4Fd632C7b012846",
+    batchExecutorLib: "0x2c454bEF1b09c8a306a7058b8B510bF0DfF7179D",
+    strategyFactory: ZERO_ADDRESS
+  },
+  // ERC-8004 identity is minted on Base; HyperEVM syndicates reference the
+  // Base-minted token id. Coordination attestations are pinned to Base EAS.
+  identityRegistry: ZERO_ADDRESS,
+  eas: BASE_EAS,
+  tokens: {
+    usdc: {
+      address: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      symbol: "USDC",
+      decimals: 6
+    }
+  },
+  explorer: "https://hyperliquid.cloud.blockscout.com",
+  rpcs: ["https://rpc.hyperliquid.xyz/evm"]
+};
+var ROBINHOOD_L2 = {
+  chainId: CHAIN_IDS.ROBINHOOD_L2,
+  name: "Robinhood L2 Testnet",
+  slug: "robinhood-l2",
+  sherwood: {
+    factory: "0x6d026e2f5Ff0C34A01690EC46Cb601B8fF391985",
+    governor: "0xd882056ba6b0aEd8908c541884B327121E2f2C9C",
+    // Robinhood L2 doesn't have a guardian registry yet; use zero so callers
+    // get a clear UNSUPPORTED rather than a confusing revert downstream.
+    guardianRegistry: "0x0000000000000000000000000000000000000000",
+    vaultImpl: "0xF4720523325f9A4546F43391484DCd1D28dFc266",
+    batchExecutorLib: "0x1493f5a7E5d82e1e56c34e2Ba300f56F97186017",
+    strategyFactory: ZERO_ADDRESS
+  },
+  // No ERC-8004 registry and no EAS path on Robinhood L2.
+  identityRegistry: ZERO_ADDRESS,
+  eas: NO_EAS,
+  tokens: {},
+  explorer: "https://explorer-robinhood-l2.t.conduit.xyz",
+  rpcs: ["https://rpc-robinhood-l2.t.conduit.xyz"]
+};
+var REGISTRY = {
+  [CHAIN_IDS.BASE]: BASE,
+  [CHAIN_IDS.HYPEREVM]: HYPEREVM,
+  [CHAIN_IDS.ROBINHOOD_L2]: ROBINHOOD_L2
+};
+function getDeployment(chainId) {
+  const entry = REGISTRY[chainId];
+  if (!entry)
+    throw unsupported(`No Sherwood deployment for chain ${chainId}`);
+  return entry;
+}
+
+// ../sdk/dist/encoders/vault.js
+import { encodeFunctionData, getAddress, maxUint256 } from "viem";
+var WETH_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [],
+    outputs: []
+  }
+];
+var ZERO_VALUE = "0x0";
+function toHexValue(value) {
+  return `0x${value.toString(16)}`;
+}
+function encodeApproveTx(token, spender, amount, chainId) {
+  return {
+    to: token,
+    data: encodeFunctionData({
+      abi: ERC20_ABI2,
+      functionName: "approve",
+      args: [spender, amount]
+    }),
+    value: ZERO_VALUE,
+    chainId
+  };
+}
+function encodeDepositTx(vault, assets, receiver, chainId) {
+  return {
+    to: vault,
+    data: encodeFunctionData({
+      abi: SYNDICATE_VAULT_ABI2,
+      functionName: "deposit",
+      args: [assets, receiver]
+    }),
+    value: ZERO_VALUE,
+    chainId
+  };
+}
+function encodeDeposit(args, chainId) {
+  if (args.assets <= 0n) {
+    throw usage("`assets` must be > 0");
+  }
+  const vault = getAddress(args.vault);
+  const receiver = getAddress(args.receiver);
+  const asset = getAddress(args.asset);
+  const txs = [];
+  let wrapped = false;
+  if (args.wrapEth) {
+    const weth = getDeployment(chainId).tokens.weth;
+    if (!weth || getAddress(weth.address) !== asset) {
+      throw usage("`wrapEth` is only valid for WETH vaults \u2014 the vault asset must be the chain's WETH.");
+    }
+    const held = args.currentWethBalance ?? 0n;
+    const shortfall = held >= args.assets ? 0n : args.assets - held;
+    if (shortfall > 0n) {
+      txs.push({
+        to: asset,
+        data: encodeFunctionData({ abi: WETH_ABI, functionName: "deposit", args: [] }),
+        value: toHexValue(shortfall),
+        chainId
+      });
+      wrapped = true;
+    }
+  }
+  const needsApprove = args.currentAllowance === void 0 || args.currentAllowance < args.assets;
+  if (needsApprove) {
+    txs.push(encodeApproveTx(asset, vault, maxUint256, chainId));
+  }
+  txs.push(encodeDepositTx(vault, args.assets, receiver, chainId));
+  const minDecimal = formatUnits(args.assets, args.assetDecimals);
+  let description;
+  if (wrapped) {
+    description = needsApprove ? `Wrap ETH\u2192WETH, approve ${args.assetSymbol} for ${vault}, then deposit ${minDecimal} ${args.assetSymbol}.` : `Wrap ETH\u2192WETH, then deposit ${minDecimal} ${args.assetSymbol}.`;
+  } else {
+    description = needsApprove ? `Approve ${args.assetSymbol} for ${vault}, then deposit ${minDecimal} ${args.assetSymbol}.` : `Deposit ${minDecimal} ${args.assetSymbol} into ${vault}.`;
+  }
+  return {
+    txs,
+    preconditions: [
+      {
+        type: "balance",
+        asset,
+        assetSymbol: args.assetSymbol,
+        min: args.assets.toString(),
+        minDecimal
+      },
+      {
+        type: "allowance",
+        token: asset,
+        spender: vault,
+        min: args.assets.toString(),
+        minDecimal
+      },
+      { type: "vault-not-locked", vault },
+      { type: "depositor-approved", vault, depositor: receiver }
+    ],
+    description,
+    note: "Both txs are gated by vault state. If `redemptionsLocked()` is true the deposit reverts unless live NAV is available; check the vault read endpoint before broadcasting."
+  };
+}
+function formatUnits(value, decimals) {
+  if (decimals === 0)
+    return value.toString();
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const str = abs.toString().padStart(decimals + 1, "0");
+  const head = str.slice(0, str.length - decimals);
+  const tail = str.slice(str.length - decimals).replace(/0+$/, "");
+  const out = tail.length > 0 ? `${head}.${tail}` : head;
+  return negative ? `-${out}` : out;
+}
+function encodeRedeem(args, chainId) {
+  if (args.shares <= 0n)
+    throw usage("`shares` must be > 0");
+  const vault = getAddress(args.vault);
+  const receiver = getAddress(args.receiver);
+  const owner = getAddress(args.owner);
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI2,
+          functionName: "redeem",
+          args: [args.shares, receiver, owner]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Redeem ${args.shares.toString()} shares of ${vault} \u2192 ${receiver}.`,
+    note: "Synchronous path. Reverts if the vault has an active proposal AND live NAV is unavailable; in that case use /prepare/request-redeem (queue path) instead."
+  };
+}
+function encodeApproveDepositor(args, chainId) {
+  const vault = getAddress(args.vault);
+  const depositor = getAddress(args.depositor);
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI2,
+          functionName: "approveDepositor",
+          args: [depositor]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Approve depositor ${depositor} on vault ${vault}.`,
+    note: "Vault owner only."
+  };
+}
+function encodeRegisterAgent(args, chainId) {
+  const vault = getAddress(args.vault);
+  const agentAddress = getAddress(args.agentAddress);
+  const id = typeof args.agentId === "bigint" ? args.agentId : BigInt(args.agentId);
+  if (id < 0n)
+    throw usage("`agentId` must be a non-negative integer");
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI2,
+          functionName: "registerAgent",
+          args: [agentAddress, id]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Register agent ${agentAddress} (id ${id.toString()}) on vault ${vault}.`,
+    note: "Vault owner only. The ERC-8004 NFT must be owned by `agentAddress` or by the vault owner at registration time."
+  };
+}
+
+// ../sdk/dist/encoders/governor.js
+import { encodeFunctionData as encodeFunctionData2, getAddress as getAddress2, isAddress } from "viem";
+var ZERO_VALUE2 = "0x0";
+var VOTE_TYPES = {
+  For: 0,
+  Against: 1,
+  Abstain: 2
+};
+function governorTx(chainId, data) {
+  return {
+    to: getDeployment(chainId).sherwood.governor,
+    data,
+    value: ZERO_VALUE2,
+    chainId
+  };
+}
+function parseProposalId(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage("`proposalId` must be a non-negative integer");
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage("`proposalId` must be a non-negative integer");
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`proposalId\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+function encodeVote(args, chainId) {
+  const support = VOTE_TYPES[args.vote];
+  if (support === void 0) {
+    throw usage(`Unsupported vote "${args.vote}" \u2014 must be one of: ${Object.keys(VOTE_TYPES).join(", ")}`);
+  }
+  const proposalId = parseProposalId(args.proposalId);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "vote",
+    args: [proposalId, support]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [],
+    description: `Vote ${args.vote} on proposal ${proposalId.toString()}.`,
+    note: "Voter must hold ERC20Votes shares of the vault at the proposal's snapshot timestamp; double-voting reverts. Use the proposal read endpoint to check `voteEnd` first."
+  };
+}
+function lifecycleAction(fn, proposalId, chainId, description, note) {
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: fn,
+    args: [proposalId]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [],
+    description,
+    note
+  };
+}
+function encodeExecute(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("executeProposal", id, chainId, `Execute proposal ${id.toString()} (open the strategy).`, "Reverts if the proposal is not in the `Approved` state. Check `state == Approved` via the proposal read endpoint first.");
+}
+function encodeSettle(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("settleProposal", id, chainId, `Settle proposal ${id.toString()} (close the strategy and distribute fees).`, "Proposer can settle anytime; anyone can settle after the strategy duration elapses.");
+}
+function encodeCancel(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("cancelProposal", id, chainId, `Cancel proposal ${id.toString()} (proposer-only).`, "Only the proposer can cancel, and only while the proposal is in `Pending`, `GuardianReview`, or `Approved`.");
+}
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+function validateBatchCall(call, scope, idx) {
+  if (!call || typeof call !== "object") {
+    throw usage(`\`${scope}[${idx}]\` must be an object`);
+  }
+  const c = call;
+  if (typeof c.target !== "string" || !isAddress(c.target)) {
+    throw usage(`\`${scope}[${idx}].target\` must be a 0x-prefixed address`);
+  }
+  if (typeof c.data !== "string" || !/^0x[0-9a-fA-F]*$/.test(c.data)) {
+    throw usage(`\`${scope}[${idx}].data\` must be a 0x-prefixed hex string`);
+  }
+  let value;
+  if (typeof c.value === "string") {
+    if (!/^\d+$/.test(c.value)) {
+      throw usage(`\`${scope}[${idx}].value\` must be a non-negative integer string`);
+    }
+    value = BigInt(c.value);
+  } else if (typeof c.value === "bigint") {
+    if (c.value < 0n) {
+      throw usage(`\`${scope}[${idx}].value\` must be non-negative`);
+    }
+    value = c.value;
+  } else if (c.value === void 0 || c.value === null) {
+    value = 0n;
+  } else {
+    throw usage(`\`${scope}[${idx}].value\` must be a non-negative integer string (or omitted for 0)`);
+  }
+  return { target: getAddress2(c.target), data: c.data, value };
+}
+function encodePropose(args, chainId) {
+  const vault = getAddress2(args.vault);
+  const strategy2 = args.strategy === ZERO_ADDRESS2 ? ZERO_ADDRESS2 : getAddress2(args.strategy);
+  if (typeof args.metadataURI !== "string" || args.metadataURI.length === 0) {
+    throw usage("`metadataURI` must be a non-empty string (e.g. ipfs://...)");
+  }
+  if (!Number.isInteger(args.performanceFeeBps) || args.performanceFeeBps < 0 || args.performanceFeeBps > 1e4) {
+    throw usage("`performanceFeeBps` must be an integer in [0, 10000]");
+  }
+  const strategyDuration = typeof args.strategyDuration === "bigint" ? args.strategyDuration : BigInt(args.strategyDuration);
+  if (strategyDuration <= 0n) {
+    throw usage("`strategyDuration` must be > 0 (seconds)");
+  }
+  if (!Array.isArray(args.executeCalls)) {
+    throw usage("`executeCalls` must be an array of {target, data, value} objects");
+  }
+  if (!Array.isArray(args.settlementCalls)) {
+    throw usage("`settlementCalls` must be an array of {target, data, value} objects");
+  }
+  const executeCalls = args.executeCalls.map((c, i) => validateBatchCall(c, "executeCalls", i));
+  const settlementCalls = args.settlementCalls.map((c, i) => validateBatchCall(c, "settlementCalls", i));
+  const coProposers = (args.coProposers ?? []).map((cp, i) => {
+    if (!cp || typeof cp !== "object") {
+      throw usage(`\`coProposers[${i}]\` must be an object`);
+    }
+    const agent = cp.agent;
+    const splitBps = cp.splitBps;
+    if (typeof agent !== "string" || !isAddress(agent)) {
+      throw usage(`\`coProposers[${i}].agent\` must be a 0x-prefixed address`);
+    }
+    let bps;
+    if (typeof splitBps === "string" && /^\d+$/.test(splitBps)) {
+      bps = BigInt(splitBps);
+    } else if (typeof splitBps === "bigint") {
+      bps = splitBps;
+    } else if (typeof splitBps === "number" && Number.isInteger(splitBps) && splitBps >= 0) {
+      bps = BigInt(splitBps);
+    } else {
+      throw usage(`\`coProposers[${i}].splitBps\` must be a non-negative integer (string, number, or bigint)`);
+    }
+    if (bps < 0n || bps > 10000n) {
+      throw usage(`\`coProposers[${i}].splitBps\` must be in [0, 10000]`);
+    }
+    return { agent: getAddress2(agent), splitBps: bps };
+  });
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "propose",
+    args: [
+      vault,
+      strategy2,
+      args.metadataURI,
+      BigInt(args.performanceFeeBps),
+      strategyDuration,
+      executeCalls,
+      settlementCalls,
+      coProposers
+    ]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Propose a strategy on ${vault} (duration ${strategyDuration.toString()}s, fee ${args.performanceFeeBps} bps).`,
+    note: "Reverts if the vault has an active proposal (cooldown not elapsed). The strategy address is immutable post-propose; pass address(0) to opt out of live NAV. `coProposers[].splitBps` total must satisfy contract-side constraints."
+  };
+}
+function encodeUnstick(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "unstick",
+    args: [id]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [],
+    description: `Unstick proposal ${id.toString()} \u2014 run its governance-approved settlement calls (owner-instant, no funds beyond the approved calls).`,
+    note: "Vault-owner only. Valid only when the proposal is Executed AND its strategy duration has elapsed. Runs the proposal's pre-committed settlement calls and finalizes settlement; no owner stake required. Reverts if those calls revert \u2014 if they can't succeed, open an emergency-settle with custom unwind calls instead."
+  };
+}
+function encodeEmergencySettle(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  if (!Array.isArray(args.calls)) {
+    throw usage("`calls` must be an array of {target, data, value} objects");
+  }
+  const calls = args.calls.map((c, i) => validateBatchCall(c, "calls", i));
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "emergencySettleWithCalls",
+    args: [id, calls]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [],
+    description: `Open an emergency-settle review on proposal ${id.toString()} with ${calls.length} unwind call(s).`,
+    note: "Vault-owner only, requires bonded owner stake. Does NOT execute immediately \u2014 it commits the calls' hash and opens a guardian-reviewed window (default ~24h). After the window, finalize with finalizeEmergencySettle; guardians can block within it (owner stake burned on block-quorum)."
+  };
+}
+function parseUintArg(value, label) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage(`\`${label}\` must be a non-negative integer`);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage(`\`${label}\` must be a non-negative integer`);
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`${label}\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+var GOVERNOR_PARAM_SETTERS = {
+  votingPeriod: "setVotingPeriod",
+  executionWindow: "setExecutionWindow",
+  vetoThresholdBps: "setVetoThresholdBps",
+  maxPerformanceFeeBps: "setMaxPerformanceFeeBps",
+  maxStrategyDuration: "setMaxStrategyDuration",
+  cooldownPeriod: "setCooldownPeriod",
+  protocolFeeBps: "setProtocolFeeBps"
+};
+function encodeGovernorParam(args, chainId) {
+  const fn = GOVERNOR_PARAM_SETTERS[args.param];
+  if (!fn) {
+    throw usage(`Unknown governor param "${args.param}" \u2014 must be one of: ${Object.keys(GOVERNOR_PARAM_SETTERS).join(", ")}`);
+  }
+  const value = parseUintArg(args.value, args.param);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: fn,
+    args: [value]
+  });
+  return {
+    txs: [governorTx(chainId, data)],
+    preconditions: [],
+    description: `Set governor parameter ${args.param} = ${value.toString()}.`,
+    note: "Owner-only (the owner multisig). V1.5 has no on-chain parameter timelock \u2014 the change applies immediately on this call. Bounds are validated on-chain; out-of-range values revert. Setting a non-zero protocolFeeBps reverts unless protocolFeeRecipient is already set."
+  };
+}
+
+// ../sdk/dist/encoders/factory.js
+import { encodeFunctionData as encodeFunctionData3, getAddress as getAddress3 } from "viem";
+var ZERO_VALUE3 = "0x0";
+var SUBDOMAIN_RE = /^[a-z0-9-]{1,63}$/;
+function encodeCreateSyndicate(args, chainId) {
+  if (typeof args.metadataURI !== "string" || args.metadataURI.length === 0) {
+    throw usage("`metadataURI` must be a non-empty string (e.g. ipfs://...)");
+  }
+  if (typeof args.name !== "string" || args.name.length === 0) {
+    throw usage("`name` must be a non-empty string");
+  }
+  if (typeof args.symbol !== "string" || args.symbol.length === 0) {
+    throw usage("`symbol` must be a non-empty string");
+  }
+  if (typeof args.openDeposits !== "boolean") {
+    throw usage("`openDeposits` must be a boolean");
+  }
+  if (!SUBDOMAIN_RE.test(args.subdomain)) {
+    throw usage("`subdomain` must match /^[a-z0-9-]{1,63}$/ (lowercase letters, digits, hyphens)");
+  }
+  const asset = getAddress3(args.asset);
+  const creatorAgentId = typeof args.creatorAgentId === "bigint" ? args.creatorAgentId : BigInt(args.creatorAgentId);
+  if (creatorAgentId < 0n)
+    throw usage("`creatorAgentId` must be non-negative");
+  const factory = getDeployment(chainId).sherwood.factory;
+  const data = encodeFunctionData3({
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "createSyndicate",
+    args: [
+      creatorAgentId,
+      {
+        metadataURI: args.metadataURI,
+        asset,
+        name: args.name,
+        symbol: args.symbol,
+        openDeposits: args.openDeposits,
+        subdomain: args.subdomain
+      }
+    ]
+  });
+  return {
+    txs: [{ to: factory, data, value: ZERO_VALUE3, chainId }],
+    preconditions: [
+      // Creator must own the ERC-8004 NFT for `creatorAgentId` and have
+      // pre-staked the owner bond via guardianRegistry.prepareOwnerStake.
+      // No on-chain check from the SDK side — agent verifies upstream.
+    ],
+    description: `Create syndicate "${args.subdomain}" with ${args.openDeposits ? "open" : "whitelisted"} deposits.`,
+    note: "Caller must own the ERC-8004 NFT for `creatorAgentId` and must have called `guardianRegistry.prepareOwnerStake` first to bond the owner stake. The factory's `createSyndicate` deploys a vault proxy + binds the owner stake atomically."
+  };
+}
+
+// ../sdk/dist/encoders/strategy.js
+import { concatHex, encodeAbiParameters, encodeFunctionData as encodeFunctionData4, encodePacked, getAddress as getAddress4, getCreate2Address, isHex, keccak256 } from "viem";
+var ZERO_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+var ZERO_VALUE4 = "0x0";
+var ERC1167_PREFIX = "0x3d602d80600a3d3981f3363d3d373d3d3d363d73";
+var ERC1167_SUFFIX = "0x5af43d82803e903d91602b57fd5bf3";
+function predictStrategyCloneAddress(factory, template, salt) {
+  const initCode = concatHex([
+    ERC1167_PREFIX,
+    getAddress4(template),
+    ERC1167_SUFFIX
+  ]);
+  return getCreate2Address({
+    from: getAddress4(factory),
+    salt,
+    bytecode: initCode
+  });
+}
+function deriveStrategySalt(vault, proposer, template, initData) {
+  return keccak256(encodePacked(["address", "address", "address", "bytes"], [getAddress4(vault), getAddress4(proposer), getAddress4(template), initData]));
+}
+function effectiveStrategySalt(vault, salt) {
+  return keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [getAddress4(vault), salt]));
+}
+function requireSalt(value) {
+  if (typeof value !== "string" || !isHex(value) || value.length !== 66) {
+    throw usage("`salt` must be a 0x-prefixed 32-byte hex string (66 chars)");
+  }
+  return value;
+}
+function encodeStrategyDeploy(args, chainId) {
+  const template = getAddress4(args.template);
+  const vault = getAddress4(args.vault);
+  const proposer = getAddress4(args.proposer);
+  if (typeof args.initData !== "string" || !isHex(args.initData)) {
+    throw usage("`initData` must be a 0x-prefixed hex string");
+  }
+  if (template === ZERO_ADDRESS3) {
+    throw usage("`template` must be a non-zero address");
+  }
+  if (proposer === ZERO_ADDRESS3) {
+    throw usage("`proposer` must be a non-zero address");
+  }
+  const factory = args.factory ? getAddress4(args.factory) : getDeployment(chainId).sherwood.strategyFactory;
+  if (factory === ZERO_ADDRESS3) {
+    throw unavailable(`StrategyFactory is not yet deployed on chain ${chainId} \u2014 mirror its address into the SDK once it lands (issue #387), or pass an explicit \`factory\`.`);
+  }
+  const salt = args.salt ? requireSalt(args.salt) : deriveStrategySalt(vault, proposer, template, args.initData);
+  const clone = predictStrategyCloneAddress(factory, template, effectiveStrategySalt(vault, salt));
+  const data = encodeFunctionData4({
+    abi: STRATEGY_FACTORY_ABI,
+    functionName: "cloneAndInitDeterministic",
+    args: [template, vault, proposer, args.initData, salt]
+  });
+  const tx = { to: factory, data, value: ZERO_VALUE4, chainId };
+  return {
+    txs: [tx],
+    preconditions: [],
+    clone,
+    salt,
+    factory,
+    description: `Deploy a strategy clone of ${template} for vault ${vault} (deterministic \u2014 clone at ${clone}).`,
+    note: "Broadcast this tx from `proposer` \u2014 the factory requires proposer == msg.sender, and msg.sender must be the vault owner or a registered agent. The vault must be registered on the SyndicateFactory and `template` must be on the factory's allowlist (the factory reverts otherwise). The clone address is fixed by (factory, template, vault, salt) \u2014 reference it as the proposal `strategy` and inside executeCalls/settlementCalls. The factory binds the salt to the vault, and `_authClone` lets only the vault's owner/agents deploy there, so the predicted address can't be front-run."
+  };
+}
+
+// ../sdk/dist/encoders/identity.js
+import { encodeFunctionData as encodeFunctionData5, getAddress as getAddress5 } from "viem";
+var ZERO_ADDRESS4 = "0x0000000000000000000000000000000000000000";
+var ERC8004_TYPE = "https://eips.ethereum.org/EIPS/eip-8004#registration-v1";
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function toBase64Utf8(str) {
+  const bin = encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+  let out = "";
+  for (let i = 0; i < bin.length; i += 3) {
+    const a = bin.charCodeAt(i);
+    const hasB = i + 1 < bin.length;
+    const hasC = i + 2 < bin.length;
+    const b = hasB ? bin.charCodeAt(i + 1) : 0;
+    const c = hasC ? bin.charCodeAt(i + 2) : 0;
+    out += B64_ALPHABET[a >> 2];
+    out += B64_ALPHABET[(a & 3) << 4 | b >> 4];
+    out += hasB ? B64_ALPHABET[(b & 15) << 2 | c >> 6] : "=";
+    out += hasC ? B64_ALPHABET[c & 63] : "=";
+  }
+  return out;
+}
+function encodeIdentityMint(args, chainId) {
+  const registry2 = getDeployment(chainId).identityRegistry;
+  if (registry2 === ZERO_ADDRESS4) {
+    throw unsupported(`ERC-8004 identity registry is not deployed on chain ${chainId} \u2014 mint on Base (8453).`);
+  }
+  if (!args.name)
+    throw usage("`name` is required");
+  if (!args.description)
+    throw usage("`description` is required");
+  const reg = {
+    type: ERC8004_TYPE,
+    name: args.name,
+    description: args.description
+  };
+  if (args.image)
+    reg.image = args.image;
+  reg.services = [];
+  reg.active = args.active ?? true;
+  reg.x402Support = args.x402Support ?? false;
+  const json = JSON.stringify(reg);
+  const dataUri = `data:application/json;base64,${toBase64Utf8(json)}`;
+  return {
+    txs: [
+      {
+        to: getAddress5(registry2),
+        data: encodeFunctionData5({
+          abi: IDENTITY_REGISTRY_ABI,
+          functionName: "register",
+          args: [dataUri, []]
+        }),
+        value: "0x0",
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Mint an ERC-8004 agent identity "${args.name}" on chain ${chainId}.`,
+    note: "ERC-8004 identity is minted on Base. Read the resulting token id from the mint receipt (chainId:tokenId); reference it when creating or joining syndicates."
+  };
+}
+
+// ../sdk/dist/encoders/eas.js
+import { encodeAbiParameters as encodeAbiParameters2, encodeFunctionData as encodeFunctionData6, getAddress as getAddress6, parseAbiParameters } from "viem";
+var ZERO_ADDRESS5 = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var JOIN_REQUEST_PARAMS = parseAbiParameters("uint256, uint256, address, string");
+var AGENT_APPROVED_PARAMS = parseAbiParameters("uint256, uint256, address");
+var toBig = (x) => typeof x === "bigint" ? x : BigInt(x);
+function formatMessageWithRef(message, referrerAgentId) {
+  if (referrerAgentId == null)
+    return message;
+  return `[ref:${referrerAgentId}] ${message}`;
+}
+function formatMessageWithChain(message, sourceSlug, easSlug) {
+  if (sourceSlug === easSlug)
+    return message;
+  return `[chain:${sourceSlug}] ${message}`;
+}
+function buildAttestTx(easAddress, schema, recipient, data, chainId) {
+  return {
+    to: getAddress6(easAddress),
+    data: encodeFunctionData6({
+      abi: EAS_ABI,
+      functionName: "attest",
+      args: [
+        {
+          schema,
+          data: {
+            recipient,
+            expirationTime: 0n,
+            revocable: true,
+            refUID: ZERO_BYTES322,
+            data,
+            value: 0n
+          }
+        }
+      ]
+    }),
+    value: "0x0",
+    chainId
+  };
+}
+function encodeJoinRequest(args, chainId) {
+  const dep = getDeployment(chainId);
+  const eas = dep.eas;
+  if (eas.address === ZERO_ADDRESS5) {
+    throw unsupported(`No EAS coordination path on chain ${chainId} \u2014 join requests require a chain whose attestations are pinned to Base.`);
+  }
+  const easSlug = getDeployment(eas.chainId).slug;
+  const message = formatMessageWithChain(formatMessageWithRef(args.message, args.referrerAgentId), dep.slug, easSlug);
+  const data = encodeAbiParameters2(JOIN_REQUEST_PARAMS, [
+    toBig(args.syndicateId),
+    toBig(args.agentId),
+    getAddress6(args.vault),
+    message
+  ]);
+  return {
+    txs: [
+      buildAttestTx(eas.address, eas.schemas.joinRequest, getAddress6(args.creator), data, eas.chainId)
+    ],
+    preconditions: [],
+    description: `Request to join syndicate ${toBig(args.syndicateId).toString()} (vault ${getAddress6(args.vault)}).`,
+    note: "EAS coordination attestation \u2014 always submitted on Base, even for syndicates on another chain. Revocable; the creator discovers it via the join-request schema."
+  };
+}
+function encodeApproveAgent(args, chainId) {
+  const dep = getDeployment(chainId);
+  const eas = dep.eas;
+  if (eas.address === ZERO_ADDRESS5) {
+    throw unsupported(`No EAS coordination path on chain ${chainId} \u2014 approvals require a chain whose attestations are pinned to Base.`);
+  }
+  const registerTx = encodeRegisterAgent({
+    vault: args.vault,
+    agentAddress: args.agentAddress,
+    agentId: toBig(args.agentId)
+  }, chainId).txs[0];
+  const data = encodeAbiParameters2(AGENT_APPROVED_PARAMS, [
+    toBig(args.syndicateId),
+    toBig(args.agentId),
+    getAddress6(args.vault)
+  ]);
+  const attestTx = buildAttestTx(eas.address, eas.schemas.agentApproved, getAddress6(args.agentAddress), data, eas.chainId);
+  return {
+    txs: [registerTx, attestTx],
+    preconditions: [],
+    description: `Approve agent ${toBig(args.agentId).toString()} for syndicate ${toBig(args.syndicateId).toString()}: register on the vault (chain ${chainId}) + AGENT_APPROVED attestation on Base.`,
+    note: "Vault owner only. Two txs on two chains: registerAgent runs on the syndicate's chain; the approval attestation runs on Base."
+  };
+}
+
+// ../sdk/dist/encoders/guardian.js
+import { encodeFunctionData as encodeFunctionData7, getAddress as getAddress7 } from "viem";
+var ZERO_VALUE5 = "0x0";
+function registryTx(chainId, data) {
+  const registry2 = getDeployment(chainId).sherwood.guardianRegistry;
+  if (registry2 === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`Guardian registry is not deployed on chain ${chainId} yet`);
+  }
+  return { to: registry2, data, value: ZERO_VALUE5, chainId };
+}
+function parseUint(value, field) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage(`\`${field}\` must be a non-negative integer`);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage(`\`${field}\` must be a non-negative integer`);
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`${field}\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+function encodeGuardianStake(args, chainId) {
+  if (args.amount <= 0n)
+    throw usage("`amount` must be > 0");
+  const agentId = parseUint(args.agentId, "agentId");
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "stakeAsGuardian",
+    args: [args.amount, agentId]
+  });
+  const registry2 = getDeployment(chainId).sherwood.guardianRegistry;
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [
+      // Caller must have approved WOOD for the registry; agent should
+      // check this client-side and prepend an ERC20.approve if needed.
+      {
+        type: "allowance",
+        token: registry2,
+        spender: registry2,
+        min: args.amount.toString(),
+        minDecimal: args.amount.toString()
+      }
+    ],
+    description: `Stake ${args.amount.toString()} WOOD as guardian (agent ${agentId.toString()}).`,
+    note: "Caller must have approved WOOD for the registry first. Stake locks the WOOD; use /prepare/guardian-unstake later to start the 7d unstake cooldown."
+  };
+}
+var GUARDIAN_UNSTAKE_FN = {
+  request: "requestUnstakeGuardian",
+  cancel: "cancelUnstakeGuardian",
+  claim: "claimUnstakeGuardian"
+};
+function encodeGuardianUnstake(args, chainId) {
+  const fn = GUARDIAN_UNSTAKE_FN[args.action];
+  if (!fn) {
+    throw usage(`\`action\` must be one of: ${Object.keys(GUARDIAN_UNSTAKE_FN).join(", ")}`);
+  }
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: fn,
+    args: []
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Guardian unstake ${args.action}.`,
+    note: args.action === "request" ? "Starts a 7-day cooldown. After it elapses, call again with action=claim to withdraw." : args.action === "claim" ? "Withdraws the unstake amount once the 7-day cooldown has elapsed." : "Cancels a pending unstake request and re-activates the guardian."
+  };
+}
+function encodeGuardianDelegate(args, chainId) {
+  if (args.amount <= 0n)
+    throw usage("`amount` must be > 0");
+  const delegate = getAddress7(args.delegate);
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "delegateStake",
+    args: [delegate, args.amount]
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Delegate ${args.amount.toString()} WOOD to ${delegate}.`,
+    note: "Caller must have approved WOOD for the registry first. Delegation does NOT activate the delegate as a guardian \u2014 they must self-stake separately."
+  };
+}
+var DELEGATION_UNSTAKE_FN = {
+  request: "requestUnstakeDelegation",
+  cancel: "cancelUnstakeDelegation",
+  claim: "claimUnstakeDelegation"
+};
+function encodeDelegationUnstake(args, chainId) {
+  const fn = DELEGATION_UNSTAKE_FN[args.action];
+  if (!fn) {
+    throw usage(`\`action\` must be one of: ${Object.keys(DELEGATION_UNSTAKE_FN).join(", ")}`);
+  }
+  const delegate = getAddress7(args.delegate);
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: fn,
+    args: [delegate]
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Delegation unstake ${args.action} for delegate ${delegate}.`,
+    note: args.action === "request" ? "Starts a 7-day cooldown on the delegated amount." : args.action === "claim" ? "Withdraws the delegated amount once the 7-day cooldown has elapsed." : "Cancels a pending unstake of the delegation."
+  };
+}
+function encodeSetCommission(args, chainId) {
+  if (!Number.isInteger(args.bps) || args.bps < 0 || args.bps > 5e3) {
+    throw usage("`bps` must be an integer in [0, 5000] (0\u201350%)");
+  }
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "setCommission",
+    args: [args.bps]
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Set DPoS commission to ${args.bps} bps.`,
+    note: "Raise-rate is capped at 500 bps above the epoch-start rate; first set on a delegate is exempt. Decreases are unbounded."
+  };
+}
+function encodeClaimProposalReward(args, chainId) {
+  const proposalId = parseUint(args.proposalId, "proposalId");
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "claimProposalReward",
+    args: [proposalId]
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Claim guardian-fee reward for proposal ${proposalId.toString()}.`,
+    note: "Approver-side claim. Pulls the DPoS commission slice and seeds the delegator pool atomically."
+  };
+}
+function encodeClaimDelegatorProposalReward(args, chainId) {
+  const proposalId = parseUint(args.proposalId, "proposalId");
+  const delegate = getAddress7(args.delegate);
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "claimDelegatorProposalReward",
+    args: [delegate, proposalId]
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Claim delegator-share reward from delegate ${delegate} for proposal ${proposalId.toString()}.`,
+    note: "Delegator-side claim. The approver must have claimed first to seed the delegator pool."
+  };
+}
+
+// ../sdk/dist/reads/syndicates.js
+import { getAddress as getAddress8 } from "viem";
+
 // src/strategies/moonwell-supply-template.ts
-import { encodeAbiParameters, encodeFunctionData } from "viem";
+import { encodeAbiParameters as encodeAbiParameters3, encodeFunctionData as encodeFunctionData8 } from "viem";
 function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount) {
-  return encodeAbiParameters(
+  return encodeAbiParameters3(
     [
       { type: "address" },
       { type: "address" },
@@ -298,7 +1988,7 @@ function buildExecuteCalls(clone, underlying, supplyAmount) {
   return [
     {
       target: underlying,
-      data: encodeFunctionData({
+      data: encodeFunctionData8({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, supplyAmount]
@@ -307,7 +1997,7 @@ function buildExecuteCalls(clone, underlying, supplyAmount) {
     },
     {
       target: clone,
-      data: encodeFunctionData({
+      data: encodeFunctionData8({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -319,7 +2009,7 @@ function buildSettleCalls(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData({
+      data: encodeFunctionData8({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -329,7 +2019,7 @@ function buildSettleCalls(clone) {
 }
 
 // src/strategies/venice-inference-template.ts
-import { encodeAbiParameters as encodeAbiParameters2, encodeFunctionData as encodeFunctionData2 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters4, encodeFunctionData as encodeFunctionData9 } from "viem";
 var INIT_PARAMS_TYPES = [
   {
     type: "tuple",
@@ -349,13 +2039,13 @@ var INIT_PARAMS_TYPES = [
   }
 ];
 function buildInitData2(params) {
-  return encodeAbiParameters2(INIT_PARAMS_TYPES, [params]);
+  return encodeAbiParameters4(INIT_PARAMS_TYPES, [params]);
 }
 function buildExecuteCalls2(clone, asset, assetAmount) {
   return [
     {
       target: asset,
-      data: encodeFunctionData2({
+      data: encodeFunctionData9({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, assetAmount]
@@ -364,7 +2054,7 @@ function buildExecuteCalls2(clone, asset, assetAmount) {
     },
     {
       target: clone,
-      data: encodeFunctionData2({
+      data: encodeFunctionData9({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -376,7 +2066,7 @@ function buildSettleCalls2(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData2({
+      data: encodeFunctionData9({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -386,7 +2076,7 @@ function buildSettleCalls2(clone) {
 }
 
 // src/strategies/aerodrome-lp-template.ts
-import { encodeAbiParameters as encodeAbiParameters3, encodeFunctionData as encodeFunctionData3 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData10 } from "viem";
 var INIT_PARAMS_TYPES2 = [
   {
     type: "tuple",
@@ -408,13 +2098,13 @@ var INIT_PARAMS_TYPES2 = [
   }
 ];
 function buildInitData3(params) {
-  return encodeAbiParameters3(INIT_PARAMS_TYPES2, [params]);
+  return encodeAbiParameters5(INIT_PARAMS_TYPES2, [params]);
 }
 function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
   return [
     {
       target: tokenA,
-      data: encodeFunctionData3({
+      data: encodeFunctionData10({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, amountA]
@@ -423,7 +2113,7 @@ function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
     },
     {
       target: tokenB,
-      data: encodeFunctionData3({
+      data: encodeFunctionData10({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, amountB]
@@ -432,7 +2122,7 @@ function buildExecuteCalls3(clone, tokenA, amountA, tokenB, amountB) {
     },
     {
       target: clone,
-      data: encodeFunctionData3({
+      data: encodeFunctionData10({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -444,7 +2134,7 @@ function buildSettleCalls3(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData3({
+      data: encodeFunctionData10({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -454,7 +2144,7 @@ function buildSettleCalls3(clone) {
 }
 
 // src/strategies/wsteth-moonwell-template.ts
-import { encodeAbiParameters as encodeAbiParameters4, encodeFunctionData as encodeFunctionData4, maxUint256 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters6, encodeFunctionData as encodeFunctionData11, maxUint256 as maxUint2562 } from "viem";
 var INIT_PARAMS_TYPES3 = [
   {
     type: "tuple",
@@ -473,14 +2163,14 @@ var INIT_PARAMS_TYPES3 = [
   }
 ];
 function buildInitData4(params) {
-  return encodeAbiParameters4(INIT_PARAMS_TYPES3, [params]);
+  return encodeAbiParameters6(INIT_PARAMS_TYPES3, [params]);
 }
 function buildExecuteCalls4(clone, weth, supplyAmount) {
-  const approveAmount = supplyAmount === 0n ? maxUint256 : supplyAmount;
+  const approveAmount = supplyAmount === 0n ? maxUint2562 : supplyAmount;
   return [
     {
       target: weth,
-      data: encodeFunctionData4({
+      data: encodeFunctionData11({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, approveAmount]
@@ -489,7 +2179,7 @@ function buildExecuteCalls4(clone, weth, supplyAmount) {
     },
     {
       target: clone,
-      data: encodeFunctionData4({
+      data: encodeFunctionData11({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -497,7 +2187,7 @@ function buildExecuteCalls4(clone, weth, supplyAmount) {
     },
     {
       target: weth,
-      data: encodeFunctionData4({
+      data: encodeFunctionData11({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, 0n]
@@ -510,7 +2200,7 @@ function buildSettleCalls4(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData4({
+      data: encodeFunctionData11({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -520,9 +2210,9 @@ function buildSettleCalls4(clone) {
 }
 
 // src/strategies/mamo-yield-template.ts
-import { encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData5 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters7, encodeFunctionData as encodeFunctionData12 } from "viem";
 function buildInitData5(underlying, mamoFactory, minRedeemAmount) {
-  return encodeAbiParameters5(
+  return encodeAbiParameters7(
     [
       { type: "address" },
       { type: "address" },
@@ -535,7 +2225,7 @@ function buildExecuteCalls5(clone, underlying, amount) {
   return [
     {
       target: underlying,
-      data: encodeFunctionData5({
+      data: encodeFunctionData12({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, amount]
@@ -544,7 +2234,7 @@ function buildExecuteCalls5(clone, underlying, amount) {
     },
     {
       target: clone,
-      data: encodeFunctionData5({
+      data: encodeFunctionData12({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -556,7 +2246,7 @@ function buildSettleCalls5(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData5({
+      data: encodeFunctionData12({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -566,13 +2256,13 @@ function buildSettleCalls5(clone) {
 }
 
 // src/strategies/portfolio-template.ts
-import { encodeAbiParameters as encodeAbiParameters6, encodeFunctionData as encodeFunctionData6 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters8, encodeFunctionData as encodeFunctionData13 } 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);
   const priceDecimals = allocations.map((a) => a.priceDecimals);
-  return encodeAbiParameters6(
+  return encodeAbiParameters8(
     [
       { type: "address" },
       { type: "address" },
@@ -601,7 +2291,7 @@ function buildExecuteCalls6(clone, asset, totalAmount) {
   return [
     {
       target: asset,
-      data: encodeFunctionData6({
+      data: encodeFunctionData13({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, totalAmount]
@@ -610,7 +2300,7 @@ function buildExecuteCalls6(clone, asset, totalAmount) {
     },
     {
       target: clone,
-      data: encodeFunctionData6({
+      data: encodeFunctionData13({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -622,7 +2312,7 @@ function buildSettleCalls6(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData6({
+      data: encodeFunctionData13({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -632,9 +2322,9 @@ function buildSettleCalls6(clone) {
 }
 
 // src/strategies/hyperliquid-perp-template.ts
-import { encodeAbiParameters as encodeAbiParameters7, encodeFunctionData as encodeFunctionData7, maxUint256 as maxUint2562 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters9, encodeFunctionData as encodeFunctionData14, maxUint256 as maxUint2563 } from "viem";
 function buildInitData7(asset, depositAmount, perpAssetIndex, leverage, maxPositionSize, maxTradesPerDay) {
-  return encodeAbiParameters7(
+  return encodeAbiParameters9(
     [
       { type: "address" },
       { type: "uint256" },
@@ -647,11 +2337,11 @@ function buildInitData7(asset, depositAmount, perpAssetIndex, leverage, maxPosit
   );
 }
 function buildExecuteCalls7(clone, asset, amount) {
-  const approveAmount = amount === 0n ? maxUint2562 : amount;
+  const approveAmount = amount === 0n ? maxUint2563 : amount;
   return [
     {
       target: asset,
-      data: encodeFunctionData7({
+      data: encodeFunctionData14({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, approveAmount]
@@ -660,7 +2350,7 @@ function buildExecuteCalls7(clone, asset, amount) {
     },
     {
       target: clone,
-      data: encodeFunctionData7({
+      data: encodeFunctionData14({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -668,7 +2358,7 @@ function buildExecuteCalls7(clone, asset, amount) {
     },
     {
       target: asset,
-      data: encodeFunctionData7({
+      data: encodeFunctionData14({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, 0n]
@@ -681,7 +2371,7 @@ function buildSettleCalls7(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData7({
+      data: encodeFunctionData14({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -691,9 +2381,9 @@ function buildSettleCalls7(clone) {
 }
 
 // src/strategies/hyperliquid-grid-template.ts
-import { encodeAbiParameters as encodeAbiParameters8, encodeFunctionData as encodeFunctionData8, maxUint256 as maxUint2563 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters10, encodeFunctionData as encodeFunctionData15, maxUint256 as maxUint2564 } from "viem";
 function buildInitData8(asset, depositAmount, leverage, maxOrderSize, maxOrdersPerTick, assetIndices) {
-  return encodeAbiParameters8(
+  return encodeAbiParameters10(
     [
       { type: "address" },
       { type: "uint256" },
@@ -706,11 +2396,11 @@ function buildInitData8(asset, depositAmount, leverage, maxOrderSize, maxOrdersP
   );
 }
 function buildExecuteCalls8(clone, asset, amount) {
-  const approveAmount = amount === 0n ? maxUint2563 : amount;
+  const approveAmount = amount === 0n ? maxUint2564 : amount;
   return [
     {
       target: asset,
-      data: encodeFunctionData8({
+      data: encodeFunctionData15({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, approveAmount]
@@ -719,7 +2409,7 @@ function buildExecuteCalls8(clone, asset, amount) {
     },
     {
       target: clone,
-      data: encodeFunctionData8({
+      data: encodeFunctionData15({
         abi: BASE_STRATEGY_ABI,
         functionName: "execute"
       }),
@@ -727,7 +2417,7 @@ function buildExecuteCalls8(clone, asset, amount) {
     },
     {
       target: asset,
-      data: encodeFunctionData8({
+      data: encodeFunctionData15({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [clone, 0n]
@@ -740,7 +2430,7 @@ function buildSettleCalls8(clone) {
   return [
     {
       target: clone,
-      data: encodeFunctionData8({
+      data: encodeFunctionData15({
         abi: BASE_STRATEGY_ABI,
         functionName: "settle"
       }),
@@ -765,14 +2455,14 @@ function encodeV3Path(tokens, fees) {
 }
 function buildSwapExtraData(network, tokenIn, tokenOut, feeTier, hop) {
   if (network === "robinhood-testnet") {
-    return encodeAbiParameters9([{ type: "uint24" }], [feeTier]);
+    return encodeAbiParameters11([{ type: "uint24" }], [feeTier]);
   }
   if (hop) {
     const path = encodeV3Path([tokenIn, hop.via, tokenOut], [hop.feeIn, hop.feeOut]);
-    const encoded2 = encodeAbiParameters9([{ type: "bytes" }], [path]);
+    const encoded2 = encodeAbiParameters11([{ type: "bytes" }], [path]);
     return `0x01${encoded2.slice(2)}`;
   }
-  const encoded = encodeAbiParameters9([{ type: "uint24" }], [feeTier]);
+  const encoded = encodeAbiParameters11([{ type: "uint24" }], [feeTier]);
   return `0x00${encoded.slice(2)}`;
 }
 async function detectSwapRoute(asset, token, preferredFeeTier) {
@@ -1174,7 +2864,7 @@ async function buildInitDataForTemplate(templateKey, opts, vault) {
     const feeTier = opts.feeTier || "3000";
     const tokenAddrs = opts.tokens.split(",").map((t) => {
       const trimmed = t.trim();
-      if (isAddress(trimmed)) return trimmed;
+      if (isAddress2(trimmed)) return trimmed;
       const allTokens = tokens;
       const resolved = allTokens[trimmed.toUpperCase()];
       if (resolved && resolved !== ZERO) return resolved;
@@ -1319,7 +3009,7 @@ function resolveSwapAdapter() {
   process.exit(1);
 }
 function resolveToken(symbolOrAddress) {
-  if (isAddress(symbolOrAddress)) return symbolOrAddress;
+  if (isAddress2(symbolOrAddress)) return symbolOrAddress;
   const upper = symbolOrAddress.toUpperCase();
   const tokens = TOKENS();
   const tokenMap = {
@@ -1383,11 +3073,11 @@ function registerStrategyTemplateCommands(strategy2) {
       console.log();
       console.log(chalk.yellow("  No strategy templates deployed on this network."));
     }
-    const unavailable = TEMPLATES.filter((t) => templates[t.addressKey] === ZERO);
-    if (unavailable.length > 0) {
+    const unavailable2 = TEMPLATES.filter((t) => templates[t.addressKey] === ZERO);
+    if (unavailable2.length > 0) {
       console.log();
       console.log(chalk.dim(`  Not available on ${network}:`));
-      for (const t of unavailable) {
+      for (const t of unavailable2) {
         console.log(chalk.dim(`    ${t.name} (${t.key})`));
       }
     }
@@ -1398,7 +3088,7 @@ function registerStrategyTemplateCommands(strategy2) {
   });
   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, hyperliquid-perp, hyperliquid-grid").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)").option("--leverage <number>", "Leverage multiplier (Hyperliquid Perp, default: 10)").option("--asset-index <number>", "Perp asset index (Hyperliquid Perp, default: 0 for BTC)").option("--max-position <amount>", "Max position size in USD (Hyperliquid Perp, default: 100000)").option("--max-trades-per-day <n>", "Max trades per day (Hyperliquid Perp, default: 50)").option("--max-order-size <amount>", "Max single-order size in asset units (Hyperliquid Grid, default: 10000)").option("--max-orders-per-tick <n>", "Max orders per tick (Hyperliquid Grid, default: 20)").option("--asset-indices <list>", "Comma-separated perp asset indices (Hyperliquid Grid, default: 0)").action(async (templateKey, opts) => {
     const vault = opts.vault;
-    if (!isAddress(vault)) {
+    if (!isAddress2(vault)) {
       console.error(chalk.red("Invalid vault address"));
       process.exit(1);
     }
@@ -1467,11 +3157,11 @@ function registerStrategyTemplateCommands(strategy2) {
   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, hyperliquid-perp, hyperliquid-grid").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)").option("--leverage <number>", "Leverage multiplier (Hyperliquid Perp, default: 10)").option("--asset-index <number>", "Perp asset index (Hyperliquid Perp, default: 0 for BTC)").option("--max-position <amount>", "Max position size in USD (Hyperliquid Perp, default: 100000)").option("--max-trades-per-day <n>", "Max trades per day (Hyperliquid Perp, default: 50)").option("--max-order-size <amount>", "Max single-order size in asset units (Hyperliquid Grid, default: 10000)").option("--max-orders-per-tick <n>", "Max orders per tick (Hyperliquid Grid, default: 20)").option("--asset-indices <list>", "Comma-separated perp asset indices (Hyperliquid Grid, default: 0)").action(async (templateKey, opts) => {
     const clone = opts.clone;
     const vault = opts.vault;
-    if (!isAddress(clone)) {
+    if (!isAddress2(clone)) {
       console.error(chalk.red("Invalid clone address"));
       process.exit(1);
     }
-    if (!isAddress(vault)) {
+    if (!isAddress2(vault)) {
       console.error(chalk.red("Invalid vault address"));
       process.exit(1);
     }
@@ -1520,13 +3210,141 @@ 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, portfolio, hyperliquid-perp, hyperliquid-grid").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)").option("--leverage <number>", "Leverage multiplier (Hyperliquid Perp, default: 10)").option("--asset-index <number>", "Perp asset index (Hyperliquid Perp, default: 0 for BTC)").option("--max-position <amount>", "Max position size in USD (Hyperliquid Perp, default: 100000)").option("--max-trades-per-day <n>", "Max trades per day (Hyperliquid Perp, default: 50)").option("--max-order-size <amount>", "Max single-order size in asset units (Hyperliquid Grid, default: 10000)").option("--max-orders-per-tick <n>", "Max orders per tick (Hyperliquid Grid, default: 20)").option("--asset-indices <list>", "Comma-separated perp asset indices (Hyperliquid Grid, default: 0)").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, hyperliquid-perp, hyperliquid-grid").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("--proposer <address>", "Proposer/agent address (required for --calldata-only \u2014 the external signer)").option("--metadata-uri <uri>", "Metadata URI (required for --calldata-only \u2014 IPFS pin needs a signer)").option("--salt <bytes32>", "CREATE2 salt for the deterministic clone (--calldata-only; default: derived from inputs)").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)").option("--leverage <number>", "Leverage multiplier (Hyperliquid Perp, default: 10)").option("--asset-index <number>", "Perp asset index (Hyperliquid Perp, default: 0 for BTC)").option("--max-position <amount>", "Max position size in USD (Hyperliquid Perp, default: 100000)").option("--max-trades-per-day <n>", "Max trades per day (Hyperliquid Perp, default: 50)").option("--max-order-size <amount>", "Max single-order size in asset units (Hyperliquid Grid, default: 10000)").option("--max-orders-per-tick <n>", "Max orders per tick (Hyperliquid Grid, default: 20)").option("--asset-indices <list>", "Comma-separated perp asset indices (Hyperliquid Grid, default: 0)").action(async (templateKey, opts) => {
     const vault = opts.vault;
-    if (!isAddress(vault)) {
+    if (!isAddress2(vault)) {
       console.error(chalk.red("Invalid vault address"));
       process.exit(1);
     }
     const { def, address: templateAddr } = resolveTemplate(templateKey);
+    if (isCalldataOnly()) {
+      const missing = [];
+      if (!opts.proposer) missing.push("--proposer <address> (the external signer)");
+      if (!opts.metadataUri) missing.push("--metadata-uri <uri> (IPFS pin needs a signer)");
+      if (!opts.performanceFee) missing.push("--performance-fee <bps>");
+      if (!opts.duration) missing.push("--duration <d>");
+      if (missing.length > 0) {
+        console.error(chalk.red(`--calldata-only requires: ${missing.join(", ")}`));
+        process.exit(1);
+      }
+      const proposer = opts.proposer;
+      if (!isAddress2(proposer)) {
+        console.error(chalk.red("Invalid --proposer address"));
+        process.exit(1);
+      }
+      const performanceFeeBps2 = Number(opts.performanceFee);
+      if (!Number.isInteger(performanceFeeBps2) || performanceFeeBps2 < 0 || performanceFeeBps2 > 1e4) {
+        console.error(chalk.red("--performance-fee must be an integer 0-10000 (bps)"));
+        process.exit(1);
+      }
+      try {
+        const publicClient = getPublicClient();
+        const [isRegistered, paused] = await Promise.all([
+          publicClient.readContract({
+            address: vault,
+            abi: SYNDICATE_VAULT_ABI,
+            functionName: "isAgent",
+            args: [proposer]
+          }),
+          publicClient.readContract({
+            address: vault,
+            abi: SYNDICATE_VAULT_ABI,
+            functionName: "paused"
+          })
+        ]);
+        if (!isRegistered) {
+          console.error(
+            chalk.red(
+              `--proposer ${proposer} is not a registered agent on ${vault}; cloneAndInitDeterministic and propose will both revert.`
+            )
+          );
+          console.error(chalk.yellow(`  Register first: sherwood syndicate approve --wallet ${proposer}`));
+          process.exit(1);
+        }
+        if (paused) {
+          console.error(chalk.red(`Vault ${vault} is paused \u2014 the proposal would revert.`));
+          process.exit(1);
+        }
+        for (const check of computeProposalAssetChecks(templateKey, opts)) {
+          if (check.amount === 0n) continue;
+          const [balance, decimals] = await Promise.all([
+            publicClient.readContract({
+              address: check.asset,
+              abi: erc20Abi,
+              functionName: "balanceOf",
+              args: [vault]
+            }),
+            publicClient.readContract({
+              address: check.asset,
+              abi: erc20Abi,
+              functionName: "decimals"
+            })
+          ]);
+          if (balance < check.amount) {
+            console.error(
+              chalk.red(
+                `Vault ${vault} holds ${formatUnits2(balance, decimals)} ${check.label} but the proposal needs ${formatUnits2(check.amount, decimals)} ${check.label}.`
+              )
+            );
+            console.error(chalk.yellow(`  Hint: --amount is in human units (e.g. "10" = 10 ${check.label}), not raw decimals.`));
+            process.exit(1);
+          }
+        }
+      } catch (err) {
+        console.error(chalk.red(`Preflight read failed: ${err instanceof Error ? err.message : String(err)}`));
+        process.exit(1);
+      }
+      if (!opts.agent) opts.agent = proposer;
+      const { parseDuration: parseDuration3 } = await import("./governor-UBUNIO3U.js");
+      const strategyDuration2 = parseDuration3(opts.duration);
+      const chainId = getChain().id;
+      try {
+        const built = await buildInitDataForTemplate(templateKey, opts, vault);
+        const deploy = encodeStrategyDeploy(
+          {
+            template: templateAddr,
+            vault,
+            proposer,
+            initData: built.initData,
+            salt: opts.salt
+          },
+          chainId
+        );
+        const { executeCalls: executeCalls2, settleCalls: settleCalls2 } = buildCallsForTemplate(
+          templateKey,
+          deploy.clone,
+          built.asset,
+          built.assetAmount,
+          built.extraApprovals
+        );
+        const proposeAction = encodePropose(
+          {
+            vault,
+            strategy: deploy.clone,
+            metadataURI: opts.metadataUri,
+            performanceFeeBps: performanceFeeBps2,
+            strategyDuration: strategyDuration2,
+            executeCalls: executeCalls2,
+            settlementCalls: settleCalls2
+          },
+          chainId
+        );
+        emitCalldata({
+          txs: [...deploy.txs, ...proposeAction.txs],
+          preconditions: [...deploy.preconditions, ...proposeAction.preconditions],
+          // Surface the deterministic clone + salt as structured fields (also
+          // baked into tx 2's `strategy` arg + the execute/settle calls).
+          clone: deploy.clone,
+          salt: deploy.salt,
+          description: `Keyless ${def.name} proposal on ${vault}: (1) deploy clone at ${deploy.clone} (deterministic CREATE2, salt ${deploy.salt}); (2) governor.propose referencing it.`,
+          note: "Broadcast SEQUENTIALLY: send tx 1 (cloneAndInitDeterministic) and WAIT for it to confirm, then send tx 2 (propose). If tx 1 reverts \u2014 proposer not a registered agent, proposer != tx-1 signer, template not allowlisted, or vault unregistered \u2014 do NOT send tx 2: it would create a proposal referencing an undeployed strategy. Send tx 1 from the --proposer wallet (the factory requires proposer == msg.sender, and msg.sender must be a vault owner/agent). The clone address is pinned by (factory, template, vault, salt) and is already baked into tx 2 + the execute/settle calls. The factory binds the salt to the vault and only the vault's owner/agents may deploy there, so the predicted address can't be front-run."
+        });
+      } catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+      }
+      return;
+    }
     const account = getAccount();
     const preflightSpinner = ora("Preflight checks...").start();
     try {
@@ -1577,7 +3395,7 @@ function registerStrategyTemplateCommands(strategy2) {
           preflightSpinner.fail("Preflight failed");
           console.error(
             chalk.red(
-              `  Vault ${vault} holds ${formatUnits(balance, decimals)} ${check.label} but proposal requires ${formatUnits(check.amount, decimals)} ${check.label}.`
+              `  Vault ${vault} holds ${formatUnits2(balance, decimals)} ${check.label} but proposal requires ${formatUnits2(check.amount, decimals)} ${check.label}.`
             )
           );
           console.error(
@@ -1763,7 +3581,7 @@ 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)) {
+    if (!isAddress2(cloneArg)) {
       console.error(chalk.red("Invalid clone address"));
       process.exit(1);
     }
@@ -1826,13 +3644,13 @@ function registerStrategyTemplateCommands(strategy2) {
       } catch {
       }
       const pricesAvailable = prices.some((p) => p !== null);
-      const assetBalanceNum = Number(formatUnits(assetBalance, assetDecimals));
+      const assetBalanceNum = Number(formatUnits2(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));
+        const balanceNum = Number(formatUnits2(balance, decimals));
+        const investedNum = Number(formatUnits2(alloc.investedAmount, assetDecimals));
         totalInvested += alloc.investedAmount;
         const price = prices[i];
         let currentValue = null;
@@ -1845,9 +3663,9 @@ function registerStrategyTemplateCommands(strategy2) {
           symbol,
           decimals,
           targetWeightBps: Number(alloc.targetWeightBps),
-          balance: formatUnits(balance, decimals),
+          balance: formatUnits2(balance, decimals),
           balanceRaw: balance.toString(),
-          investedAmount: formatUnits(alloc.investedAmount, assetDecimals),
+          investedAmount: formatUnits2(alloc.investedAmount, assetDecimals),
           currentPrice: price?.price ?? null,
           currentValue,
           actualWeightBps: null,
@@ -1871,7 +3689,7 @@ function registerStrategyTemplateCommands(strategy2) {
           }
         }
       }
-      const totalInvestedNum = Number(formatUnits(totalInvested, assetDecimals));
+      const totalInvestedNum = Number(formatUnits2(totalInvested, assetDecimals));
       const totalPnl = pricesAvailable ? totalPortfolioValue - totalInvestedNum : null;
       const totalPnlPct = totalPnl !== null && totalInvestedNum > 0 ? totalPnl / totalInvestedNum * 100 : null;
       spinner?.succeed("Strategy state loaded");
@@ -1883,9 +3701,9 @@ function registerStrategyTemplateCommands(strategy2) {
           state: stateStr,
           network,
           asset: { address: assetAddr, symbol: assetSymbol, decimals: assetDecimals },
-          totalDeployed: formatUnits(totalAmount, assetDecimals),
+          totalDeployed: formatUnits2(totalAmount, assetDecimals),
           maxSlippageBps: Number(maxSlippage),
-          assetBalance: formatUnits(assetBalance, assetDecimals),
+          assetBalance: formatUnits2(assetBalance, assetDecimals),
           pricesAvailable,
           priceSource,
           portfolio: {
@@ -1910,9 +3728,9 @@ function registerStrategyTemplateCommands(strategy2) {
       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(`  Deployed:    ${formatUnits2(totalAmount, assetDecimals)} ${assetSymbol}`);
       console.log(`  Max Slip:    ${Number(maxSlippage) / 100}%`);
-      console.log(`  Asset held:  ${formatUnits(assetBalance, assetDecimals)} ${assetSymbol}`);
+      console.log(`  Asset held:  ${formatUnits2(assetBalance, assetDecimals)} ${assetSymbol}`);
       if (pricesAvailable) {
         const pvStr = totalPortfolioValue.toFixed(6);
         const pnlStr = totalPnl !== null ? (totalPnl >= 0 ? "+" : "") + totalPnl.toFixed(6) : "n/a";
@@ -1954,7 +3772,7 @@ function registerStrategyTemplateCommands(strategy2) {
         }
       }
       console.log(chalk.dim("\u2500".repeat(70)));
-      console.log(`  Total invested: ${formatUnits(totalInvested, assetDecimals)} ${assetSymbol}`);
+      console.log(`  Total invested: ${formatUnits2(totalInvested, assetDecimals)} ${assetSymbol}`);
       if (pricesAvailable && maxDriftToken) {
         const absMaxDrift = Math.abs(maxDriftBps);
         const driftColor = absMaxDrift > 500 ? chalk.red : absMaxDrift > 200 ? chalk.yellow : chalk.green;
@@ -1973,7 +3791,7 @@ function registerStrategyTemplateCommands(strategy2) {
     }
   });
   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)) {
+    if (!isAddress2(cloneArg)) {
       console.error(chalk.red("Invalid clone address"));
       process.exit(1);
     }
@@ -2017,7 +3835,7 @@ function registerStrategyTemplateCommands(strategy2) {
         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)}`
+          `  ${chalk.bold(symbol.padEnd(8))} ${weightPct.padEnd(8)} bal: ${formatUnits2(balance, decimals)}`
         );
       }
       let newWeightsBps;
@@ -2061,7 +3879,7 @@ function registerStrategyTemplateCommands(strategy2) {
         });
         const updateSpinner = ora("Updating target weights...").start();
         try {
-          const innerData = encodeAbiParameters9(
+          const innerData = encodeAbiParameters11(
             [{ type: "uint256[]" }, { type: "uint256" }, { type: "bytes[]" }],
             [newWeightsBps.map((w) => BigInt(w)), BigInt(maxSlip), swapData]
           );
@@ -2121,9 +3939,9 @@ function registerStrategyTemplateCommands(strategy2) {
         const alloc = postAllocations[i];
         const [balance, symbol, decimals] = postData[i];
         const weightPct = (Number(alloc.targetWeightBps) / 100).toFixed(1) + "%";
-        const investedStr = formatUnits(alloc.investedAmount, assetDecimals);
+        const investedStr = formatUnits2(alloc.investedAmount, assetDecimals);
         console.log(
-          `  ${chalk.bold(symbol.padEnd(8))} ${weightPct.padEnd(8)} invested: ${investedStr.padEnd(14)} bal: ${formatUnits(balance, decimals)}`
+          `  ${chalk.bold(symbol.padEnd(8))} ${weightPct.padEnd(8)} invested: ${investedStr.padEnd(14)} bal: ${formatUnits2(balance, decimals)}`
         );
       }
       console.log();
@@ -2205,7 +4023,7 @@ async function getActiveSyndicates2(creator) {
 }
 
 // src/commands/venice.ts
-import { formatUnits as formatUnits2, isAddress as isAddress2, parseUnits as parseUnits2 } from "viem";
+import { formatUnits as formatUnits3, isAddress as isAddress3, parseUnits as parseUnits2 } from "viem";
 import chalk2 from "chalk";
 import ora2 from "ora";
 import { readFileSync } from "fs";
@@ -2229,7 +4047,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)));
@@ -2270,10 +4088,10 @@ function registerVeniceCommands(program2) {
         args: [account.address]
       });
       if (vvvBalance < amount) {
-        balSpinner.fail(`Insufficient VVV: have ${formatUnits2(vvvBalance, 18)}, need ${opts.amount}`);
+        balSpinner.fail(`Insufficient VVV: have ${formatUnits3(vvvBalance, 18)}, need ${opts.amount}`);
         process.exit(1);
       }
-      balSpinner.succeed(`VVV balance: ${formatUnits2(vvvBalance, 18)}`);
+      balSpinner.succeed(`VVV balance: ${formatUnits3(vvvBalance, 18)}`);
     } catch (err) {
       balSpinner.fail("Failed to check VVV balance");
       console.error(chalk2.red(formatContractError(err)));
@@ -2313,7 +4131,7 @@ function registerVeniceCommands(program2) {
         functionName: "balanceOf",
         args: [account.address]
       });
-      stakeSpinner.succeed(`Staked ${opts.amount} VVV \u2192 ${formatUnits2(sVvvBalance, 18)} sVVV`);
+      stakeSpinner.succeed(`Staked ${opts.amount} VVV \u2192 ${formatUnits3(sVvvBalance, 18)} sVVV`);
       console.log(chalk2.dim("  You can now run: sherwood venice provision"));
     } catch (err) {
       stakeSpinner.fail("Stake failed");
@@ -2348,12 +4166,12 @@ function registerVeniceCommands(program2) {
     }
     if (sVvvBalance < amount) {
       balSpinner.fail(
-        `Insufficient sVVV: have ${formatUnits2(sVvvBalance, 18)}, need ${opts.amount}`
+        `Insufficient sVVV: have ${formatUnits3(sVvvBalance, 18)}, need ${opts.amount}`
       );
       console.log(chalk2.yellow("  Stake VVV first (see VeniceInferenceStrategy proposal flow)."));
       process.exit(1);
     }
-    balSpinner.succeed(`sVVV balance: ${formatUnits2(sVvvBalance, 18)}`);
+    balSpinner.succeed(`sVVV balance: ${formatUnits3(sVvvBalance, 18)}`);
     const quoteSpinner = ora2("Quoting DIEM output...").start();
     let expected;
     try {
@@ -2374,7 +4192,7 @@ function registerVeniceCommands(program2) {
     }
     const minOut = expected * (10000n - slippageBps) / 10000n;
     quoteSpinner.succeed(
-      `Expected: ${formatUnits2(expected, 18)} DIEM  (minOut @ ${slippageBps}bps: ${formatUnits2(minOut, 18)})`
+      `Expected: ${formatUnits3(expected, 18)} DIEM  (minOut @ ${slippageBps}bps: ${formatUnits3(minOut, 18)})`
     );
     const MIN_SPENDABLE_DIEM = parseUnits2("0.1", 18);
     let currentDiem = 0n;
@@ -2394,8 +4212,8 @@ function registerVeniceCommands(program2) {
       console.log();
       console.log(chalk2.red("  \u26A0  Venice requires \u2265 0.1 DIEM minimum before ANY DIEM credit"));
       console.log(chalk2.red("     becomes spendable on inference calls."));
-      console.log(chalk2.red(`     Projected DIEM after mint: ${formatUnits2(projectedDiem, 18)}  (short by ${formatUnits2(shortfall, 18)})`));
-      console.log(chalk2.red(`     Approx additional sVVV needed: ${formatUnits2(sVvvNeeded, 18)}`));
+      console.log(chalk2.red(`     Projected DIEM after mint: ${formatUnits3(projectedDiem, 18)}  (short by ${formatUnits3(shortfall, 18)})`));
+      console.log(chalk2.red(`     Approx additional sVVV needed: ${formatUnits3(sVvvNeeded, 18)}`));
       console.log(chalk2.dim("     Below threshold, this DIEM sits idle \u2014 consider acquiring"));
       console.log(chalk2.dim("     more sVVV first, or use x402 USDC pay-per-request."));
     }
@@ -2439,7 +4257,7 @@ function registerVeniceCommands(program2) {
       });
       const delta = diemAfter - diemBefore;
       mintSpinner.succeed(
-        `Minted ${formatUnits2(delta > 0n ? delta : diemAfter, 18)} DIEM` + (delta > 0n ? ` (balance: ${formatUnits2(diemAfter, 18)})` : "")
+        `Minted ${formatUnits3(delta > 0n ? delta : diemAfter, 18)} DIEM` + (delta > 0n ? ` (balance: ${formatUnits3(diemAfter, 18)})` : "")
       );
       console.log(chalk2.dim(`  Tx: ${hash}`));
       console.log(chalk2.yellow("  Note: Venice requires \u2265 0.1 DIEM to spend ANY DIEM credit, and"));
@@ -2454,7 +4272,7 @@ function registerVeniceCommands(program2) {
   });
   venice.command("status").description("Show Venice inference status: sVVV balances, DIEM, API key").requiredOption("--vault <address>", "Vault address").action(async (opts) => {
     const vaultAddress = opts.vault;
-    if (!isAddress2(vaultAddress)) {
+    if (!isAddress3(vaultAddress)) {
       console.error(chalk2.red(`Invalid vault address: ${opts.vault}`));
       process.exit(1);
     }
@@ -2517,18 +4335,18 @@ 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(`    DIEM (credits):    ${formatUnits2(myDiem, 18)}`);
+      console.log(`    sVVV:              ${formatUnits3(mySvvv, 18)}`);
+      console.log(`    Pending rewards:   ${formatUnits3(myPending, 18)} VVV`);
+      console.log(`    DIEM (credits):    ${formatUnits3(myDiem, 18)}`);
       console.log(chalk2.dim("    (mint via `sherwood venice mint-diem --amount <sVVV>`)"));
       console.log(chalk2.bold("\n  Venice API"));
       console.log(`    Key:     ${apiKey ? `${apiKey.slice(0, 8)}...${apiKey.slice(-4)}` : chalk2.dim("not provisioned")}`);
@@ -2599,11 +4417,11 @@ ${opts.prompt}`;
       }
       try {
         const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-5VIHTS3N.js");
-        const { keccak256: keccak2562, toHex, isAddress: isAddr } = await import("viem");
+        const { keccak256: keccak2563, toHex, isAddress: isAddr } = await import("viem");
         const { getChainContracts: getChainContracts2 } = await import("./config-REASKDIK.js");
         const { getChain: getActiveChain } = await import("./network-3ZU7UBDU.js");
         const vaultRecipient = opts.vault && isAddr(opts.vault) ? opts.vault : getChainContracts2(getActiveChain().id).vault;
-        const promptHash = keccak2562(toHex(userContent)).slice(0, 18);
+        const promptHash = keccak2563(toHex(userContent)).slice(0, 18);
         const { uid } = await createVeniceInferenceAttestation(
           result.model,
           result.usage.promptTokens,
@@ -2625,12 +4443,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 isAddress4 } from "viem";
 import chalk3 from "chalk";
 import ora3 from "ora";
 
 // src/strategies/allowance-disburse.ts
-import { encodeFunctionData as encodeFunctionData9, parseUnits as parseUnits3 } from "viem";
+import { encodeFunctionData as encodeFunctionData16, 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();
@@ -2639,7 +4457,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
   if (!isUsdc) {
     calls.push({
       target: assetAddress,
-      data: encodeFunctionData9({
+      data: encodeFunctionData16({
         abi: ERC20_ABI,
         functionName: "approve",
         args: [UNISWAP().SWAP_ROUTER, assetAmount]
@@ -2649,7 +4467,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     if (isWeth) {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData9({
+        data: encodeFunctionData16({
           abi: SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
           functionName: "exactInputSingle",
           args: [
@@ -2669,7 +4487,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
     } else {
       calls.push({
         target: UNISWAP().SWAP_ROUTER,
-        data: encodeFunctionData9({
+        data: encodeFunctionData16({
           abi: SWAP_ROUTER_ABI,
           functionName: "exactInput",
           args: [
@@ -2689,7 +4507,7 @@ function buildDisburseBatch(config, vaultAddress, agents, assetAddress, assetDec
   for (const agent of agents) {
     calls.push({
       target: TOKENS().USDC,
-      data: encodeFunctionData9({
+      data: encodeFunctionData16({
         abi: ERC20_ABI,
         functionName: "transfer",
         args: [agent, perAgent]
@@ -2706,7 +4524,7 @@ function registerAllowanceCommands(program2) {
   const allowance = program2.command("allowance").description("Disburse vault profits to agent wallets");
   allowance.command("disburse").description("Swap vault profits \u2192 USDC \u2192 distribute to all agent operator wallets").requiredOption("--vault <address>", "Vault address").requiredOption("--amount <amount>", "Deposit token amount to convert & distribute (e.g. 500)").option("--fee <tier>", "Fee tier for asset \u2192 USDC swap (500, 3000, 10000)", "3000").option("--slippage <bps>", "Slippage tolerance in bps", "100").option("--execute", "Execute on-chain (default: simulate only)", false).action(async (opts) => {
     const vaultAddress = opts.vault;
-    if (!isAddress3(vaultAddress)) {
+    if (!isAddress4(vaultAddress)) {
       console.error(chalk3.red(`Invalid vault address: ${opts.vault}`));
       process.exit(1);
     }
@@ -2754,9 +4572,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})`}`);
@@ -2765,7 +4583,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();
     }
@@ -2799,7 +4617,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");
@@ -2809,7 +4627,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 = {
@@ -2840,7 +4658,7 @@ function registerAllowanceCommands(program2) {
   });
   allowance.command("status").description("Show vault profit and agent USDC balances").requiredOption("--vault <address>", "Vault address").action(async (opts) => {
     const vaultAddress = opts.vault;
-    if (!isAddress3(vaultAddress)) {
+    if (!isAddress4(vaultAddress)) {
       console.error(chalk3.red(`Invalid vault address: ${opts.vault}`));
       process.exit(1);
     }
@@ -2876,14 +4694,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) {
@@ -2898,7 +4716,7 @@ function registerAllowanceCommands(program2) {
 import chalk4 from "chalk";
 import ora4 from "ora";
 import { SDK } from "agent0-sdk";
-var IDENTITY_REGISTRY_ABI = [
+var IDENTITY_REGISTRY_ABI2 = [
   {
     name: "balanceOf",
     type: "function",
@@ -2931,6 +4749,19 @@ function getAgent0SDK() {
 function registerIdentityCommands(program2) {
   const identity = program2.command("identity").description("Manage ERC-8004 agent identity (via Agent0 SDK)");
   identity.command("mint").description("Register a new ERC-8004 agent identity (required before creating/joining syndicates)").requiredOption("--name <name>", "Agent name (e.g. 'Alpha Seeker Agent')").option("--description <desc>", "Agent description", "Sherwood syndicate agent").option("--image <uri>", "Agent image URI (IPFS recommended)").action(async (opts) => {
+    if (isCalldataOnly()) {
+      emitCalldata(
+        encodeIdentityMint(
+          {
+            name: opts.name,
+            description: opts.description,
+            image: opts.image
+          },
+          getChain().id
+        )
+      );
+      return;
+    }
     const account = getAccount();
     const existingId = getAgentId();
     if (existingId) {
@@ -2978,7 +4809,7 @@ function registerIdentityCommands(program2) {
     try {
       const owner = await client.readContract({
         address: registry2,
-        abi: IDENTITY_REGISTRY_ABI,
+        abi: IDENTITY_REGISTRY_ABI2,
         functionName: "ownerOf",
         args: [BigInt(tokenId)]
       });
@@ -3048,7 +4879,7 @@ function registerIdentityCommands(program2) {
     try {
       const balance = await client.readContract({
         address: registry2,
-        abi: IDENTITY_REGISTRY_ABI,
+        abi: IDENTITY_REGISTRY_ABI2,
         functionName: "balanceOf",
         args: [account.address]
       });
@@ -3064,7 +4895,7 @@ function registerIdentityCommands(program2) {
         try {
           const owner = await client.readContract({
             address: registry2,
-            abi: IDENTITY_REGISTRY_ABI,
+            abi: IDENTITY_REGISTRY_ABI2,
             functionName: "ownerOf",
             args: [BigInt(savedId)]
           });
@@ -3126,60 +4957,268 @@ function registerIdentityCommands(program2) {
         console.log(`  Saved ID:   ${chalk4.dim("none \u2014 run 'sherwood identity mint --name <name>'")}`);
         console.log();
       }
-    } catch (err) {
-      spinner.fail("Failed to check identity");
-      console.error(chalk4.red(formatContractError(err)));
-      process.exit(1);
+    } catch (err) {
+      spinner.fail("Failed to check identity");
+      console.error(chalk4.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/proposal.ts
+import { isAddress as isAddress5, encodeFunctionData as encodeFunctionData18 } from "viem";
+import chalk6 from "chalk";
+import ora5 from "ora";
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/lib/format.ts
+function formatDurationShort(seconds) {
+  const s = Number(seconds);
+  if (s >= 86400) return `${(s / 86400).toFixed(s % 86400 === 0 ? 0 : 1)}d`;
+  if (s >= 3600) return `${(s / 3600).toFixed(s % 3600 === 0 ? 0 : 1)}h`;
+  if (s >= 60) return `${(s / 60).toFixed(0)}m`;
+  return `${s}s`;
+}
+function formatDurationLong(seconds) {
+  const s = Number(seconds);
+  if (s >= 86400) return `${(s / 86400).toFixed(s % 86400 === 0 ? 0 : 1)} day${s >= 172800 ? "s" : ""}`;
+  if (s >= 3600) return `${(s / 3600).toFixed(s % 3600 === 0 ? 0 : 1)} hour${s >= 7200 ? "s" : ""}`;
+  if (s >= 60) return `${(s / 60).toFixed(0)} min`;
+  return `${s}s`;
+}
+function formatShares(raw, decimals = 6) {
+  const num = Number(raw) / 10 ** decimals;
+  return num.toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: 2 });
+}
+function formatUSDC(raw) {
+  const num = Number(raw) / 1e6;
+  return `$${num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function parseBigIntArg(value, name) {
+  if (!/^-?\d+$/.test(value)) {
+    throw new Error(`Invalid ${name}: "${value}" is not a valid integer`);
+  }
+  return BigInt(value);
+}
+
+// src/lib/simulate.ts
+import { decodeFunctionData as decodeFunctionData2, encodeFunctionData as encodeFunctionData17 } from "viem";
+import chalk5 from "chalk";
+
+// src/lib/risk.ts
+import { decodeFunctionData, erc20Abi as erc20Abi2 } from "viem";
+var MOONWELL_CTOKEN_ABI = [
+  { name: "mint", type: "function", stateMutability: "nonpayable", inputs: [{ name: "mintAmount", type: "uint256" }], outputs: [{ name: "", type: "uint256" }] },
+  { name: "redeem", type: "function", stateMutability: "nonpayable", inputs: [{ name: "redeemTokens", type: "uint256" }], outputs: [{ name: "", type: "uint256" }] },
+  { name: "redeemUnderlying", type: "function", stateMutability: "nonpayable", inputs: [{ name: "redeemAmount", type: "uint256" }], outputs: [{ name: "", type: "uint256" }] },
+  { name: "borrow", type: "function", stateMutability: "nonpayable", inputs: [{ name: "borrowAmount", type: "uint256" }], outputs: [{ name: "", type: "uint256" }] },
+  { name: "repayBorrow", type: "function", stateMutability: "nonpayable", inputs: [{ name: "repayAmount", type: "uint256" }], outputs: [{ name: "", type: "uint256" }] }
+];
+var MOONWELL_COMPTROLLER_ABI = [
+  { name: "enterMarkets", type: "function", stateMutability: "nonpayable", inputs: [{ name: "mTokens", type: "address[]" }], outputs: [{ name: "", type: "uint256[]" }] },
+  { name: "exitMarket", type: "function", stateMutability: "nonpayable", inputs: [{ name: "mToken", type: "address" }], outputs: [{ name: "", type: "uint256" }] }
+];
+var SWAP_ROUTER_SINGLE_ABI = [
+  {
+    name: "exactInputSingle",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{
+      name: "params",
+      type: "tuple",
+      components: [
+        { name: "tokenIn", type: "address" },
+        { name: "tokenOut", type: "address" },
+        { name: "fee", type: "uint24" },
+        { name: "recipient", type: "address" },
+        { name: "amountIn", type: "uint256" },
+        { name: "amountOutMinimum", type: "uint256" },
+        { name: "sqrtPriceLimitX96", type: "uint160" }
+      ]
+    }],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+var SWAP_ROUTER_MULTI_ABI = [
+  {
+    name: "exactInput",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{
+      name: "params",
+      type: "tuple",
+      components: [
+        { name: "path", type: "bytes" },
+        { name: "recipient", type: "address" },
+        { name: "amountIn", type: "uint256" },
+        { name: "amountOutMinimum", type: "uint256" }
+      ]
+    }],
+    outputs: [{ name: "amountOut", type: "uint256" }]
+  }
+];
+function buildLabelMapFromKnown(known) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [label, addr] of Object.entries(known)) {
+    if (addr && addr !== "0x0000000000000000000000000000000000000000") {
+      map.set(addr.toLowerCase(), label);
+    }
+  }
+  return map;
+}
+function truncAddr(addr) {
+  return `${addr.slice(0, 6)}\u2026${addr.slice(-4)}`;
+}
+function labeledAddr(addr, labels) {
+  const label = labels.get(addr.toLowerCase());
+  return label ? `${label} (${truncAddr(addr)})` : truncAddr(addr);
+}
+function tryDecode(abi, data) {
+  try {
+    const decoded = decodeFunctionData({ abi, data });
+    return { functionName: decoded.functionName, args: decoded.args ?? [] };
+  } catch {
+    return null;
+  }
+}
+function decodeCallArgs(data) {
+  return tryDecode(erc20Abi2, data) ?? tryDecode(MOONWELL_CTOKEN_ABI, data) ?? tryDecode(MOONWELL_COMPTROLLER_ABI, data) ?? tryDecode(SWAP_ROUTER_SINGLE_ABI, data) ?? // exactInputSingle (single-hop)
+  tryDecode(SWAP_ROUTER_MULTI_ABI, data);
+}
+function analyzeRisk(calls, callResults, context) {
+  const risks = [];
+  const labels = buildLabelMapFromKnown(context?.knownAddresses ?? {});
+  const vaultLower = context?.vault?.toLowerCase();
+  const isKnown = (addr) => {
+    const lower = addr.toLowerCase();
+    return labels.has(lower) || lower === vaultLower;
+  };
+  let allTargetsVerified = calls.length > 0;
+  let allCallsDecoded = calls.length > 0;
+  for (let i = 0; i < calls.length; i++) {
+    const call = calls[i];
+    const result = callResults[i];
+    const callNum = i + 1;
+    if (result && !result.success) {
+      risks.push({
+        level: "critical",
+        code: "SIMULATION_FAILED",
+        message: `Call #${callNum} to ${labeledAddr(call.target, labels)} reverted during simulation`,
+        callIndex: i
+      });
+    }
+    const targetKnown = isKnown(call.target);
+    if (!targetKnown) {
+      allTargetsVerified = false;
+      risks.push({
+        level: "critical",
+        code: "UNKNOWN_TARGET",
+        message: `Call #${callNum} targets ${labeledAddr(call.target, labels)} which is not in the known address registry`,
+        callIndex: i
+      });
+    }
+    const decoded = decodeCallArgs(call.data);
+    if (!decoded) {
+      allCallsDecoded = false;
+      if (!targetKnown) {
+        risks.push({
+          level: "critical",
+          code: "UNDECODED_CALLDATA",
+          message: `Call #${callNum} has unrecognized calldata (selector ${call.data.slice(0, 10)}) targeting unknown contract`,
+          callIndex: i
+        });
+      }
+      continue;
+    }
+    if (decoded.functionName === "transfer" && decoded.args.length >= 2) {
+      const to = decoded.args[0];
+      if (typeof to === "string" && to.startsWith("0x") && !isKnown(to)) {
+        risks.push({
+          level: "critical",
+          code: "TRANSFER_TO_UNKNOWN",
+          message: `Call #${callNum} transfer() sends funds to ${truncAddr(to)} which is not a known protocol`,
+          callIndex: i
+        });
+      }
+    }
+    if (decoded.functionName === "transferFrom" && decoded.args.length >= 3) {
+      const to = decoded.args[1];
+      if (typeof to === "string" && to.startsWith("0x") && !isKnown(to)) {
+        risks.push({
+          level: "critical",
+          code: "TRANSFER_FROM_TO_UNKNOWN",
+          message: `Call #${callNum} transferFrom() sends funds to ${truncAddr(to)} which is not a known protocol`,
+          callIndex: i
+        });
+      }
+    }
+    if (decoded.functionName === "approve" && decoded.args.length >= 2) {
+      const spender = decoded.args[0];
+      if (typeof spender === "string" && spender.startsWith("0x") && !isKnown(spender)) {
+        risks.push({
+          level: "critical",
+          code: "APPROVE_TO_UNKNOWN",
+          message: `Call #${callNum} approve() grants allowance to ${truncAddr(spender)} which is not a known protocol`,
+          callIndex: i
+        });
+      }
     }
-  });
-}
-
-// src/commands/proposal.ts
-import { isAddress as isAddress4, encodeFunctionData as encodeFunctionData11 } from "viem";
-import chalk6 from "chalk";
-import ora5 from "ora";
-import { readFileSync as readFileSync2 } from "fs";
-
-// src/lib/format.ts
-function formatDurationShort(seconds) {
-  const s = Number(seconds);
-  if (s >= 86400) return `${(s / 86400).toFixed(s % 86400 === 0 ? 0 : 1)}d`;
-  if (s >= 3600) return `${(s / 3600).toFixed(s % 3600 === 0 ? 0 : 1)}h`;
-  if (s >= 60) return `${(s / 60).toFixed(0)}m`;
-  return `${s}s`;
-}
-function formatDurationLong(seconds) {
-  const s = Number(seconds);
-  if (s >= 86400) return `${(s / 86400).toFixed(s % 86400 === 0 ? 0 : 1)} day${s >= 172800 ? "s" : ""}`;
-  if (s >= 3600) return `${(s / 3600).toFixed(s % 3600 === 0 ? 0 : 1)} hour${s >= 7200 ? "s" : ""}`;
-  if (s >= 60) return `${(s / 60).toFixed(0)} min`;
-  return `${s}s`;
-}
-function formatShares(raw, decimals = 6) {
-  const num = Number(raw) / 10 ** decimals;
-  return num.toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: 2 });
-}
-function formatUSDC(raw) {
-  const num = Number(raw) / 1e6;
-  return `$${num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
-}
-function parseBigIntArg(value, name) {
-  if (!/^-?\d+$/.test(value)) {
-    throw new Error(`Invalid ${name}: "${value}" is not a valid integer`);
   }
-  return BigInt(value);
+  if (context?.performanceFeeBps !== void 0) {
+    const fee = context.performanceFeeBps;
+    const maxFee = context.governorParams?.maxPerformanceFeeBps;
+    if (maxFee !== void 0 && fee > maxFee * 80n / 100n) {
+      risks.push({
+        level: "critical",
+        code: "EXCESSIVE_PERFORMANCE_FEE",
+        message: `Performance fee ${Number(fee) / 100}% is within 20% of the hard cap (${Number(maxFee) / 100}%)`
+      });
+    } else if (fee > 2000n) {
+      risks.push({
+        level: "warning",
+        code: "HIGH_PERFORMANCE_FEE",
+        message: `Performance fee ${Number(fee) / 100}% exceeds 20% threshold`
+      });
+    }
+  }
+  if (context?.strategyDuration !== void 0) {
+    const dur = context.strategyDuration;
+    if (dur < 3600n) {
+      risks.push({
+        level: "warning",
+        code: "SHORT_STRATEGY_DURATION",
+        message: `Strategy duration ${Number(dur)}s is under 1 hour \u2014 flash-loan-style risk`
+      });
+    }
+    if (dur > 2592000n) {
+      risks.push({
+        level: "warning",
+        code: "LONG_STRATEGY_DURATION",
+        message: `Strategy duration ${Number(dur) / 86400} days exceeds 30-day threshold`
+      });
+    }
+  }
+  const hasCritical = risks.some((r) => r.level === "critical");
+  const hasWarning = risks.some((r) => r.level === "warning");
+  if (!hasCritical && !hasWarning) {
+    if (allTargetsVerified) {
+      risks.push({ level: "info", code: "ALL_TARGETS_VERIFIED", message: "All call targets are verified protocol addresses" });
+    }
+    if (allCallsDecoded) {
+      risks.push({ level: "info", code: "ALL_CALLS_DECODED", message: "All calldata successfully decoded" });
+    }
+  }
+  return risks;
 }
 
 // src/lib/simulate.ts
-import { decodeFunctionData, encodeFunctionData as encodeFunctionData10 } from "viem";
-import chalk5 from "chalk";
 var G = chalk5.green;
 var W = chalk5.white;
 var DIM = chalk5.gray;
 var BOLD = chalk5.white.bold;
 var LABEL = chalk5.green.bold;
 var SEP = () => console.log(DIM("\u2500".repeat(60)));
-var MOONWELL_CTOKEN_ABI = [
+var MOONWELL_CTOKEN_ABI2 = [
   {
     name: "mint",
     type: "function",
@@ -3216,7 +5255,7 @@ var MOONWELL_CTOKEN_ABI = [
     outputs: [{ name: "", type: "uint256" }]
   }
 ];
-var MOONWELL_COMPTROLLER_ABI = [
+var MOONWELL_COMPTROLLER_ABI2 = [
   {
     name: "enterMarkets",
     type: "function",
@@ -3232,7 +5271,7 @@ var MOONWELL_COMPTROLLER_ABI = [
     outputs: [{ name: "", type: "uint256" }]
   }
 ];
-var SWAP_ROUTER_SINGLE_ABI = [
+var SWAP_ROUTER_SINGLE_ABI2 = [
   {
     name: "exactInputSingle",
     type: "function",
@@ -3337,10 +5376,7 @@ function getAddressLabel(addr) {
   const labels = buildLabelMap();
   return labels.get(addr.toLowerCase()) ?? null;
 }
-function truncAddr(addr) {
-  return `${addr.slice(0, 6)}...${addr.slice(-4)}`;
-}
-function labeledAddr(addr) {
+function labeledAddr2(addr) {
   const label = buildLabelMap().get(addr.toLowerCase());
   const short = truncAddr(addr);
   return label ? `${short} (${label})` : short;
@@ -3378,21 +5414,21 @@ function decodeCallData(target, data) {
   if (mw) {
     const isMToken = [mw.mUSDC, mw.mWETH, mw.mCbETH, mw.mWstETH, mw.mCbBTC, mw.mDAI, mw.mAERO].some((a) => a.toLowerCase() === targetLower);
     if (isMToken) {
-      candidates.push({ abi: MOONWELL_CTOKEN_ABI, context: labels.get(targetLower) || "mToken" });
+      candidates.push({ abi: MOONWELL_CTOKEN_ABI2, context: labels.get(targetLower) || "mToken" });
     }
     if (mw.COMPTROLLER.toLowerCase() === targetLower) {
-      candidates.push({ abi: MOONWELL_COMPTROLLER_ABI, context: "Comptroller" });
+      candidates.push({ abi: MOONWELL_COMPTROLLER_ABI2, context: "Comptroller" });
     }
   }
   const uni = safeCall(() => UNISWAP());
   if (uni && uni.SWAP_ROUTER.toLowerCase() === targetLower) {
     candidates.push({ abi: SWAP_ROUTER_ABI, context: "SwapRouter" });
-    candidates.push({ abi: SWAP_ROUTER_SINGLE_ABI, context: "SwapRouter" });
+    candidates.push({ abi: SWAP_ROUTER_SINGLE_ABI2, context: "SwapRouter" });
   }
   candidates.push({ abi: ERC20_ABI, context: labels.get(targetLower) || "ERC20" });
   for (const { abi, context } of candidates) {
     try {
-      const decoded = decodeFunctionData({
+      const decoded = decodeFunctionData2({
         abi,
         data
       });
@@ -3411,7 +5447,7 @@ function formatArgs(args, functionName, target) {
     if (typeof arg === "bigint") {
       parts.push(formatTokenAmount(arg, target));
     } else if (typeof arg === "string" && arg.startsWith("0x") && arg.length === 42) {
-      parts.push(labeledAddr(arg));
+      parts.push(labeledAddr2(arg));
     } else if (typeof arg === "object" && arg !== null && !Array.isArray(arg)) {
       const entries = Object.entries(arg);
       const structParts = [];
@@ -3419,7 +5455,7 @@ function formatArgs(args, functionName, target) {
         if (typeof val === "bigint") {
           structParts.push(`${key}: ${formatTokenAmount(val, target)}`);
         } else if (typeof val === "string" && val.startsWith("0x") && val.length === 42) {
-          structParts.push(`${key}: ${labeledAddr(val)}`);
+          structParts.push(`${key}: ${labeledAddr2(val)}`);
         } else if (typeof val === "string" && val.startsWith("0x") && key === "path") {
           structParts.push(`path: ${decodeUniswapPath(val)}`);
         } else {
@@ -3430,7 +5466,7 @@ function formatArgs(args, functionName, target) {
     } else if (Array.isArray(arg)) {
       const arrParts = arg.map((item) => {
         if (typeof item === "string" && item.startsWith("0x") && item.length === 42) {
-          return labeledAddr(item);
+          return labeledAddr2(item);
         }
         return String(item);
       });
@@ -3462,168 +5498,9 @@ function decodeUniswapPath(pathHex) {
 function safeCall(fn) {
   try {
     return fn();
-  } catch {
-    return null;
-  }
-}
-function decodeCallArgs(target, data) {
-  if (data.length < 10) return null;
-  const targetLower = target.toLowerCase();
-  const candidates = [];
-  const mw = safeCall(() => MOONWELL());
-  if (mw) {
-    const isMToken = [mw.mUSDC, mw.mWETH, mw.mCbETH, mw.mWstETH, mw.mCbBTC, mw.mDAI, mw.mAERO].some((a) => a.toLowerCase() === targetLower);
-    if (isMToken) candidates.push({ abi: MOONWELL_CTOKEN_ABI });
-    if (mw.COMPTROLLER.toLowerCase() === targetLower) candidates.push({ abi: MOONWELL_COMPTROLLER_ABI });
-  }
-  const uni = safeCall(() => UNISWAP());
-  if (uni && uni.SWAP_ROUTER.toLowerCase() === targetLower) {
-    candidates.push({ abi: SWAP_ROUTER_ABI });
-    candidates.push({ abi: SWAP_ROUTER_SINGLE_ABI });
-  }
-  candidates.push({ abi: ERC20_ABI });
-  for (const { abi } of candidates) {
-    try {
-      const decoded = decodeFunctionData({ abi, data });
-      return { functionName: decoded.functionName, args: decoded.args };
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-function analyzeRisk(calls, callResults, context) {
-  const risks = [];
-  const labels = buildLabelMap();
-  const vaultLower = context?.vault?.toLowerCase();
-  const isKnown = (addr) => {
-    const lower = addr.toLowerCase();
-    return labels.has(lower) || lower === vaultLower;
-  };
-  let allTargetsVerified = true;
-  let allCallsDecoded = true;
-  for (let i = 0; i < calls.length; i++) {
-    const call = calls[i];
-    const result = callResults[i];
-    const callNum = i + 1;
-    if (result && !result.success) {
-      risks.push({
-        level: "critical",
-        code: "SIMULATION_FAILED",
-        message: `Call #${callNum} to ${labeledAddr(call.target)} reverted during simulation`,
-        callIndex: i
-      });
-    }
-    const targetKnown = isKnown(call.target);
-    if (!targetKnown) {
-      allTargetsVerified = false;
-      risks.push({
-        level: "critical",
-        code: "UNKNOWN_TARGET",
-        message: `Call #${callNum} targets ${labeledAddr(call.target)} which is not in the known address registry`,
-        callIndex: i
-      });
-    }
-    const decoded = decodeCallArgs(call.target, call.data);
-    if (!decoded) {
-      allCallsDecoded = false;
-      if (!targetKnown) {
-        risks.push({
-          level: "critical",
-          code: "UNDECODED_CALLDATA",
-          message: `Call #${callNum} has unrecognized calldata (selector ${call.data.slice(0, 10)}) targeting unknown contract`,
-          callIndex: i
-        });
-      }
-      continue;
-    }
-    if (decoded.functionName === "transfer" && decoded.args.length >= 2) {
-      const to = decoded.args[0];
-      if (typeof to === "string" && to.startsWith("0x") && !isKnown(to)) {
-        risks.push({
-          level: "critical",
-          code: "TRANSFER_TO_UNKNOWN",
-          message: `Call #${callNum} transfer() sends funds to ${truncAddr(to)} which is not a known protocol`,
-          callIndex: i
-        });
-      }
-    }
-    if (decoded.functionName === "transferFrom" && decoded.args.length >= 3) {
-      const to = decoded.args[1];
-      if (typeof to === "string" && to.startsWith("0x") && !isKnown(to)) {
-        risks.push({
-          level: "critical",
-          code: "TRANSFER_FROM_TO_UNKNOWN",
-          message: `Call #${callNum} transferFrom() sends funds to ${truncAddr(to)} which is not a known protocol`,
-          callIndex: i
-        });
-      }
-    }
-    if (decoded.functionName === "approve" && decoded.args.length >= 2) {
-      const spender = decoded.args[0];
-      if (typeof spender === "string" && spender.startsWith("0x") && !isKnown(spender)) {
-        risks.push({
-          level: "critical",
-          code: "APPROVE_TO_UNKNOWN",
-          message: `Call #${callNum} approve() grants allowance to ${truncAddr(spender)} which is not a known protocol`,
-          callIndex: i
-        });
-      }
-    }
-  }
-  if (context?.performanceFeeBps !== void 0) {
-    const fee = context.performanceFeeBps;
-    const maxFee = context.governorParams?.maxPerformanceFeeBps;
-    if (maxFee && fee > maxFee * 80n / 100n) {
-      risks.push({
-        level: "critical",
-        code: "EXCESSIVE_PERFORMANCE_FEE",
-        message: `Performance fee ${Number(fee) / 100}% is within 20% of the hard cap (${Number(maxFee) / 100}%)`
-      });
-    } else if (fee > 2000n) {
-      risks.push({
-        level: "warning",
-        code: "HIGH_PERFORMANCE_FEE",
-        message: `Performance fee ${Number(fee) / 100}% exceeds 20% threshold`
-      });
-    }
-  }
-  if (context?.strategyDuration !== void 0) {
-    const dur = context.strategyDuration;
-    if (dur < 3600n) {
-      risks.push({
-        level: "warning",
-        code: "SHORT_STRATEGY_DURATION",
-        message: `Strategy duration ${Number(dur)}s is under 1 hour \u2014 flash-loan-style risk`
-      });
-    }
-    if (dur > 2592000n) {
-      risks.push({
-        level: "warning",
-        code: "LONG_STRATEGY_DURATION",
-        message: `Strategy duration ${Number(dur) / 86400} days exceeds 30-day threshold`
-      });
-    }
-  }
-  const hasCritical = risks.some((r) => r.level === "critical");
-  const hasWarning = risks.some((r) => r.level === "warning");
-  if (!hasCritical && !hasWarning) {
-    if (allTargetsVerified) {
-      risks.push({
-        level: "info",
-        code: "ALL_TARGETS_VERIFIED",
-        message: "All call targets are verified protocol addresses"
-      });
-    }
-    if (allCallsDecoded) {
-      risks.push({
-        level: "info",
-        code: "ALL_CALLS_DECODED",
-        message: "All calldata successfully decoded"
-      });
-    }
+  } catch {
+    return null;
   }
-  return risks;
 }
 var API_URLS = {
   "base": "https://app.sherwood.sh",
@@ -3674,7 +5551,7 @@ async function simulateViaApi(vault, calls) {
   const warnings = [];
   for (const cr of callResults) {
     if (!cr.success) {
-      warnings.push(`Call #${cr.index + 1} to ${labeledAddr(cr.target)} failed`);
+      warnings.push(`Call #${cr.index + 1} to ${labeledAddr2(cr.target)} failed`);
     }
   }
   return {
@@ -3690,7 +5567,7 @@ async function simulateViaApi(vault, calls) {
 async function simulateViaEthCall(vault, calls) {
   const governor = getGovernorAddress();
   const client = getPublicClient();
-  const input2 = encodeFunctionData10({
+  const input2 = encodeFunctionData17({
     abi: SYNDICATE_VAULT_ABI,
     functionName: "executeGovernorBatch",
     args: [calls.map((c) => ({ target: c.target, data: c.data, value: c.value }))]
@@ -3743,7 +5620,12 @@ async function simulateBatchCalls(vault, calls, callType, riskContext) {
     console.log(DIM(`  Simulation API unavailable (${message}), falling back to eth_call...`));
     result = await simulateViaEthCall(vault, calls);
   }
-  const ctx = { vault, ...riskContext };
+  const inlineLabels = buildLabelMap();
+  const knownAddresses = {};
+  for (const [addr, label] of inlineLabels) {
+    knownAddresses[label] = addr;
+  }
+  const ctx = { vault, ...riskContext, knownAddresses };
   result.risks = analyzeRisk(calls, result.callResults, ctx);
   return result;
 }
@@ -3916,10 +5798,10 @@ function parseCallsFile(path) {
 }
 function registerProposalCommands(program2) {
   const proposal = program2.command("proposal").description("Governance proposals \u2014 create, vote, execute, settle");
-  proposal.command("create").description("Submit a strategy proposal").requiredOption("--vault <address>", "Vault address the proposal targets").requiredOption("--name <name>", "Strategy name").requiredOption("--description <text>", "Strategy rationale and risk summary").requiredOption("--performance-fee <bps>", "Agent fee in bps (e.g. 1500 = 15%)").requiredOption("--duration <duration>", "Strategy duration (e.g. 7d, 24h, 3600)").requiredOption("--execute-calls <path>", "Path to JSON file with execute Call[] array").requiredOption("--settle-calls <path>", "Path to JSON file with settlement Call[] array").option("--metadata-uri <uri>", "Override \u2014 skip IPFS upload and use this URI directly").option("--simulate", "Simulate calls via Tenderly before submitting").option("--force", "Submit even if simulation fails (requires --simulate)").action(async (opts) => {
+  proposal.command("create").description("Submit a strategy proposal").requiredOption("--vault <address>", "Vault address the proposal targets").requiredOption("--name <name>", "Strategy name").requiredOption("--description <text>", "Strategy rationale and risk summary").requiredOption("--performance-fee <bps>", "Agent fee in bps (e.g. 1500 = 15%)").requiredOption("--duration <duration>", "Strategy duration (e.g. 7d, 24h, 3600)").requiredOption("--execute-calls <path>", "Path to JSON file with execute Call[] array").requiredOption("--settle-calls <path>", "Path to JSON file with settlement Call[] array").option("--strategy <address>", "Live-NAV strategy clone address (default: none \u2014 queue-only)").option("--metadata-uri <uri>", "Override \u2014 skip IPFS upload and use this URI directly").option("--simulate", "Simulate calls via Tenderly before submitting").option("--force", "Submit even if simulation fails (requires --simulate)").action(async (opts) => {
     try {
       const vault = opts.vault;
-      if (!isAddress4(vault)) {
+      if (!isAddress5(vault)) {
         console.error(chalk6.red(`Invalid vault address: ${opts.vault}`));
         process.exit(1);
       }
@@ -3927,6 +5809,45 @@ function registerProposalCommands(program2) {
       const strategyDuration = parseDuration(opts.duration);
       const executeCalls = parseCallsFile(opts.executeCalls);
       const settleCalls = parseCallsFile(opts.settleCalls);
+      const ZERO_STRATEGY = "0x0000000000000000000000000000000000000000";
+      let strategy2 = ZERO_STRATEGY;
+      if (opts.strategy) {
+        if (!isAddress5(opts.strategy)) {
+          console.error(chalk6.red(`Invalid strategy address: ${opts.strategy}`));
+          process.exit(1);
+        }
+        strategy2 = opts.strategy;
+      }
+      if (isCalldataOnly()) {
+        if (!opts.metadataUri) {
+          console.error(
+            chalk6.red(
+              "--calldata-only requires --metadata-uri (IPFS metadata upload needs a signing wallet)"
+            )
+          );
+          process.exit(1);
+        }
+        try {
+          emitCalldata(
+            encodePropose(
+              {
+                vault,
+                strategy: strategy2,
+                metadataURI: opts.metadataUri,
+                performanceFeeBps: Number(performanceFeeBps),
+                strategyDuration,
+                executeCalls,
+                settlementCalls: settleCalls
+              },
+              getChain().id
+            )
+          );
+        } catch (err) {
+          console.error(chalk6.red(err instanceof Error ? err.message : String(err)));
+          process.exit(1);
+        }
+        return;
+      }
       let metadataURI = opts.metadataUri || "";
       if (!metadataURI) {
         const spinner2 = ora5({ text: W2("Uploading metadata to IPFS..."), color: "green" }).start();
@@ -4001,7 +5922,7 @@ function registerProposalCommands(program2) {
       const spinner = ora5({ text: W2("Submitting proposal..."), color: "green" }).start();
       const result = await propose(
         vault,
-        "0x0000000000000000000000000000000000000000",
+        strategy2,
         metadataURI,
         performanceFeeBps,
         strategyDuration,
@@ -4157,6 +6078,11 @@ function registerProposalCommands(program2) {
         console.error(chalk6.red(`Invalid support value "${opts.support}". Use for|against|abstain.`));
         process.exit(1);
       }
+      if (isCalldataOnly()) {
+        const voteDir = support === VOTE_TYPE.For ? "For" : support === VOTE_TYPE.Against ? "Against" : "Abstain";
+        emitCalldata(encodeVote({ proposalId, vote: voteDir }, getChain().id));
+        return;
+      }
       const account = getAccount();
       const spinner = ora5("Loading proposal...").start();
       const p = await getProposal(proposalId);
@@ -4196,6 +6122,10 @@ function registerProposalCommands(program2) {
   proposal.command("execute").description("Execute an approved proposal").requiredOption("--id <proposalId>", "Proposal ID").option("--dry-run", "Simulate execution without sending a transaction").action(async (opts) => {
     try {
       const proposalId = parseBigIntArg(opts.id, "proposal ID");
+      if (isCalldataOnly()) {
+        emitCalldata(encodeExecute({ proposalId }, getChain().id));
+        return;
+      }
       const spinner = ora5("Loading proposal...").start();
       const state = await getProposalState(proposalId);
       if (state !== PROPOSAL_STATE.Approved) {
@@ -4236,6 +6166,17 @@ function registerProposalCommands(program2) {
   proposal.command("settle").description("Settle an executed proposal (auto-routes settlement path)").requiredOption("--id <proposalId>", "Proposal ID").option("--calls <path>", "Path to JSON file with settle Call[] (for agent/emergency settle)").action(async (opts) => {
     try {
       const proposalId = parseBigIntArg(opts.id, "proposal ID");
+      if (isCalldataOnly()) {
+        if (opts.calls) {
+          const calls = parseCallsFile(opts.calls);
+          emitCalldata(
+            encodeEmergencySettle({ proposalId, calls }, getChain().id)
+          );
+        } else {
+          emitCalldata(encodeSettle({ proposalId }, getChain().id));
+        }
+        return;
+      }
       const account = getAccount();
       const spinner = ora5("Loading proposal...").start();
       const p = await getProposal(proposalId);
@@ -4281,6 +6222,10 @@ function registerProposalCommands(program2) {
   ).action(async (opts) => {
     try {
       const proposalId = parseBigIntArg(opts.id, "proposal ID");
+      if (isCalldataOnly()) {
+        emitCalldata(encodeUnstick({ proposalId }, getChain().id));
+        return;
+      }
       const account = getAccount();
       const spinner = ora5("Loading proposal...").start();
       const p = await getProposal(proposalId);
@@ -4330,7 +6275,7 @@ function registerProposalCommands(program2) {
         process.exit(1);
       }
       const asset = await getAssetAddress();
-      const noopCalldata = encodeFunctionData11({
+      const noopCalldata = encodeFunctionData18({
         abi: ERC20_ABI,
         functionName: "balanceOf",
         args: [vault]
@@ -4400,6 +6345,10 @@ function registerProposalCommands(program2) {
   proposal.command("cancel").description("Cancel a proposal (proposer or vault owner)").requiredOption("--id <proposalId>", "Proposal ID").option("--emergency", "Emergency cancel (vault owner only, any non-settled state)").action(async (opts) => {
     try {
       const proposalId = parseBigIntArg(opts.id, "proposal ID");
+      if (isCalldataOnly()) {
+        emitCalldata(encodeCancel({ proposalId }, getChain().id));
+        return;
+      }
       const spinner = ora5("Loading proposal...").start();
       const state = await getProposalState(proposalId);
       if (state === PROPOSAL_STATE.Settled || state === PROPOSAL_STATE.Cancelled) {
@@ -4474,7 +6423,7 @@ function registerProposalCommands(program2) {
         console.log(DIM2(`
   Simulating proposal #${proposalId} on vault ${vault.slice(0, 10)}...`));
       } else if (opts.executeCalls) {
-        if (!opts.vault || !isAddress4(opts.vault)) {
+        if (!opts.vault || !isAddress5(opts.vault)) {
           console.error(chalk6.red("\n  \u2716 --vault is required when using --execute-calls"));
           process.exit(1);
         }
@@ -4525,6 +6474,33 @@ var DIM3 = chalk7.gray;
 var BOLD3 = chalk7.white.bold;
 var LABEL3 = chalk7.green.bold;
 var SEP3 = () => console.log(DIM3("\u2500".repeat(60)));
+function registerParamSetter(governor, spec) {
+  governor.command(spec.command).description(spec.description).requiredOption(spec.flag, spec.flagDescription).action(async (opts) => {
+    const rawValue = String(opts[spec.valueLabel]);
+    if (isCalldataOnly()) {
+      try {
+        const value = parseBigIntArg(rawValue, spec.valueLabel);
+        emitCalldata(
+          encodeGovernorParam({ param: spec.param, value }, getChain().id)
+        );
+      } catch (err) {
+        console.error(chalk7.red(formatContractError(err)));
+        process.exit(1);
+      }
+      return;
+    }
+    const spinner = ora6(spec.spinnerText).start();
+    try {
+      const hash = await spec.setter(parseBigIntArg(rawValue, spec.valueLabel));
+      spinner.succeed(G3(spec.succeed(rawValue)));
+      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
+    } catch (err) {
+      spinner.fail(spec.failText);
+      console.error(chalk7.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+}
 function registerGovernorCommands(program2) {
   const governor = program2.command("governor").description("Governor parameters and vault management");
   governor.command("info").description("Display current governor parameters and registered vaults").action(async () => {
@@ -4562,96 +6538,96 @@ function registerGovernorCommands(program2) {
       process.exit(1);
     }
   });
-  governor.command("set-voting-period").description("Set the voting period (owner only)").requiredOption("--seconds <n>", "New voting period in seconds").action(async (opts) => {
-    const spinner = ora6("Setting voting period...").start();
-    try {
-      const hash = await setVotingPeriod(parseBigIntArg(opts.seconds, "seconds"));
-      spinner.succeed(G3(`Voting period change queued (${opts.seconds}s). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set voting period");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-voting-period",
+    description: "Set the voting period (owner only)",
+    flag: "--seconds <n>",
+    flagDescription: "New voting period in seconds",
+    valueLabel: "seconds",
+    param: "votingPeriod",
+    setter: setVotingPeriod,
+    spinnerText: "Setting voting period...",
+    succeed: (v) => `Voting period updated to ${v}s (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set voting period"
   });
-  governor.command("set-execution-window").description("Set the execution window (owner only)").requiredOption("--seconds <n>", "New execution window in seconds").action(async (opts) => {
-    const spinner = ora6("Setting execution window...").start();
-    try {
-      const hash = await setExecutionWindow(parseBigIntArg(opts.seconds, "seconds"));
-      spinner.succeed(G3(`Execution window change queued (${opts.seconds}s). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set execution window");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-execution-window",
+    description: "Set the execution window (owner only)",
+    flag: "--seconds <n>",
+    flagDescription: "New execution window in seconds",
+    valueLabel: "seconds",
+    param: "executionWindow",
+    setter: setExecutionWindow,
+    spinnerText: "Setting execution window...",
+    succeed: (v) => `Execution window updated to ${v}s (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set execution window"
   });
-  governor.command("set-veto-threshold").description("Set the veto threshold in bps (owner only)").requiredOption("--bps <n>", "New veto threshold in bps (e.g. 4000 = 40%)").action(async (opts) => {
-    const spinner = ora6("Setting veto threshold...").start();
-    try {
-      const hash = await setVetoThresholdBps(parseBigIntArg(opts.bps, "bps"));
-      spinner.succeed(G3(`Veto threshold change queued (${Number(opts.bps) / 100}%). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set veto threshold");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-veto-threshold",
+    description: "Set the veto threshold in bps (owner only)",
+    flag: "--bps <n>",
+    flagDescription: "New veto threshold in bps (e.g. 4000 = 40%)",
+    valueLabel: "bps",
+    param: "vetoThresholdBps",
+    setter: setVetoThresholdBps,
+    spinnerText: "Setting veto threshold...",
+    succeed: (v) => `Veto threshold updated to ${Number(v) / 100}% (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set veto threshold"
   });
-  governor.command("set-max-fee").description("Set the max performance fee in bps (owner only)").requiredOption("--bps <n>", "New max fee in bps (e.g. 3000 = 30%)").action(async (opts) => {
-    const spinner = ora6("Setting max fee...").start();
-    try {
-      const hash = await setMaxPerformanceFeeBps(parseBigIntArg(opts.bps, "bps"));
-      spinner.succeed(G3(`Max performance fee change queued (${Number(opts.bps) / 100}%). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set max fee");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-max-fee",
+    description: "Set the max performance fee in bps (owner only)",
+    flag: "--bps <n>",
+    flagDescription: "New max fee in bps (e.g. 3000 = 30%)",
+    valueLabel: "bps",
+    param: "maxPerformanceFeeBps",
+    setter: setMaxPerformanceFeeBps,
+    spinnerText: "Setting max fee...",
+    succeed: (v) => `Max performance fee updated to ${Number(v) / 100}% (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set max fee"
   });
-  governor.command("set-max-duration").description("Set the max strategy duration in seconds (owner only)").requiredOption("--seconds <n>", "New max duration in seconds").action(async (opts) => {
-    const spinner = ora6("Setting max duration...").start();
-    try {
-      const hash = await setMaxStrategyDuration(parseBigIntArg(opts.seconds, "seconds"));
-      spinner.succeed(G3(`Max strategy duration change queued (${opts.seconds}s). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set max duration");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-max-duration",
+    description: "Set the max strategy duration in seconds (owner only)",
+    flag: "--seconds <n>",
+    flagDescription: "New max duration in seconds",
+    valueLabel: "seconds",
+    param: "maxStrategyDuration",
+    setter: setMaxStrategyDuration,
+    spinnerText: "Setting max duration...",
+    succeed: (v) => `Max strategy duration updated to ${v}s (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set max duration"
   });
-  governor.command("set-cooldown").description("Set the cooldown period in seconds (owner only)").requiredOption("--seconds <n>", "New cooldown in seconds").action(async (opts) => {
-    const spinner = ora6("Setting cooldown...").start();
-    try {
-      const hash = await setCooldownPeriod(parseBigIntArg(opts.seconds, "seconds"));
-      spinner.succeed(G3(`Cooldown period change queued (${opts.seconds}s). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set cooldown");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-cooldown",
+    description: "Set the cooldown period in seconds (owner only)",
+    flag: "--seconds <n>",
+    flagDescription: "New cooldown in seconds",
+    valueLabel: "seconds",
+    param: "cooldownPeriod",
+    setter: setCooldownPeriod,
+    spinnerText: "Setting cooldown...",
+    succeed: (v) => `Cooldown period updated to ${v}s (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set cooldown"
   });
-  governor.command("set-protocol-fee").description("Set the protocol fee in bps (owner only)").requiredOption("--bps <n>", "New protocol fee in bps (e.g. 500 = 5%, max 1000 = 10%)").action(async (opts) => {
-    const spinner = ora6("Setting protocol fee...").start();
-    try {
-      const hash = await setProtocolFeeBps(parseBigIntArg(opts.bps, "bps"));
-      spinner.succeed(G3(`Protocol fee change queued (${Number(opts.bps) / 100}%). Finalize after the timelock delay with \`sherwood governor finalize-param\`.`));
-      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
-    } catch (err) {
-      spinner.fail("Failed to set protocol fee");
-      console.error(chalk7.red(formatContractError(err)));
-      process.exit(1);
-    }
+  registerParamSetter(governor, {
+    command: "set-protocol-fee",
+    description: "Set the protocol fee in bps (owner only)",
+    flag: "--bps <n>",
+    flagDescription: "New protocol fee in bps (e.g. 500 = 5%, max 1000 = 10%)",
+    valueLabel: "bps",
+    param: "protocolFeeBps",
+    setter: setProtocolFeeBps,
+    spinnerText: "Setting protocol fee...",
+    succeed: (v) => `Protocol fee updated to ${Number(v) / 100}% (owner-instant \u2014 the owner multisig enforces its own delay).`,
+    failText: "Failed to set protocol fee"
   });
 }
 
 // src/commands/guardian-delegate.ts
 import chalk8 from "chalk";
 import ora7 from "ora";
-import { formatUnits as formatUnits4, isAddress as isAddress5, parseUnits as parseUnits5 } from "viem";
+import { formatUnits as formatUnits5, isAddress as isAddress6, parseUnits as parseUnits5 } from "viem";
 var G4 = chalk8.green;
 var W4 = chalk8.white;
 var DIM4 = chalk8.gray;
@@ -4659,7 +6635,7 @@ var BOLD4 = chalk8.white.bold;
 var LABEL4 = chalk8.green.bold;
 var WARN = chalk8.yellow;
 var SEP4 = () => console.log(DIM4("\u2500".repeat(60)));
-var GUARDIAN_REGISTRY_ABI = [
+var GUARDIAN_REGISTRY_ABI2 = [
   // Guardian stake
   { type: "function", name: "stakeAsGuardian", inputs: [{ type: "uint256" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
   { type: "function", name: "requestUnstakeGuardian", inputs: [], outputs: [], stateMutability: "nonpayable" },
@@ -4682,7 +6658,7 @@ var GUARDIAN_REGISTRY_ABI = [
   { type: "function", name: "claimProposalReward", inputs: [{ type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
   { type: "function", name: "claimDelegatorProposalReward", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" }
 ];
-var ERC20_ABI2 = [
+var ERC20_ABI3 = [
   { type: "function", name: "approve", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" },
   { type: "function", name: "balanceOf", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
   { type: "function", name: "decimals", inputs: [], outputs: [{ type: "uint8" }], stateMutability: "view" }
@@ -4715,7 +6691,7 @@ async function ensureWoodAllowance(amount) {
   try {
     const hash = await wallet.writeContract({
       address: wood(),
-      abi: ERC20_ABI2,
+      abi: ERC20_ABI3,
       functionName: "approve",
       args: [registry(), 2n ** 256n - 1n],
       chain: null,
@@ -4734,7 +6710,7 @@ function registerGuardianCommands(program2) {
     const pc = getPublicClient();
     let target;
     if (addressArg) {
-      if (!isAddress5(addressArg)) {
+      if (!isAddress6(addressArg)) {
         console.error(chalk8.red("Invalid address"));
         process.exit(1);
       }
@@ -4746,13 +6722,13 @@ function registerGuardianCommands(program2) {
     const spinner = ora7("Loading...").start();
     try {
       const [stake, active, commission] = await Promise.all([
-        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "guardianStake", args: [target] }),
-        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "isActiveGuardian", args: [target] }),
-        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "commissionOf", args: [target] })
+        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "guardianStake", args: [target] }),
+        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "isActiveGuardian", args: [target] }),
+        pc.readContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "commissionOf", args: [target] })
       ]);
       const delegatedIn = await pc.readContract({
         address: registry(),
-        abi: GUARDIAN_REGISTRY_ABI,
+        abi: GUARDIAN_REGISTRY_ABI2,
         functionName: "delegatedInbound",
         args: [target]
       });
@@ -4762,8 +6738,8 @@ function registerGuardianCommands(program2) {
       SEP4();
       console.log(W4(`  Address:              ${G4(target)}`));
       console.log(W4(`  Active guardian:      ${active ? G4("yes") : DIM4("no")}`));
-      console.log(W4(`  Own stake:            ${BOLD4(formatUnits4(stake, 18))} WOOD`));
-      console.log(W4(`  Delegated inbound:    ${BOLD4(formatUnits4(delegatedIn, 18))} WOOD`));
+      console.log(W4(`  Own stake:            ${BOLD4(formatUnits5(stake, 18))} WOOD`));
+      console.log(W4(`  Delegated inbound:    ${BOLD4(formatUnits5(delegatedIn, 18))} WOOD`));
       console.log(W4(`  Commission:           ${BOLD4(`${Number(commission) / 100}%`)}`));
       SEP4();
       console.log();
@@ -4776,6 +6752,10 @@ function registerGuardianCommands(program2) {
   guardian.command("stake <amount>").description("Stake as a guardian. Amount in WOOD (min = registry.minGuardianStake).").option("--agent-id <id>", "ERC-8004 agent ID to associate (first-stake only)", "0").action(async (amountStr, opts) => {
     const amount = parseUnits5(amountStr, 18);
     const agentId = BigInt(opts.agentId);
+    if (isCalldataOnly()) {
+      emitCalldata(encodeGuardianStake({ amount, agentId: opts.agentId }, getChain().id));
+      return;
+    }
     await ensureWoodAllowance(amount);
     const wallet = getWalletClient();
     const pc = getPublicClient();
@@ -4783,7 +6763,7 @@ function registerGuardianCommands(program2) {
     try {
       const hash = await wallet.writeContract({
         address: registry(),
-        abi: GUARDIAN_REGISTRY_ABI,
+        abi: GUARDIAN_REGISTRY_ABI2,
         functionName: "stakeAsGuardian",
         args: [amount, agentId],
         chain: null,
@@ -4803,11 +6783,15 @@ function registerGuardianCommands(program2) {
       console.error(chalk8.red(`Unknown action '${action}'. Use request | cancel | claim.`));
       process.exit(1);
     }
+    if (isCalldataOnly()) {
+      emitCalldata(encodeGuardianUnstake({ action }, getChain().id));
+      return;
+    }
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7(`${action}...`).start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: fn, args: [], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: fn, args: [], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`${action} confirmed. Tx: ${hash}`);
     } catch (err) {
@@ -4817,17 +6801,21 @@ function registerGuardianCommands(program2) {
     }
   });
   guardian.command("delegate <delegate> <amount>").description("Delegate WOOD stake to a guardian. Amount in WOOD.").action(async (delegate, amountStr) => {
-    if (!isAddress5(delegate)) {
+    if (!isAddress6(delegate)) {
       console.error(chalk8.red("Invalid delegate address"));
       process.exit(1);
     }
     const amount = parseUnits5(amountStr, 18);
+    if (isCalldataOnly()) {
+      emitCalldata(encodeGuardianDelegate({ delegate, amount }, getChain().id));
+      return;
+    }
     await ensureWoodAllowance(amount);
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7(`Delegating ${amountStr} WOOD to ${delegate}...`).start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "delegateStake", args: [delegate, amount], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "delegateStake", args: [delegate, amount], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`Delegated. Tx: ${hash}`);
     } catch (err) {
@@ -4837,7 +6825,7 @@ function registerGuardianCommands(program2) {
     }
   });
   guardian.command("undelegate <delegate> <action>").description("Unstake-delegation flow: 'request' | 'cancel' | 'claim'").action(async (delegate, action) => {
-    if (!isAddress5(delegate)) {
+    if (!isAddress6(delegate)) {
       console.error(chalk8.red("Invalid delegate address"));
       process.exit(1);
     }
@@ -4846,11 +6834,15 @@ function registerGuardianCommands(program2) {
       console.error(chalk8.red(`Unknown action '${action}'. Use request | cancel | claim.`));
       process.exit(1);
     }
+    if (isCalldataOnly()) {
+      emitCalldata(encodeDelegationUnstake({ action, delegate }, getChain().id));
+      return;
+    }
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7(`${action}...`).start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: fn, args: [delegate], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: fn, args: [delegate], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`${action} confirmed. Tx: ${hash}`);
     } catch (err) {
@@ -4865,11 +6857,15 @@ function registerGuardianCommands(program2) {
       console.error(chalk8.red("Commission cannot exceed 5000 bps (50%)"));
       process.exit(1);
     }
+    if (isCalldataOnly()) {
+      emitCalldata(encodeSetCommission({ bps: Number(bps) }, getChain().id));
+      return;
+    }
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7(`Setting commission to ${Number(bps) / 100}%...`).start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "setCommission", args: [bps], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "setCommission", args: [bps], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`Commission set. Tx: ${hash}`);
     } catch (err) {
@@ -4880,11 +6876,15 @@ function registerGuardianCommands(program2) {
   });
   guardian.command("claim-proposal <proposalId>").description("Claim guardian-fee commission for a settled proposal you voted Approve on (vault asset).").action(async (pidStr) => {
     const pid = BigInt(pidStr);
+    if (isCalldataOnly()) {
+      emitCalldata(encodeClaimProposalReward({ proposalId: pid }, getChain().id));
+      return;
+    }
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7("Claiming...").start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "claimProposalReward", args: [pid], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "claimProposalReward", args: [pid], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`Claimed. Tx: ${hash}`);
     } catch (err) {
@@ -4894,16 +6894,20 @@ function registerGuardianCommands(program2) {
     }
   });
   guardian.command("claim-delegator <delegate> <proposalId>").description("Claim your delegator share of a delegate's guardian-fee pool for a specific proposal.").action(async (delegate, pidStr) => {
-    if (!isAddress5(delegate)) {
+    if (!isAddress6(delegate)) {
       console.error(chalk8.red("Invalid delegate address"));
       process.exit(1);
     }
     const pid = BigInt(pidStr);
+    if (isCalldataOnly()) {
+      emitCalldata(encodeClaimDelegatorProposalReward({ delegate, proposalId: pid }, getChain().id));
+      return;
+    }
     const wallet = getWalletClient();
     const pc = getPublicClient();
     const spinner = ora7("Claiming delegator share...").start();
     try {
-      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI, functionName: "claimDelegatorProposalReward", args: [delegate, pid], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: registry(), abi: GUARDIAN_REGISTRY_ABI2, functionName: "claimDelegatorProposalReward", args: [delegate, pid], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`Claimed. Tx: ${hash}`);
     } catch (err) {
@@ -4933,6 +6937,7 @@ function registerGuardianCommands(program2) {
 
 // src/commands/grid.ts
 import chalk14 from "chalk";
+import { createInterface as createInterface2 } from "readline/promises";
 
 // src/grid/loop.ts
 import chalk13 from "chalk";
@@ -5183,7 +7188,7 @@ var GridManager = class {
     }
     this.portfolio.checkPauseThreshold(state, this.config, prices);
     await this.portfolio.save(state);
-    return { fills: totalFills, roundTrips: totalRoundTrips, pnlUsd: totalPnl, paused: false };
+    return { fills: totalFills, roundTrips: totalRoundTrips, pnlUsd: totalPnl, paused: state.paused };
   }
   /** Hourly refresh of `grid.trend` from recent 4h candles. Called from
    *  tick() so the downtrend filter sees fresh data between buildGrid runs. */
@@ -5472,7 +7477,8 @@ var DEFAULT_GRID_CONFIG = {
   // was 0.55 — rebalance faster, keep levels near price
   fullRebuildIntervalMs: 12 * 60 * 60 * 1e3,
   // 12h
-  tokenSplit: { bitcoin: 0.45, ethereum: 0.3, solana: 0.25 },
+  tokenSplit: { bitcoin: 0.55, ethereum: 0.25, solana: 0.2 },
+  // BTC-tilt — 30d backtest 2026-04-18..05-18 vs prior 0.45/0.30/0.25: net +$464 (+9.28%) vs +$422 (+8.44%) and max DD -$546 vs -$598
   minProfitPerFillUsd: 0.5,
   pauseThresholdPct: 0.2,
   // post leverage-fix calibration: fires at ~4% adverse move on 5x (real dollar terms); old 0.40 required ~8% which essentially never fired before liquidation
@@ -5550,8 +7556,14 @@ var GridHedgeManager = class {
    * @param marketTrend - recent market trend (e.g. BTC's 56h trend) used by
    *                     `hedgeRatioFor()` to scale hedge size by regime. Pass
    *                     undefined to use the static default.
+   * @param paused - when true, force desired hedge to zero for all tokens so
+   *                 the close-path realizes any unrealized PnL into the
+   *                 ledger. The loop passes `state.paused` so a soft-pause
+   *                 grid doesn't hold paper-gain on the hedge that erodes
+   *                 when the underlying mean-reverts toward the resume
+   *                 threshold.
    */
-  async tick(openFills, prices, now = Date.now(), marketTrend) {
+  async tick(openFills, prices, now = Date.now(), marketTrend, paused = false) {
     const state = await this.load(now);
     let adjustments = 0;
     let unrealizedPnl = 0;
@@ -5559,7 +7571,7 @@ var GridHedgeManager = class {
     for (const fill of openFills) {
       const price = prices[fill.token];
       if (!price || price <= 0) continue;
-      const desiredShortQty = fill.fillCount >= MIN_FILLS_TO_HEDGE ? fill.totalQuantity * activeRatio : 0;
+      const desiredShortQty = paused ? 0 : fill.fillCount >= MIN_FILLS_TO_HEDGE ? fill.totalQuantity * activeRatio : 0;
       const existing = state.positions.find((p) => p.token === fill.token);
       if (desiredShortQty <= 0) {
         if (existing && existing.quantity > 0) {
@@ -5651,6 +7663,39 @@ var GridHedgeManager = class {
       totalRealizedPnl: state.totalRealizedPnl
     };
   }
+  /**
+   * Close every active hedge position in the ledger at the provided mark
+   * prices, accumulating realized PnL using the same `(entry - price) * qty`
+   * formula `tick()` uses on its auto-close path. Positions whose token is
+   * missing from `prices` are left untouched and reported in `skipped`.
+   *
+   * Bookkeeping-only — this manager does not place perp orders; the actual
+   * HL position (if any) must be closed externally. Use this to zero the
+   * ledger as part of `sherwood grid flatten`.
+   */
+  async flatten(prices, now = Date.now()) {
+    const state = await this.load(now);
+    const closed = [];
+    const skipped = [];
+    for (const pos of state.positions) {
+      if (pos.quantity <= 0) continue;
+      const price = prices[pos.token];
+      if (!price || price <= 0) {
+        skipped.push(pos.token);
+        continue;
+      }
+      const closePnl = (pos.entryPrice - price) * pos.quantity;
+      state.totalRealizedPnl += closePnl;
+      state.todayRealizedPnl += closePnl;
+      pos.realizedPnl += closePnl;
+      closed.push({ token: pos.token, quantity: pos.quantity, realizedPnl: closePnl });
+      pos.quantity = 0;
+      pos.entryPrice = 0;
+      pos.lastAdjustedAt = now;
+    }
+    await this.save();
+    return { closed, skipped, totalRealizedPnl: state.totalRealizedPnl };
+  }
   /** Get current hedge status for display. */
   getStatus() {
     if (!this.state) return null;
@@ -5716,13 +7761,13 @@ var GridExecutor = class {
 import chalk12 from "chalk";
 import { mkdir as mkdir3, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname3 } from "path";
-import { encodeAbiParameters as encodeAbiParameters11, parseUnits as parseUnits6 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters13, parseUnits as parseUnits6 } from "viem";
 
 // src/grid/cloid.ts
-import { keccak256, encodeAbiParameters as encodeAbiParameters10 } from "viem";
+import { keccak256 as keccak2562, encodeAbiParameters as encodeAbiParameters12 } from "viem";
 function gridCloid(strategy2, assetIndex, isBuy, levelIndex, nonce) {
-  const hash = keccak256(
-    encodeAbiParameters10(
+  const hash = keccak2562(
+    encodeAbiParameters12(
       [
         { type: "address" },
         { type: "uint32" },
@@ -5782,11 +7827,18 @@ var OnchainGridExecutor = class {
     this.maxOrdersPerTick = Number(value);
     return this.maxOrdersPerTick;
   }
-  /** Load persisted state. Call once before the first execute(). */
-  async load() {
+  /**
+   * Read persisted state from disk — does NOT touch the network. Use this
+   * when you only need `nonces` + `placedCloids` (e.g. for `flattenAll`'s
+   * cancel-only path). Idempotent: callers may invoke it repeatedly; each
+   * call re-reads the file and clobbers in-memory maps with disk state.
+   */
+  async loadFromDisk() {
     try {
       const raw = await readFile3(this.statePath, "utf-8");
       const state = JSON.parse(raw);
+      this.nonces.clear();
+      this.placedCloids.clear();
       for (const [tok, n] of Object.entries(state.nonces)) this.nonces.set(tok, n);
       for (const [tok, cloids] of Object.entries(state.placedCloids)) {
         this.placedCloids.set(tok, cloids.map((s) => BigInt(s)));
@@ -5803,6 +7855,10 @@ var OnchainGridExecutor = class {
         );
       }
     }
+  }
+  /** Load persisted state + chain meta. Call once before the first execute(). */
+  async load() {
+    await this.loadFromDisk();
     if (!this.meta) this.meta = await hlGetMeta();
     await this.fetchMaxOrdersPerTick();
   }
@@ -5938,7 +7994,7 @@ var OnchainGridExecutor = class {
     for (const chunk of chunks) {
       const nonce = this.bumpNonce(token);
       const { encoded, cloids } = this.encodeOrders(assetIndex, chunk, meta, nonce);
-      const data = encodeAbiParameters11(
+      const data = encodeAbiParameters13(
         [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
         [ACTION_PLACE_GRID, encoded]
       );
@@ -5956,7 +8012,7 @@ var OnchainGridExecutor = class {
       this.bumpNonce(token);
       return "0x";
     }
-    const data = encodeAbiParameters11(
+    const data = encodeAbiParameters13(
       [{ type: "uint8" }, { type: "uint32" }, { type: "uint128[]" }],
       [ACTION_CANCEL_ALL, assetIndex, cloids]
     );
@@ -5985,7 +8041,7 @@ var OnchainGridExecutor = class {
       const { encoded, cloids } = this.encodeOrders(assetIndex, chunk, meta, newNonce);
       let data;
       if (i === 0) {
-        data = encodeAbiParameters11(
+        data = encodeAbiParameters13(
           [
             { type: "uint8" },
             { type: "uint32" },
@@ -5995,7 +8051,7 @@ var OnchainGridExecutor = class {
           [ACTION_CANCEL_AND_PLACE, assetIndex, oldCloids, encoded]
         );
       } else {
-        data = encodeAbiParameters11(
+        data = encodeAbiParameters13(
           [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
           [ACTION_PLACE_GRID, encoded]
         );
@@ -6008,6 +8064,47 @@ var OnchainGridExecutor = class {
     }
     return txs;
   }
+  /**
+   * Cancel every tracked CLOID across all configured tokens. Used by
+   * `sherwood grid flatten` to wind the strategy down to a no-orders state
+   * without placing anything new.
+   *
+   * Per-token errors are captured and returned rather than thrown — partial
+   * progress is the expected outcome when one token reverts (e.g. nonce
+   * desync after a manual on-chain action). Each successful cancel saves
+   * before moving on, so a crash mid-flatten leaves a consistent on-disk
+   * record of which tokens still hold cloids.
+   */
+  async flattenAll() {
+    if (this.busy) {
+      return { txs: [], cancelled: [], skipped: [], errors: ["flattenAll() called while another execute()/flattenAll() is in flight"] };
+    }
+    this.busy = true;
+    try {
+      await this.loadFromDisk();
+      const txs = [];
+      const cancelled = [];
+      const skipped = [];
+      const errors = [];
+      for (const [token, assetIndex] of Object.entries(this.cfg.assetIndices)) {
+        try {
+          const tx = await this.cancelAll(token, assetIndex);
+          if (tx === "0x") {
+            skipped.push(token);
+          } else {
+            txs.push(tx);
+            cancelled.push(token);
+          }
+          await this.save();
+        } catch (e) {
+          errors.push(`${token}: ${e.message}`);
+        }
+      }
+      return { txs, cancelled, skipped, errors };
+    } finally {
+      this.busy = false;
+    }
+  }
   /**
    * Submit and wait for receipt. Throwing here surfaces to the per-token
    * try/catch in execute(), recording the error and skipping the save() so
@@ -6151,7 +8248,7 @@ var GridLoop = class {
     }
     const openExposure = this.manager.getOpenFillExposure();
     const marketTrend = this.manager.getMarketTrend();
-    const hedgeResult = await this.hedge.tick(openExposure, prices, Date.now(), marketTrend);
+    const hedgeResult = await this.hedge.tick(openExposure, prices, Date.now(), marketTrend, result.paused);
     if (hedgeResult.adjustments > 0) {
       console.error(chalk13.magenta(
         `  [hedge] ${hedgeResult.adjustments} adjustment(s), unrealized: $${hedgeResult.unrealizedPnl.toFixed(2)}, total realized: $${hedgeResult.totalRealizedPnl.toFixed(2)}`
@@ -6598,7 +8695,7 @@ async function runBacktest(opts) {
         }
         const exposure = manager.getOpenFillExposure();
         const marketTrend = manager.getMarketTrend();
-        const hedgeResult = await hedge.tick(exposure, hedgePrices, t, marketTrend);
+        const hedgeResult = await hedge.tick(exposure, hedgePrices, t, marketTrend, stateAfter?.paused ?? false);
         hedgeAdjustments += hedgeResult.adjustments;
         hedgeRealized = hedgeResult.totalRealizedPnl;
         hedgeUnrealized = hedgeResult.unrealizedPnl;
@@ -6930,6 +9027,9 @@ async function runSweep(opts) {
 }
 
 // src/commands/grid.ts
+var DEFAULT_PAUSE_REASON = "Manually paused by operator";
+var DEFAULT_FLATTEN_REASON = "Manually flattened by operator";
+var CONFIRM_TIMEOUT_SECONDS = 60;
 var DIM5 = chalk14.gray;
 var G5 = chalk14.green;
 var BOLD5 = chalk14.white.bold;
@@ -7022,6 +9122,21 @@ function printSweepSummary(s) {
   console.log(W5(`  Saved: ${s.sweepId}/sweep.json + per-run JSONs in ~/.sherwood/grid/sweeps/`));
   console.log();
 }
+function parseAssetIndices(raw) {
+  const indices = {};
+  for (const pair of raw.split(",")) {
+    const [tok, idx] = pair.split("=");
+    if (!tok || !idx) {
+      throw new Error(`Bad asset-indices pair: '${pair}' (expected token=index)`);
+    }
+    const n = Number(idx.trim());
+    if (!Number.isInteger(n) || n < 0) {
+      throw new Error(`Bad asset-indices value for '${tok}': '${idx}' (must be a non-negative integer)`);
+    }
+    indices[tok.trim()] = n;
+  }
+  return indices;
+}
 function parseTokenSplit(raw, tokens) {
   const split = {};
   for (const pair of raw.split(",")) {
@@ -7059,12 +9174,7 @@ function registerGridCommand(program2) {
       if (!opts.assetIndices) {
         throw new Error("--asset-indices required when --live (mainnet: --asset-indices bitcoin=0,ethereum=1,solana=5)");
       }
-      assetIndices = {};
-      for (const pair of opts.assetIndices.split(",")) {
-        const [tok, idx] = pair.split("=");
-        if (!tok || !idx) throw new Error(`Bad asset-indices pair: ${pair}`);
-        assetIndices[tok.trim()] = Number(idx);
-      }
+      assetIndices = parseAssetIndices(opts.assetIndices);
     }
     const strategyAddress = opts.strategy;
     if (strategyAddress && !live) {
@@ -7227,7 +9337,7 @@ function registerGridCommand(program2) {
     });
     printSweepSummary(result);
   });
-  grid.command("pause").description("Manually pause the live grid (sets state.paused=true)").option("--reason <text>", "Reason for the pause (shown in status output)", "Manually paused by operator").option("--state-dir <path>", "Read/write state from a custom directory (defaults to ~/.sherwood/grid)").action(async (opts) => {
+  grid.command("pause").description("Manually pause the live grid (sets state.paused=true)").option("--reason <text>", "Reason for the pause (shown in status output)", DEFAULT_PAUSE_REASON).option("--state-dir <path>", "Read/write state from a custom directory (defaults to ~/.sherwood/grid)").action(async (opts) => {
     const portfolio = new GridPortfolio(opts.stateDir);
     const state = await portfolio.load();
     if (!state) {
@@ -7273,6 +9383,116 @@ function registerGridCommand(program2) {
     console.log(G5(`  Grid resumed. (was paused: ${wasReason || "<unknown>"})`));
     console.log();
   });
+  grid.command("flatten").description("Cancel all open grid orders on-chain, zero the hedge ledger, and pause the grid").option("--state-dir <path>", "Read/write state from a custom directory (defaults to ~/.sherwood/grid)").option("--strategy <address>", "Strategy contract address \u2014 required to cancel on-chain CLOIDs. Omit for hedge-only flatten.").option("--asset-indices <pairs>", "comma-separated token=index pairs (required with --strategy, e.g. bitcoin=3,ethereum=4,solana=5)").option("--reason <text>", "Reason recorded on the paused grid state", DEFAULT_FLATTEN_REASON).option("--dry-run", "Print intended actions and exit without touching state or chain").option("--yes", "Skip the confirmation prompt").action(async (opts) => {
+    const stateDir = opts.stateDir;
+    const portfolio = new GridPortfolio(stateDir);
+    const state = await portfolio.load();
+    if (!state) {
+      console.log(DIM5("\n  No grid portfolio found. Nothing to flatten.\n"));
+      return;
+    }
+    const openFills = state.grids.flatMap((g) => g.openFills.filter((f) => !f.closed));
+    const hedgeMgr = new GridHedgeManager(stateDir);
+    const hedgeState = await hedgeMgr.load();
+    const openHedges = hedgeState.positions.filter((p) => p.quantity > 0);
+    let strategyAddress;
+    let assetIndices;
+    if (opts.strategy) {
+      strategyAddress = opts.strategy;
+      if (!opts.assetIndices) {
+        throw new Error("--asset-indices required with --strategy (e.g. --asset-indices bitcoin=3,ethereum=4,solana=5)");
+      }
+      assetIndices = parseAssetIndices(opts.assetIndices);
+    }
+    console.log();
+    console.log(BOLD5("  Flatten plan"));
+    SEP5();
+    console.log(W5(`  State dir:     ${stateDir ?? "~/.sherwood/grid (default)"}`));
+    console.log(W5(`  On-chain:      ${strategyAddress ? strategyAddress : DIM5("(skipped \u2014 no --strategy)")}`));
+    console.log(W5(`  Open fills:    ${openFills.length} (informational \u2014 on-chain CLOIDs cancelled per-token)`));
+    console.log(W5(`  Hedge legs:    ${openHedges.length}${openHedges.length > 0 ? " (" + openHedges.map((h) => h.token).join(", ") + ")" : ""}`));
+    console.log(W5(`  Will pause:    yes \u2014 reason: "${opts.reason}"`));
+    SEP5();
+    if (opts.dryRun) {
+      console.log(chalk14.yellow("  --dry-run set \u2014 no state or chain mutation."));
+      console.log();
+      return;
+    }
+    if (!opts.yes) {
+      if (!process.stdin.isTTY) {
+        throw new Error("Refusing to flatten without --yes in a non-interactive context. Pass --yes to confirm.");
+      }
+      const rl = createInterface2({ input: process.stdin, output: process.stdout });
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), CONFIRM_TIMEOUT_SECONDS * 1e3);
+      let answer;
+      try {
+        answer = (await rl.question(chalk14.yellow("  Proceed with flatten? [y/N] "), { signal: ac.signal })).trim().toLowerCase();
+      } catch (e) {
+        if (e.name === "AbortError") {
+          console.log(DIM5(`
+  Timed out after ${CONFIRM_TIMEOUT_SECONDS}s. Aborted.
+`));
+          return;
+        }
+        throw e;
+      } finally {
+        clearTimeout(timer);
+        rl.close();
+      }
+      if (answer !== "y" && answer !== "yes") {
+        console.log(DIM5("  Aborted.\n"));
+        return;
+      }
+    }
+    if (strategyAddress && assetIndices) {
+      const executor = new OnchainGridExecutor({ strategyAddress, assetIndices, stateDir });
+      await executor.load();
+      const res = await executor.flattenAll();
+      if (res.cancelled.length > 0) {
+        console.log(G5(`  Cancelled CLOIDs for: ${res.cancelled.join(", ")}`));
+        for (const tx of res.txs) console.log(DIM5(`    tx ${tx}`));
+      }
+      if (res.skipped.length > 0) {
+        console.log(DIM5(`  Skipped (no tracked CLOIDs): ${res.skipped.join(", ")}`));
+      }
+      if (res.errors.length > 0) {
+        for (const err of res.errors) console.log(chalk14.red(`  Cancel error: ${err}`));
+      }
+    }
+    if (openHedges.length > 0) {
+      const hl = new HyperliquidProvider();
+      const prices = {};
+      for (const pos of openHedges) {
+        const data = await hl.getHyperliquidData(pos.token);
+        if (data?.markPrice && data.markPrice > 0) prices[pos.token] = data.markPrice;
+      }
+      const hres = await hedgeMgr.flatten(prices);
+      if (hres.closed.length > 0) {
+        for (const c of hres.closed) {
+          const sign = c.realizedPnl >= 0 ? "+" : "-";
+          console.log(G5(`  Hedge closed ${c.token}: qty ${c.quantity.toFixed(6)} \u2192 0  (${sign}$${Math.abs(c.realizedPnl).toFixed(2)} realized)`));
+        }
+      }
+      if (hres.skipped.length > 0) {
+        console.log(chalk14.yellow(`  Hedge skipped (no mark price): ${hres.skipped.join(", ")}`));
+      }
+      console.log(W5(`  Total hedge realized PnL: $${hres.totalRealizedPnl.toFixed(2)}`));
+    } else {
+      console.log(DIM5("  No active hedge legs \u2014 ledger already flat."));
+    }
+    if (!state.paused) {
+      state.paused = true;
+      state.pauseReason = opts.reason;
+      await portfolio.save(state);
+      console.log(chalk14.yellow(`  Grid paused. Reason: ${state.pauseReason}`));
+    } else {
+      console.log(DIM5(`  Grid was already paused: ${state.pauseReason}`));
+    }
+    console.log();
+    console.log(G5("  Flatten complete. Stop the loop process / systemd unit if still running."));
+    console.log();
+  });
 }
 
 // src/index.ts
@@ -7281,7 +9501,7 @@ try {
 } catch {
 }
 var require2 = createRequire(import.meta.url);
-var { version: CLI_VERSION } = require2("../package.json");
+var CLI_VERSION = "0.65.0";
 async function loadXmtp() {
   return import("./xmtp-MR6OJ76L.js");
 }
@@ -7295,7 +9515,7 @@ var BOLD6 = chalk15.white.bold;
 var LABEL5 = chalk15.green.bold;
 var SEP6 = () => console.log(DIM6("\u2500".repeat(60)));
 function validateAddress(value, name) {
-  if (!isAddress6(value)) {
+  if (!isAddress7(value)) {
     console.error(chalk15.red(`Invalid ${name} address: ${value}`));
     process.exit(1);
   }
@@ -7309,8 +9529,13 @@ function resolveVault(opts) {
 var program = new Command();
 program.name("sherwood").description("CLI for agent-managed investment syndicates").version(CLI_VERSION).addOption(
   new Option("--chain <network>", "Target network").choices(VALID_NETWORKS).default("base")
-).option("--testnet", "Alias for --chain base-sepolia (deprecated)", false).hook("preAction", (thisCommand) => {
+).option("--testnet", "Alias for --chain base-sepolia (deprecated)", false).option(
+  "--calldata-only",
+  "Print unsigned EIP-5792 calldata as JSON instead of signing/sending (for external signers \u2014 no private key required)",
+  false
+).hook("preAction", (thisCommand) => {
   const opts = thisCommand.optsWithGlobals();
+  setCalldataOnly(Boolean(opts.calldataOnly));
   let network = opts.chain;
   if (opts.testnet) {
     process.env.ENABLE_TESTNET = "true";
@@ -7333,8 +9558,10 @@ syndicate.command("create").description("Create a new syndicate via the factory
     console.log();
     console.log(LABEL5("  \u25C6 Create Syndicate"));
     SEP6();
-    const wallet = getAccount();
-    console.log(DIM6(`  Wallet:  ${wallet.address}`));
+    if (!isCalldataOnly()) {
+      const wallet = getAccount();
+      console.log(DIM6(`  Wallet:  ${wallet.address}`));
+    }
     console.log(DIM6(`  Network: ${getChain().name}`));
     SEP6();
     const savedAgentId = getAgentId();
@@ -7434,6 +9661,23 @@ syndicate.command("create").description("Create a new syndicate via the factory
         metadataURI = `data:application/json;base64,${Buffer.from(json).toString("base64")}`;
       }
     }
+    if (isCalldataOnly()) {
+      emitCalldata(
+        encodeCreateSyndicate(
+          {
+            creatorAgentId: agentIdStr,
+            metadataURI,
+            asset,
+            name,
+            symbol,
+            openDeposits,
+            subdomain
+          },
+          getChain().id
+        )
+      );
+      return;
+    }
     const existingId = await subdomainExists(subdomain);
     if (existingId !== null) {
       const existingInfo = await getSyndicate(existingId);
@@ -7766,9 +10010,18 @@ syndicate.command("update-metadata").description("Update syndicate metadata (cre
 });
 syndicate.command("approve-depositor").description("Approve an address to deposit (owner only)").option("--vault <address>", "Vault address (default: from config)").requiredOption("--depositor <address>", "Address to approve").action(async (opts) => {
   resolveVault(opts);
+  const depositor = validateAddress(opts.depositor, "depositor");
+  if (isCalldataOnly()) {
+    emitCalldata(
+      encodeApproveDepositor(
+        { vault: getVaultAddress(), depositor },
+        getChain().id
+      )
+    );
+    return;
+  }
   const spinner = ora8("Approving depositor...").start();
   try {
-    const depositor = validateAddress(opts.depositor, "depositor");
     const hash = await approveDepositor(depositor);
     spinner.succeed(`Depositor approved: ${hash}`);
     console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
@@ -7793,6 +10046,29 @@ syndicate.command("remove-depositor").description("Remove an address from the de
   }
 });
 syndicate.command("add").description("Register an agent on a syndicate vault (creator only)").option("--vault <address>", "Vault address (default: from config)").option("--agent-id <id>", "Agent's ERC-8004 identity token ID (resolved from wallet if omitted)").requiredOption("--wallet <address>", "Agent wallet address").action(async (opts) => {
+  if (isCalldataOnly()) {
+    resolveVault(opts);
+    const agentWallet = validateAddress(opts.wallet, "wallet");
+    if (!opts.agentId) {
+      console.error(
+        chalk15.red(
+          "--calldata-only requires --agent-id (auto-lookup from wallet is skipped in calldata mode)"
+        )
+      );
+      process.exit(1);
+    }
+    emitCalldata(
+      encodeRegisterAgent(
+        {
+          vault: getVaultAddress(),
+          agentAddress: agentWallet,
+          agentId: BigInt(opts.agentId)
+        },
+        getChain().id
+      )
+    );
+    return;
+  }
   const spinner = ora8("Verifying creator...").start();
   try {
     resolveVault(opts);
@@ -7941,6 +10217,24 @@ syndicate.command("join").description("Request to join a syndicate (creates an E
       }
       process.exit(1);
     }
+    if (isCalldataOnly()) {
+      const referrerAgentId2 = opts.ref ? parseInt(opts.ref, 10) : void 0;
+      spinner.stop();
+      emitCalldata(
+        encodeJoinRequest(
+          {
+            syndicateId: syndicate2.id,
+            agentId: BigInt(agentId),
+            vault: syndicate2.vault,
+            creator: syndicate2.creator,
+            message: opts.message,
+            referrerAgentId: referrerAgentId2
+          },
+          getChain().id
+        )
+      );
+      return;
+    }
     const callerAddress = getAccount().address;
     spinner.text = "Checking membership...";
     setVaultAddress(syndicate2.vault);
@@ -8116,6 +10410,21 @@ syndicate.command("approve").description("Approve an agent join request (registe
     const vaultAddress = getVaultAddress();
     const agentWallet = validateAddress(opts.wallet, "wallet");
     const { creator, subdomain, id: syndicateId } = await resolveVaultSyndicate(vaultAddress);
+    if (isCalldataOnly()) {
+      spinner.stop();
+      emitCalldata(
+        encodeApproveAgent(
+          {
+            syndicateId,
+            agentId: BigInt(opts.agentId),
+            vault: vaultAddress,
+            agentAddress: agentWallet
+          },
+          getChain().id
+        )
+      );
+      return;
+    }
     const callerAddress = getAccount().address.toLowerCase();
     if (creator.toLowerCase() !== callerAddress) {
       spinner.fail("Only the syndicate creator can approve agents");
@@ -8297,10 +10606,57 @@ syndicate.command("set-primary").description("Set the active syndicate for CLI c
   }
 });
 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)").option("--use-eth", "Auto-wrap ETH \u2192 WETH before depositing (for WETH vaults)").action(async (opts) => {
+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)").option("--use-eth", "Auto-wrap ETH \u2192 WETH before depositing (for WETH vaults)").option("--receiver <address>", "Depositor / share receiver (required with --calldata-only)").action(async (opts) => {
   resolveVault(opts);
   const decimals = await getAssetDecimals();
   const amount = parseUnits7(opts.amount, decimals);
+  if (isCalldataOnly()) {
+    if (!opts.receiver) {
+      console.error(
+        chalk15.red(
+          "--calldata-only requires --receiver <address> (the depositor / share receiver)"
+        )
+      );
+      process.exit(1);
+    }
+    const receiver = validateAddress(opts.receiver, "receiver");
+    const asset = await getAssetAddress();
+    const assetSymbol = await getPublicClient().readContract({
+      address: asset,
+      abi: ERC20_ABI,
+      functionName: "symbol"
+    });
+    let currentWethBalance;
+    if (opts.useEth) {
+      currentWethBalance = await getPublicClient().readContract({
+        address: asset,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [receiver]
+      });
+    }
+    try {
+      emitCalldata(
+        encodeDeposit(
+          {
+            vault: getVaultAddress(),
+            receiver,
+            asset,
+            assetSymbol,
+            assetDecimals: decimals,
+            assets: amount,
+            wrapEth: Boolean(opts.useEth),
+            currentWethBalance
+          },
+          getChain().id
+        )
+      );
+    } catch (err) {
+      console.error(chalk15.red(err instanceof Error ? err.message : String(err)));
+      process.exit(1);
+    }
+    return;
+  }
   try {
     if (!opts.useEth) {
       await preflightDeposit(amount);
@@ -8368,10 +10724,42 @@ vaultCmd.command("balance").description("Show LP share balance and asset value")
     process.exit(1);
   }
 });
-vaultCmd.command("redeem").description("Redeem vault shares for the underlying asset (ERC-4626)").option("--vault <address>", "Vault address (default: from config)").option("--shares <amount>", "Shares to redeem in whole-share units (default: all)").option("--receiver <address>", "Receiver of the underlying asset (default: your wallet)").action(async (opts) => {
+vaultCmd.command("redeem").description("Redeem vault shares for the underlying asset (ERC-4626)").option("--vault <address>", "Vault address (default: from config)").option("--shares <amount>", "Shares to redeem in whole-share units (default: all)").option("--receiver <address>", "Receiver of the underlying asset (default: your wallet)").option("--owner <address>", "Share owner whose shares burn (required with --calldata-only)").action(async (opts) => {
   resolveVault(opts);
   const assetDecimals = await getAssetDecimals();
   const shareDecimals = assetDecimals * 2;
+  if (isCalldataOnly()) {
+    if (!opts.shares) {
+      console.error(
+        chalk15.red(
+          "--calldata-only requires --shares (auto-'all' needs your on-chain share balance)"
+        )
+      );
+      process.exit(1);
+    }
+    if (!opts.owner) {
+      console.error(
+        chalk15.red(
+          "--calldata-only requires --owner <address> (the share holder whose shares burn)"
+        )
+      );
+      process.exit(1);
+    }
+    const owner = validateAddress(opts.owner, "owner");
+    const receiver = opts.receiver ? validateAddress(opts.receiver, "receiver") : owner;
+    emitCalldata(
+      encodeRedeem(
+        {
+          vault: getVaultAddress(),
+          receiver,
+          owner,
+          shares: parseUnits7(opts.shares, shareDecimals)
+        },
+        getChain().id
+      )
+    );
+    return;
+  }
   let shares;
   try {
     if (opts.shares) {
@@ -8389,7 +10777,7 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
 `));
     process.exit(1);
   }
-  if (opts.receiver && !isAddress6(opts.receiver)) {
+  if (opts.receiver && !isAddress7(opts.receiver)) {
     console.error(chalk15.red(`
   \u2716 Invalid receiver address: ${opts.receiver}
 `));
@@ -8403,7 +10791,7 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
 `));
     process.exit(1);
   }
-  const sharesDisplay = formatUnits5(shares, shareDecimals);
+  const sharesDisplay = formatUnits6(shares, shareDecimals);
   const spinner = ora8(`Redeeming ${sharesDisplay} shares...`).start();
   try {
     const { hash, assetsOut } = await redeem(
@@ -8412,7 +10800,7 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
     );
     spinner.succeed(`Redeemed: ${hash}`);
     console.log(chalk15.dim(`  ${getExplorerUrl(hash)}`));
-    console.log(`  Assets received: ${formatUnits5(assetsOut, assetDecimals)}`);
+    console.log(`  Assets received: ${formatUnits6(assetsOut, assetDecimals)}`);
   } catch (err) {
     spinner.fail("Redeem failed");
     console.error(chalk15.red(formatContractError(err)));