@sherwoodagent/cli 0.83.1 → 0.84.0

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   checkApiKeyValid,
   listModels,
   provisionApiKey
-} from "./chunk-CCNOXDZ7.js";
+} from "./chunk-KVB5P2OE.js";
 import {
   approveDepositor,
   deposit,
@@ -38,50 +38,55 @@ import {
   removeDepositor,
   setAgentFeeBps,
   setVaultAddress
-} from "./chunk-AOL2DJTK.js";
-import "./chunk-NKRMMFQG.js";
+} from "./chunk-SNR5R5TO.js";
+import "./chunk-JUVXLTL2.js";
 import {
+  DEFAULT_FEE_TIER,
   HYPERLIQUID_PERP_STRATEGY_ABI,
   applySlippage,
   assetDecimalsForSymbol,
   buildCallsForTemplate,
   buildInitDataForTemplate,
   computeProposalAssetChecks,
+  defaultPortfolioAsset,
   encodeSwapPath,
   getMultiHopQuote,
   getQuote,
-  resolveToken
-} from "./chunk-AJ46XIGY.js";
+  parseAlignedOverrides,
+  resolveToken,
+  selectBestFeeTier
+} from "./chunk-6DRNSZ2Z.js";
 import {
   createApproval,
   createJoinRequest,
   getEasExplorerUrl,
-  getEasScanUrl,
   parseReferrer,
   queryApprovals,
   queryJoinRequests,
   revokeJoinRequest,
   stripReferrerPrefix
-} from "./chunk-M34JVPJO.js";
+} from "./chunk-NCFN66ZH.js";
 import {
   createFund,
   getActiveFunds,
   getFund,
   subdomainExists,
   updateMetadata
-} from "./chunk-4WAEM2TC.js";
+} from "./chunk-56YYNNNQ.js";
 import {
   resolveFund,
   resolveVaultFund,
   searchFundAcrossChains,
   setTextRecord
-} from "./chunk-MBWFTXF5.js";
+} from "./chunk-MQ55QOGD.js";
 import {
   PROPOSAL_STATE,
   PROPOSAL_STATES,
   VOTE_TYPE,
+  assertReceiptSuccess,
   cancelProposal,
   classifyReview,
+  classifyReviewOpen,
   emergencyCancel,
   emergencySettle,
   evaluateExecuteGate,
@@ -98,8 +103,10 @@ import {
   getVoteWeight,
   hasVoted,
   parseDuration,
+  parseProposalIdFromLogs,
   proposalCount,
   propose,
+  scanReviewCandidates,
   setCooldownPeriod,
   setExecutionWindow,
   setMaxPerformanceFeeBps,
@@ -109,7 +116,7 @@ import {
   setVotingPeriod,
   settleProposal,
   vote
-} from "./chunk-4GO7I33U.js";
+} from "./chunk-BOC7VB5B.js";
 import {
   AERODROME,
   AGENT_REGISTRY,
@@ -119,7 +126,7 @@ import {
   TOKENS,
   UNISWAP,
   VENICE
-} from "./chunk-I7TMY7AS.js";
+} from "./chunk-DNRIKCJ5.js";
 import {
   GAS_UNITS,
   estimateGasCushion,
@@ -130,7 +137,7 @@ import {
   sendTxWithRetry,
   waitForReceipt,
   writeContractWithRetry
-} from "./chunk-AQPTBVEA.js";
+} from "./chunk-QRMZRAMG.js";
 import {
   DEFAULT_NETWORK,
   VALID_NETWORKS,
@@ -142,7 +149,7 @@ import {
   isTestnet,
   setNetwork,
   withNetwork
-} from "./chunk-ZW2VKCFZ.js";
+} from "./chunk-PVTZMRC6.js";
 import {
   addFund,
   cacheGroupId,
@@ -178,7 +185,7 @@ import {
   SWAP_ROUTER_EXACT_INPUT_SINGLE_ABI,
   SYNDICATE_VAULT_ABI,
   VENICE_STAKING_ABI
-} from "./chunk-XSP64L7L.js";
+} from "./chunk-F3MDCUGO.js";
 import {
   fetchMetadata,
   mergeFundMetadata,
@@ -289,7 +296,7 @@ var HYPERLIQUID_GRID_STRATEGY_ABI = [
 ];
 
 // src/commands/strategy-template-lib.ts
-import { parseUnits as parseUnits2, formatUnits as formatUnits4, erc20Abi } from "viem";
+import { parseUnits as parseUnits2, formatUnits as formatUnits4, isAddress as isAddress3, erc20Abi } from "viem";
 import chalk2 from "chalk";
 
 // src/lib/proposer-bond-error.ts
@@ -324,6 +331,13 @@ function emitCalldata(action) {
   process.stdout.write(JSON.stringify(action, null, 2) + "\n");
 }
 
+// ../sdk/dist/generated/state-machines.js
+var GUARDIAN_VOTE_TYPES = [
+  "None",
+  "Approve",
+  "Block"
+];
+
 // ../sdk/dist/types.js
 var CHAIN_IDS = {
   BASE: 8453,
@@ -519,6 +533,27 @@ var SYNDICATE_VAULT_ABI2 = [
       { name: "agentId", type: "uint256" }
     ],
     outputs: []
+  },
+  // Governor-only: mint + fund + run a single-use CallSandbox.
+  // ICallSandbox.Call is TWO fields (address,bytes). There is NO `value`.
+  {
+    name: "runSandbox",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "pid", type: "uint256" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "declaredTokens", type: "address[]" },
+      { name: "funding", type: "uint256" }
+    ],
+    outputs: [{ name: "sandbox", type: "address" }]
   }
 ];
 var SYNDICATE_GOVERNOR_ABI = [
@@ -580,6 +615,74 @@ var SYNDICATE_GOVERNOR_ABI = [
     ],
     outputs: [{ name: "proposalId", type: "uint256" }]
   },
+  // proposeWithSandbox — same 10 args as propose, prefixed with SandboxPayload.
+  // ICallSandbox.Call is TWO fields (address,bytes). There is NO `value`:
+  // native value would open a transfer channel with no metering story
+  // (ICallSandbox.sol:44-51). Aliasing BatchExecutorLib.Call would reintroduce it.
+  {
+    name: "proposeWithSandbox",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "sandbox",
+        type: "tuple",
+        components: [
+          { name: "funding", type: "uint256" },
+          {
+            name: "calls",
+            type: "tuple[]",
+            components: [
+              { name: "target", type: "address" },
+              { name: "data", type: "bytes" }
+            ]
+          },
+          { name: "declaredTokens", type: "address[]" }
+        ]
+      },
+      { name: "vault", type: "address" },
+      { name: "strategy", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "strategyDuration", type: "uint256" },
+      {
+        name: "envelope",
+        type: "tuple",
+        components: [
+          { name: "maxCapital", type: "uint256" },
+          { name: "maxDrawdownBps", type: "uint16" }
+        ]
+      },
+      {
+        name: "executeCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "executeCallCaps", type: "uint256[]" },
+      {
+        name: "settlementCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "settlementCallCaps", type: "uint256[]" },
+      {
+        name: "coProposers",
+        type: "tuple[]",
+        components: [
+          { name: "agent", type: "address" },
+          { name: "splitBps", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "proposalId", type: "uint256" }]
+  },
   // Lifecycle writes
   {
     name: "vote",
@@ -720,6 +823,35 @@ var SYNDICATE_GOVERNOR_ABI = [
       }
     ]
   },
+  // sandboxPayload — ISyndicateGovernor.sol ~730 / SyndicateGovernor.sol:506.
+  // Returns SandboxPayload {funding, calls, declaredTokens}. Calls are
+  // ICallSandbox.Call = (address target, bytes data) ONLY — no `value`.
+  // Non-sandbox (and unknown) pids return the mapping default: zero funding,
+  // empty calls, empty declaredTokens. The contract does not revert.
+  {
+    name: "sandboxPayload",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [
+      {
+        name: "payload",
+        type: "tuple",
+        components: [
+          { name: "funding", type: "uint256" },
+          {
+            name: "calls",
+            type: "tuple[]",
+            components: [
+              { name: "target", type: "address" },
+              { name: "data", type: "bytes" }
+            ]
+          },
+          { name: "declaredTokens", type: "address[]" }
+        ]
+      }
+    ]
+  },
   {
     name: "getProposalState",
     type: "function",
@@ -942,60 +1074,64 @@ var GUARDIAN_REGISTRY_ABI = [
     inputs: [],
     outputs: []
   },
-  // Delegation
+  // Delegation and commission fragments removed (SHE-86): delegateStake,
+  // requestUnstakeDelegation, cancelUnstakeDelegation, claimUnstakeDelegation
+  // and setCommission do not exist on the post-audit contracts.
+  // Reads
   {
-    name: "delegateStake",
+    name: "guardianStake",
     type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "delegate", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
   },
   {
-    name: "requestUnstakeDelegation",
+    name: "isActiveGuardian",
     type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "delegate", type: "address" }],
-    outputs: []
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
   },
+  // Guardian review vote — 3 args, no slashBps. Selector 0x3ad95b6d.
+  // GuardianVoteType: None=0, Approve=1, Block=2 (uint8).
   {
-    name: "cancelUnstakeDelegation",
+    name: "voteOnProposal",
     type: "function",
     stateMutability: "nonpayable",
-    inputs: [{ name: "delegate", type: "address" }],
+    inputs: [
+      { name: "governor", type: "address" },
+      { name: "proposalId", type: "uint256" },
+      { name: "support", type: "uint8" }
+    ],
     outputs: []
   },
+  // Cached review flags. Returns THREE bools (opened, resolved, blocked).
+  // A fourth output is the SHE-88 arity break: viem refuses the 96-byte returndata.
   {
-    name: "claimUnstakeDelegation",
+    name: "getReviewState",
     type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "delegate", type: "address" }],
-    outputs: []
-  },
-  // Commission
+    stateMutability: "view",
+    inputs: [
+      { name: "governor", type: "address" },
+      { name: "proposalId", type: "uint256" }
+    ],
+    outputs: [
+      { name: "opened", type: "bool" },
+      { name: "resolved", type: "bool" },
+      { name: "blocked", type: "bool" }
+    ]
+  }
+];
+var STAKED_WOOD_ABI = [
   {
-    name: "setCommission",
+    name: "stakeAsGuardian",
     type: "function",
     stateMutability: "nonpayable",
-    inputs: [{ name: "bps", type: "uint16" }],
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "agentId", 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 = [
@@ -1127,6 +1263,17 @@ var STRATEGY_FACTORY_ABI = [
 // ../sdk/dist/addresses.js
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var NO_GUARDIAN_ERA = {
+  governorBeacon: ZERO_ADDRESS,
+  protocolConfig: ZERO_ADDRESS,
+  priceRouter: ZERO_ADDRESS,
+  tierRegistry: ZERO_ADDRESS,
+  callSandboxImpl: ZERO_ADDRESS,
+  exposureLedger: ZERO_ADDRESS,
+  proposerBondEscrow: ZERO_ADDRESS,
+  challengeGame: ZERO_ADDRESS,
+  tokenCourt: ZERO_ADDRESS
+};
 var BASE_EAS = {
   chainId: CHAIN_IDS.BASE,
   address: "0x4200000000000000000000000000000000000021",
@@ -1147,11 +1294,15 @@ var BASE = {
   sherwood: {
     factory: "0xAC74EC56858d7F1f7618c8e77F65Fc26aDf33c82",
     guardianRegistry: "0x49E4163b5e4b23F8f3d469Cf6fa197FB6b06A26E",
+    stakedWood: ZERO_ADDRESS,
+    // not in chains/8453.json
     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
+    strategyFactory: ZERO_ADDRESS,
+    // None of the guardian-era contracts are in chains/8453.json yet.
+    ...NO_GUARDIAN_ERA
   },
   identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
   eas: BASE_EAS,
@@ -1177,9 +1328,13 @@ var HYPEREVM = {
   sherwood: {
     factory: "0xd05Ae0E8bcf13075C29817c805d6Cc14F214393a",
     guardianRegistry: "0x8b5710EB4e2fA639F364Dcc3F3B30c8f12F460b9",
+    stakedWood: ZERO_ADDRESS,
+    // no known sWOOD deployment
     vaultImpl: "0x2cbBe36Cf907A2BB410bacB0e4Fd632C7b012846",
     batchExecutorLib: "0x2c454bEF1b09c8a306a7058b8B510bF0DfF7179D",
-    strategyFactory: ZERO_ADDRESS
+    strategyFactory: ZERO_ADDRESS,
+    // No canonical chain book for HyperEVM — guardian-era contracts unknown.
+    ...NO_GUARDIAN_ERA
   },
   // ERC-8004 identity is minted on Base; HyperEVM funds reference the
   // Base-minted token id. Coordination attestations are pinned to Base EAS.
@@ -1202,9 +1357,13 @@ var ROBINHOOD = {
   sherwood: {
     factory: ZERO_ADDRESS,
     guardianRegistry: ZERO_ADDRESS,
+    stakedWood: ZERO_ADDRESS,
+    // 4663.json has WOOD, no STAKED_WOOD
     vaultImpl: ZERO_ADDRESS,
     batchExecutorLib: ZERO_ADDRESS,
-    strategyFactory: ZERO_ADDRESS
+    strategyFactory: ZERO_ADDRESS,
+    // Sherwood not deployed on Robinhood mainnet — no guardian-era contracts.
+    ...NO_GUARDIAN_ERA
   },
   // No ERC-8004 registry and no EAS path on Robinhood Chain.
   identityRegistry: ZERO_ADDRESS,
@@ -1233,14 +1392,32 @@ var ROBINHOOD_L2 = {
   sherwood: {
     factory: "0xa91AA45AFF32f52b6357044B02a16EBA775feC0b",
     guardianRegistry: "0xA400eFcfFc820C6f812203C58ee00423AeCC0903",
+    stakedWood: "0x21A69A6c9814c0d339C57fDdafed3B283702a739",
     vaultImpl: "0xC57e12d6e2d8Ed49316F0b69c51893CcA44151F7",
     batchExecutorLib: "0xF3b8db5aa41c7Ce92478A0Fa9C55a6460533eb86",
-    strategyFactory: "0xb683Bb8EEcBc2419BC3801df6FeA88f96657e670"
+    strategyFactory: "0xb683Bb8EEcBc2419BC3801df6FeA88f96657e670",
+    // Guardian-era contracts from contracts/chains/46630.json (SHE-93).
+    governorBeacon: "0x3D46Ec018cd5893b685b4dfdc3921A4Eb64E11d1",
+    protocolConfig: "0xC104Eb6a522d6718cA28F344B2373B29d57FF2E0",
+    priceRouter: "0xDd302ffcfA08071780eC1A2f12BccFB9ba6b6731",
+    tierRegistry: "0x99b8068Dc0F6093466964D581f72d947e3e380DB",
+    callSandboxImpl: "0xf09f6AF7DeBB964eD731376C9Af389F2Ce3d872A",
+    // Not in chains/46630.json (econ-security stack not deployed there yet).
+    exposureLedger: ZERO_ADDRESS,
+    proposerBondEscrow: ZERO_ADDRESS,
+    challengeGame: ZERO_ADDRESS,
+    tokenCourt: ZERO_ADDRESS
   },
   // No ERC-8004 registry and no EAS path on Robinhood L2.
   identityRegistry: ZERO_ADDRESS,
   eas: NO_EAS,
-  tokens: {},
+  tokens: {
+    wood: {
+      address: "0xCCb4fB59cf40de1E23083037ee81Da1DD747D8d7",
+      symbol: "WOOD",
+      decimals: 18
+    }
+  },
   explorer: "https://explorer.testnet.chain.robinhood.com",
   rpcs: ["https://rpc.testnet.chain.robinhood.com"]
 };
@@ -1251,9 +1428,21 @@ var ROBINHOOD_FORK = {
   sherwood: {
     factory: "0x02bc9B9C1A4322D5A5df86DadA0a2a02e45108B9",
     guardianRegistry: "0xdfEe38C4D7595c9c04AdBcaFE01E4Fd6FD6117f4",
+    stakedWood: "0xD3037D28693cc7BB3DbF1E17B6e01C4ce628f6DF",
     vaultImpl: "0x9BF51da59B13746e6cCeb1b35c398EDA9776a4Dc",
     batchExecutorLib: "0xdBdBce2af4222Abe0cCDAc05f84364a50577B5a2",
-    strategyFactory: "0xb3C009aECAeDd5ccC62Ec12eDAAA55F19C4A1eFb"
+    strategyFactory: "0xb3C009aECAeDd5ccC62Ec12eDAAA55F19C4A1eFb",
+    // Guardian-era contracts from sherwood-protocol/chains/9994663.json (SHE-93).
+    governorBeacon: "0x2e8aB422Db9127F1a70d8C38A15903f22B51DA97",
+    protocolConfig: "0x36C45dC52FbC267d8536E8456ADe5255eC83A5ab",
+    // Not in chains/9994663.json (no PriceRouter / CallSandbox on the fork).
+    priceRouter: ZERO_ADDRESS,
+    tierRegistry: "0x42B089B816F994d792481fAa308199E9CF63be9f",
+    callSandboxImpl: ZERO_ADDRESS,
+    exposureLedger: "0x223e2Fd41aD6487333146fc3998d000E74CB1549",
+    proposerBondEscrow: "0xef2D6994faCad11e6CfAF3DaBf7b0B2091009B05",
+    challengeGame: "0x202c1F133006D6706e872433CCAfD729c7A8AE56",
+    tokenCourt: "0x5DC603881f5d77f41bbd4202F1d518263Dfd497f"
   },
   // No ERC-8004 registry and no EAS path on the Robinhood fork.
   identityRegistry: ZERO_ADDRESS,
@@ -1263,6 +1452,11 @@ var ROBINHOOD_FORK = {
       address: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
       symbol: "WETH",
       decimals: 18
+    },
+    wood: {
+      address: "0xF8BC08092C06dB6148114DCf82AF881F1085f92b",
+      symbol: "WOOD",
+      decimals: 18
     }
   },
   // A Tenderly vnet scopes its blocks under /explorer/vnet/<id> — the bare
@@ -1689,6 +1883,155 @@ function encodePropose(args, chainId) {
     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."
   };
 }
+var MAX_SANDBOX_CALLS = 32;
+var MAX_SANDBOX_TOKENS = 16;
+function validateSandboxCall(call, idx) {
+  if (!call || typeof call !== "object") {
+    throw usage(`\`sandbox.calls[${idx}]\` must be an object of {target, data}`);
+  }
+  const c = call;
+  if ("value" in c && c.value !== void 0 && c.value !== null) {
+    throw usage(`\`sandbox.calls[${idx}]\` must be (address,bytes) only \u2014 ICallSandbox.Call has no \`value\` field (native value would open an unmetered transfer channel). Do not alias BatchExecutorLib.Call.`);
+  }
+  if (typeof c.target !== "string" || !isAddress(c.target)) {
+    throw usage(`\`sandbox.calls[${idx}].target\` must be a 0x-prefixed address`);
+  }
+  if (getAddress2(c.target) === ZERO_ADDRESS2) {
+    throw usage(`\`sandbox.calls[${idx}].target\` must not be the zero address (the governor reverts ZeroSandboxTarget)`);
+  }
+  if (typeof c.data !== "string" || !/^0x[0-9a-fA-F]*$/.test(c.data)) {
+    throw usage(`\`sandbox.calls[${idx}].data\` must be a 0x-prefixed hex string`);
+  }
+  return { target: getAddress2(c.target), data: c.data };
+}
+function validateSandboxPayload(sandbox, maxCapital) {
+  if (!sandbox || typeof sandbox !== "object") {
+    throw usage("`sandbox` must be an object of {funding, calls, declaredTokens}");
+  }
+  const s = sandbox;
+  const funding = toBigInt(s.funding, "sandbox.funding");
+  if (funding === 0n) {
+    throw usage("`sandbox.funding` must be > 0 (the governor rejects zero as ZeroSandboxFunding)");
+  }
+  if (funding > maxCapital) {
+    throw usage(`\`sandbox.funding\` (${funding}) exceeds \`envelope.maxCapital\` (${maxCapital}) \u2014 the sandbox is funded out of the declared envelope, not beside it`);
+  }
+  if (!Array.isArray(s.calls)) {
+    throw usage("`sandbox.calls` must be an array of {target, data} objects (no value)");
+  }
+  if (s.calls.length === 0) {
+    throw usage("`sandbox.calls` must be non-empty (the governor rejects empty as EmptySandboxCalls)");
+  }
+  if (s.calls.length > MAX_SANDBOX_CALLS) {
+    throw usage(`\`sandbox.calls\` has ${s.calls.length} entries; max is ${MAX_SANDBOX_CALLS}`);
+  }
+  const calls = s.calls.map((c, i) => validateSandboxCall(c, i));
+  const rawTokens = s.declaredTokens ?? [];
+  if (!Array.isArray(rawTokens)) {
+    throw usage("`sandbox.declaredTokens` must be an array of addresses");
+  }
+  if (rawTokens.length > MAX_SANDBOX_TOKENS) {
+    throw usage(`\`sandbox.declaredTokens\` has ${rawTokens.length} entries; max is ${MAX_SANDBOX_TOKENS}`);
+  }
+  const declaredTokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rawTokens.length; i++) {
+    const t = rawTokens[i];
+    if (typeof t !== "string" || !isAddress(t)) {
+      throw usage(`\`sandbox.declaredTokens[${i}]\` must be a 0x-prefixed address`);
+    }
+    const addr = getAddress2(t);
+    if (seen.has(addr.toLowerCase())) {
+      throw usage(`\`sandbox.declaredTokens[${i}]\` duplicates ${addr} (the governor reverts DuplicateSandboxToken)`);
+    }
+    seen.add(addr.toLowerCase());
+    declaredTokens.push(addr);
+  }
+  return { funding, calls, declaredTokens };
+}
+function encodeProposeWithSandbox(args, chainId) {
+  const vault = getAddress2(args.vault);
+  const governor = parseGovernor(args.governor);
+  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://...)");
+  }
+  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 };
+  });
+  if (!args.envelope || typeof args.envelope !== "object") {
+    throw usage("`envelope` must be an object of {maxCapital, maxDrawdownBps}");
+  }
+  const maxCapital = toBigInt(args.envelope.maxCapital, "envelope.maxCapital");
+  if (maxCapital === 0n) {
+    throw usage("`envelope.maxCapital` must be > 0 (the governor rejects zero as ZeroMaxCapital)");
+  }
+  const maxDrawdownBps = args.envelope.maxDrawdownBps;
+  if (!Number.isInteger(maxDrawdownBps) || maxDrawdownBps < 0 || maxDrawdownBps > 1e4) {
+    throw usage("`envelope.maxDrawdownBps` must be an integer in [0, 10000]");
+  }
+  const executeCallCaps = validateCaps(args.executeCallCaps, executeCalls, maxCapital, "executeCallCaps");
+  const settlementCallCaps = validateCaps(args.settlementCallCaps, settlementCalls, maxCapital, "settlementCallCaps");
+  const sandbox = validateSandboxPayload(args.sandbox, maxCapital);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "proposeWithSandbox",
+    args: [
+      sandbox,
+      vault,
+      strategy2,
+      args.metadataURI,
+      strategyDuration,
+      { maxCapital, maxDrawdownBps },
+      executeCalls,
+      executeCallCaps,
+      settlementCalls,
+      settlementCallCaps,
+      coProposers
+    ]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Propose a sandbox strategy on ${vault} (funding ${sandbox.funding.toString()}, ${sandbox.calls.length} sandbox call(s), duration ${strategyDuration.toString()}s).`,
+    note: "Reverts if the vault has an active proposal, has no CallSandbox implementation bound, or the payload fails propose-time sandbox gates (empty calls, zero funding, funding > maxCapital, zero target, duplicate declared tokens). ICallSandbox.Call is (address,bytes) only \u2014 no native value."
+  };
+}
 function encodeUnstick(args, chainId) {
   const governor = parseGovernor(args.governor);
   const id = parseProposalId(args.proposalId);
@@ -2057,6 +2400,13 @@ function encodeApproveAgent(args, chainId) {
 // ../sdk/dist/encoders/guardian.js
 import { encodeFunctionData as encodeFunctionData7, getAddress as getAddress7 } from "viem";
 var ZERO_VALUE5 = "0x0";
+function swoodTx(chainId, data) {
+  const swood2 = getDeployment(chainId).sherwood.stakedWood;
+  if (swood2 === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`sWOOD (StakedWood) is not deployed on chain ${chainId} yet`);
+  }
+  return { to: swood2, data, value: ZERO_VALUE5, chainId };
+}
 function registryTx(chainId, data) {
   const registry = getDeployment(chainId).sherwood.guardianRegistry;
   if (registry === "0x0000000000000000000000000000000000000000") {
@@ -2086,26 +2436,31 @@ function encodeGuardianStake(args, chainId) {
     throw usage("`amount` must be > 0");
   const agentId = parseUint(args.agentId, "agentId");
   const data = encodeFunctionData7({
-    abi: GUARDIAN_REGISTRY_ABI,
+    abi: STAKED_WOOD_ABI,
     functionName: "stakeAsGuardian",
     args: [args.amount, agentId]
   });
-  const registry = getDeployment(chainId).sherwood.guardianRegistry;
+  const deployment = getDeployment(chainId);
+  const wood2 = deployment.tokens.wood?.address;
+  const swood2 = deployment.sherwood.stakedWood;
+  if (!wood2 || wood2 === "0x0000000000000000000000000000000000000000" || swood2 === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`WOOD / sWOOD is not deployed on chain ${chainId} yet`);
+  }
   return {
-    txs: [registryTx(chainId, data)],
+    txs: [swoodTx(chainId, data)],
     preconditions: [
-      // Caller must have approved WOOD for the registry; agent should
+      // Caller must have approved WOOD for sWOOD (StakedWood); agent should
       // check this client-side and prepend an ERC20.approve if needed.
       {
         type: "allowance",
-        token: registry,
-        spender: registry,
+        token: wood2,
+        spender: swood2,
         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."
+    note: "Caller must have approved WOOD for sWOOD (StakedWood) first. Stake locks the WOOD; use /prepare/guardian-unstake later to start the 7d unstake cooldown."
   };
 }
 var GUARDIAN_UNSTAKE_FN = {
@@ -2130,59 +2485,29 @@ function encodeGuardianUnstake(args, chainId) {
     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(", ")}`);
+function encodeVoteOnProposal(args, chainId) {
+  let governor;
+  try {
+    governor = getAddress7(args.governor);
+  } catch {
+    throw usage("`governor` must be a 0x-prefixed 40-char hex address");
   }
-  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 support = GUARDIAN_VOTE_TYPES.indexOf(args.vote);
+  if (support <= 0) {
+    throw usage("`vote` must be one of: Approve, Block");
   }
+  const proposalId = parseUint(args.proposalId, "proposalId");
   const data = encodeFunctionData7({
     abi: GUARDIAN_REGISTRY_ABI,
-    functionName: "setCommission",
-    args: [args.bps]
+    functionName: "voteOnProposal",
+    args: [governor, proposalId, support]
   });
+  const underwriting = args.vote === "Approve" ? " APPROVE books coverage against the CALLER'S OWN slashable guardian bond (ExposureLedger.recordApproval). If this proposal is later challenged or slashed, your WOOD stake is at risk \u2014 not another guardian's. An over-exposed guardian books nothing rather than reverting; the vote still lands." : " Block votes do not book coverage. Slash severity is computed at resolveReview from block-side decisiveness.";
   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."
+    description: `Guardian review vote ${args.vote} on proposal ${proposalId.toString()} (governor ${governor}).`,
+    note: `voteOnProposal(governor, proposalId, vote) \u2014 3 args, selector 0x3ad95b6d, no slashBps.${underwriting}`
   };
 }
 
@@ -2196,7 +2521,7 @@ var DIM = chalk.gray;
 var BOLD = chalk.white.bold;
 var LABEL = chalk.green.bold;
 var SEP = () => console.log(DIM("\u2500".repeat(60)));
-var STAKED_WOOD_ABI = [
+var STAKED_WOOD_ABI2 = [
   // Guardian stake
   { type: "function", name: "stakeAsGuardian", inputs: [{ type: "uint256" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
   // Owner bond (required before SyndicateFactory.createSyndicate)
@@ -2204,19 +2529,9 @@ var STAKED_WOOD_ABI = [
   { type: "function", name: "requestUnstakeGuardian", inputs: [], outputs: [], stateMutability: "nonpayable" },
   { type: "function", name: "cancelUnstakeGuardian", inputs: [], outputs: [], stateMutability: "nonpayable" },
   { type: "function", name: "claimUnstakeGuardian", inputs: [], outputs: [], stateMutability: "nonpayable" },
-  // Delegation
-  { type: "function", name: "delegateStake", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
-  { type: "function", name: "requestUnstakeDelegation", inputs: [{ type: "address" }], outputs: [], stateMutability: "nonpayable" },
-  { type: "function", name: "cancelUnstakeDelegation", inputs: [{ type: "address" }], outputs: [], stateMutability: "nonpayable" },
-  { type: "function", name: "claimUnstakeDelegation", inputs: [{ type: "address" }], outputs: [], stateMutability: "nonpayable" },
-  // Commission
-  { type: "function", name: "setCommission", inputs: [{ type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
   // Views
   { type: "function", name: "guardianStake", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "isActiveGuardian", inputs: [{ type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" },
-  { type: "function", name: "commissionOf", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "delegationOf", inputs: [{ type: "address" }, { type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "delegatedInbound", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" }
+  { type: "function", name: "isActiveGuardian", inputs: [{ type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" }
 ];
 var ERC20_ABI3 = [
   { type: "function", name: "approve", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" },
@@ -2267,8 +2582,8 @@ async function ensureWoodAllowance(amount, spender, label = "WOOD") {
   }
 }
 function registerGuardianCommands(program2) {
-  const guardian = program2.command("guardian").description("Guardian staking, delegation, and rewards (V1.5)");
-  guardian.command("status [address]").description("Show guardian stake + commission + active status for an address (default: caller)").action(async (addressArg) => {
+  const guardian = program2.command("guardian").description("Guardian staking and rewards");
+  guardian.command("status [address]").description("Show guardian stake + active status for an address (default: caller)").action(async (addressArg) => {
     const pc = getPublicClient();
     let target;
     if (addressArg) {
@@ -2283,17 +2598,10 @@ function registerGuardianCommands(program2) {
     }
     const spinner = ora("Loading...").start();
     try {
-      const [stake, active, commission] = await Promise.all([
-        pc.readContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: "guardianStake", args: [target] }),
-        pc.readContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: "isActiveGuardian", args: [target] }),
-        pc.readContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: "commissionOf", args: [target] })
+      const [stake, active] = await Promise.all([
+        pc.readContract({ address: swood(), abi: STAKED_WOOD_ABI2, functionName: "guardianStake", args: [target] }),
+        pc.readContract({ address: swood(), abi: STAKED_WOOD_ABI2, functionName: "isActiveGuardian", args: [target] })
       ]);
-      const delegatedIn = await pc.readContract({
-        address: swood(),
-        abi: STAKED_WOOD_ABI,
-        functionName: "delegatedInbound",
-        args: [target]
-      });
       spinner.stop();
       console.log();
       console.log(LABEL("  \u25C6 Guardian Status"));
@@ -2301,8 +2609,6 @@ function registerGuardianCommands(program2) {
       console.log(W(`  Address:              ${G(target)}`));
       console.log(W(`  Active guardian:      ${active ? G("yes") : DIM("no")}`));
       console.log(W(`  Own stake:            ${BOLD(formatUnits3(stake, 18))} WOOD`));
-      console.log(W(`  Delegated inbound:    ${BOLD(formatUnits3(delegatedIn, 18))} WOOD`));
-      console.log(W(`  Commission:           ${BOLD(`${Number(commission) / 100}%`)}`));
       SEP();
       console.log();
     } catch (err) {
@@ -2339,7 +2645,7 @@ function registerGuardianCommands(program2) {
     try {
       const hash = await wallet.writeContract({
         address: swood(),
-        abi: STAKED_WOOD_ABI,
+        abi: STAKED_WOOD_ABI2,
         functionName: "stakeAsGuardian",
         args: [amount, agentId],
         chain: null,
@@ -2364,7 +2670,7 @@ function registerGuardianCommands(program2) {
     try {
       const hash = await wallet.writeContract({
         address: swood(),
-        abi: STAKED_WOOD_ABI,
+        abi: STAKED_WOOD_ABI2,
         functionName: "prepareOwnerStake",
         args: [amount],
         chain: null,
@@ -2394,7 +2700,7 @@ function registerGuardianCommands(program2) {
     const pc = getPublicClient();
     const spinner = ora(`${action}...`).start();
     try {
-      const hash = await wallet.writeContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: fn, args: [], chain: null, account: wallet.account });
+      const hash = await wallet.writeContract({ address: swood(), abi: STAKED_WOOD_ABI2, functionName: fn, args: [], chain: null, account: wallet.account });
       await pc.waitForTransactionReceipt({ hash });
       spinner.succeed(`${action} confirmed. Tx: ${hash}`);
     } catch (err) {
@@ -2403,80 +2709,6 @@ function registerGuardianCommands(program2) {
       process.exit(1);
     }
   });
-  guardian.command("delegate <delegate> <amount>").description("Delegate WOOD stake to a guardian. Amount in WOOD.").action(async (delegate, amountStr) => {
-    if (!isAddress2(delegate)) {
-      console.error(chalk.red("Invalid delegate address"));
-      process.exit(1);
-    }
-    const amount = parseUnits(amountStr, 18);
-    if (isCalldataOnly()) {
-      emitCalldata(encodeGuardianDelegate({ delegate, amount }, getChain().id));
-      return;
-    }
-    await ensureWoodAllowance(amount);
-    const wallet = getWalletClient();
-    const pc = getPublicClient();
-    const spinner = ora(`Delegating ${amountStr} WOOD to ${delegate}...`).start();
-    try {
-      const hash = await wallet.writeContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: "delegateStake", args: [delegate, amount], chain: null, account: wallet.account });
-      await pc.waitForTransactionReceipt({ hash });
-      spinner.succeed(`Delegated. Tx: ${hash}`);
-    } catch (err) {
-      spinner.fail("Delegation failed");
-      console.error(chalk.red(formatContractError(err)));
-      process.exit(1);
-    }
-  });
-  guardian.command("undelegate <delegate> <action>").description("Unstake-delegation flow: 'request' | 'cancel' | 'claim'").action(async (delegate, action) => {
-    if (!isAddress2(delegate)) {
-      console.error(chalk.red("Invalid delegate address"));
-      process.exit(1);
-    }
-    const fn = { request: "requestUnstakeDelegation", cancel: "cancelUnstakeDelegation", claim: "claimUnstakeDelegation" }[action];
-    if (!fn) {
-      console.error(chalk.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 = ora(`${action}...`).start();
-    try {
-      const hash = await wallet.writeContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: fn, args: [delegate], chain: null, account: wallet.account });
-      await pc.waitForTransactionReceipt({ hash });
-      spinner.succeed(`${action} confirmed. Tx: ${hash}`);
-    } catch (err) {
-      spinner.fail(`${action} failed`);
-      console.error(chalk.red(formatContractError(err)));
-      process.exit(1);
-    }
-  });
-  guardian.command("set-commission <bps>").description("Set your commission rate in bps (0-5000 = 0-50%). Raises capped cumulatively at 500 bps/epoch.").action(async (bpsStr) => {
-    const bps = BigInt(bpsStr);
-    if (bps > 5000n) {
-      console.error(chalk.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 = ora(`Setting commission to ${Number(bps) / 100}%...`).start();
-    try {
-      const hash = await wallet.writeContract({ address: swood(), abi: STAKED_WOOD_ABI, functionName: "setCommission", args: [bps], chain: null, account: wallet.account });
-      await pc.waitForTransactionReceipt({ hash });
-      spinner.succeed(`Commission set. Tx: ${hash}`);
-    } catch (err) {
-      spinner.fail("setCommission failed");
-      console.error(chalk.red(formatContractError(err)));
-      process.exit(1);
-    }
-  });
   guardian.command("claim-wood").description("Open merkl.xyz to claim guardian WOOD rewards (block-rewards + guardian fees, off-chain distribution).").action(async () => {
     const wallet = getWalletClient();
     const addr = wallet.account.address;
@@ -2562,7 +2794,85 @@ function resolveTemplate(key) {
   }
   return { def, address };
 }
-async function resolveChainInputsForTemplate(templateKey, opts) {
+async function resolvePortfolioFeeTiers(opts, deps) {
+  if (!opts.tokens || !opts.weights || !opts.amount || opts.feeTier) return {};
+  if (UNISWAP().QUOTER_V2 === ZERO) return {};
+  const tokens = TOKENS();
+  const tokenSpecs = opts.tokens.split(",").map((t) => t.trim());
+  const tokenAddrs = tokenSpecs.map((spec) => {
+    if (isAddress3(spec)) return spec;
+    const resolved = tokens[spec.toUpperCase()];
+    return resolved && resolved !== ZERO ? resolved : null;
+  });
+  const weightsBps = opts.weights.split(",").map((w) => Number(w.trim()));
+  if (tokenAddrs.length !== weightsBps.length) return {};
+  if (weightsBps.some((w) => !Number.isFinite(w) || w < 0)) return {};
+  const assetSymbol = opts.asset || defaultPortfolioAsset();
+  let asset;
+  let totalAmount;
+  try {
+    asset = resolveToken(assetSymbol);
+    totalAmount = parseUnits2(opts.amount, assetDecimalsForSymbol(assetSymbol));
+  } catch {
+    return {};
+  }
+  const swapRouteOverrides = parseAlignedOverrides(
+    opts.swapRoutes,
+    tokenAddrs.length
+  ).values;
+  console.log(chalk2.dim("  Quoting v3 fee tiers for best execution..."));
+  const portfolioFeeTiers = [];
+  for (let i = 0; i < tokenAddrs.length; i++) {
+    const token = tokenAddrs[i];
+    if (!token || swapRouteOverrides[i] || token.toLowerCase() === asset.toLowerCase()) {
+      portfolioFeeTiers.push(null);
+      continue;
+    }
+    const legAmount = totalAmount * BigInt(Math.round(weightsBps[i])) / 10000n;
+    const best = await selectBestFeeTier(
+      {
+        tokenIn: asset,
+        tokenOut: token,
+        amountIn: legAmount > 0n ? legAmount : 1n,
+        preferredFeeTier: DEFAULT_FEE_TIER
+      },
+      deps
+    );
+    if (!best) {
+      console.warn(
+        chalk2.yellow(
+          `    ${tokenSpecs[i]}: no fee tier quoted \u2014 falling back to fee ${DEFAULT_FEE_TIER}`
+        )
+      );
+      portfolioFeeTiers.push(null);
+      continue;
+    }
+    const others = best.quoted.filter((q) => q.feeTier !== best.feeTier).map((q) => `${q.feeTier}: ${q.amountOut}`).join(", ");
+    console.log(
+      chalk2.dim(
+        `    ${tokenSpecs[i]}: fee ${best.feeTier} (out ${best.amountOut}` + (others ? `; beat ${others}` : "; only tier that quoted") + `)`
+      )
+    );
+    portfolioFeeTiers.push({
+      feeTier: best.feeTier,
+      routeDesc: `direct (fee ${best.feeTier}, best of ${best.quoted.length} quoted)`
+    });
+  }
+  return { portfolioFeeTiers };
+}
+async function resolveChainInputsForTemplate(templateKey, opts, deps = {}) {
+  if (templateKey === "portfolio") {
+    try {
+      return await resolvePortfolioFeeTiers(opts, deps);
+    } catch (err) {
+      console.warn(
+        chalk2.yellow(
+          `  Fee-tier quoting unavailable (${err instanceof Error ? err.message : String(err)}) \u2014 using default tier ${DEFAULT_FEE_TIER}`
+        )
+      );
+      return {};
+    }
+  }
   if (templateKey === "venice-inference") {
     if (!opts.amount) return {};
     const assetSymbol = opts.asset || "USDC";
@@ -2837,7 +3147,7 @@ function registerStrategyProposeCommands(strategy2) {
         process.exit(1);
       }
       if (!opts.agent) opts.agent = proposer;
-      const { parseDuration: parseDuration3, getGovernorOf: getGovernorOf2 } = await import("./governor-GSCXEZWI.js");
+      const { parseDuration: parseDuration3, getGovernorOf: getGovernorOf2 } = await import("./governor-7QKGNHMR.js");
       const strategyDuration2 = parseDuration3(opts.duration);
       const chainId = getChain().id;
       try {
@@ -3068,9 +3378,9 @@ function registerStrategyProposeCommands(strategy2) {
       console.error(chalk3.red("Missing --name or --duration. Use --write-calls to skip proposal submission."));
       process.exit(1);
     }
-    const { propose: propose2 } = await import("./governor-GSCXEZWI.js");
+    const { propose: propose2 } = await import("./governor-7QKGNHMR.js");
     const { pinJSON } = await import("./ipfs-EJ7IHXCU.js");
-    const { parseDuration: parseDuration2 } = await import("./governor-GSCXEZWI.js");
+    const { parseDuration: parseDuration2 } = await import("./governor-7QKGNHMR.js");
     const strategyDuration = parseDuration2(opts.duration);
     const metaSpinner = ora2("Pinning metadata to IPFS...").start();
     let metadataURI;
@@ -3102,7 +3412,7 @@ function registerStrategyProposeCommands(strategy2) {
       metadataURI = `data:application/json;base64,${Buffer.from(inline).toString("base64")}`;
     }
     try {
-      const { getAgentFeeBps: getAgentFeeBps2 } = await import("./vault-VDADZFSV.js");
+      const { getAgentFeeBps: getAgentFeeBps2 } = await import("./vault-UCFFOOTS.js");
       const feeBps = await getAgentFeeBps2(vault);
       console.log(
         chalk3.yellow(
@@ -3373,7 +3683,7 @@ function registerStrategyTemplateCommands(strategy2) {
       let prices = [];
       let priceSource = null;
       try {
-        const { getTokenPricesInAsset } = await import("./price-OUL7WIXQ.js");
+        const { getTokenPricesInAsset } = await import("./price-SVF25X4O.js");
         prices = await getTokenPricesInAsset({
           tokens: allocations.map((a, i) => ({
             token: a.token,
@@ -3803,10 +4113,10 @@ function registerVeniceCommands(program2) {
       console.log(chalk5.dim(`  Key: ${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`));
       console.log(chalk5.dim("  Saved to ~/.sherwood/config.json"));
       try {
-        const { createVeniceProvisionAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-32PEJETG.js");
-        const { uid } = await createVeniceProvisionAttestation(account.address);
-        if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
-          console.log(chalk5.dim(`  Attested: ${getEasScanUrl2(uid)}`));
+        const { createVeniceProvisionAttestation, getEasScanUrl } = await import("./eas-QPKX6A5A.js");
+        const attestation = await createVeniceProvisionAttestation(account.address);
+        if (attestation) {
+          console.log(chalk5.dim(`  Attested: ${getEasScanUrl(attestation.uid)}`));
         }
       } catch {
       }
@@ -4159,21 +4469,21 @@ ${opts.prompt}`;
         console.log(chalk5.dim(`Model: ${result.model} | Tokens: ${result.usage.promptTokens} in, ${result.usage.completionTokens} out, ${result.usage.totalTokens} total`));
       }
       try {
-        const { createVeniceInferenceAttestation, getEasScanUrl: getEasScanUrl2 } = await import("./eas-32PEJETG.js");
+        const { createVeniceInferenceAttestation, getEasScanUrl } = await import("./eas-QPKX6A5A.js");
         const { keccak256: keccak2563, toHex, isAddress: isAddr } = await import("viem");
         const { getChainContracts: getChainContracts2 } = await import("./config-ZGFS4I7K.js");
-        const { getChain: getActiveChain } = await import("./network-HCFCNZUI.js");
+        const { getChain: getActiveChain } = await import("./network-FEHRFDPJ.js");
         const vaultRecipient = opts.vault && isAddr(opts.vault) ? opts.vault : getChainContracts2(getActiveChain().id).vault;
         const promptHash = keccak2563(toHex(userContent)).slice(0, 18);
-        const { uid } = await createVeniceInferenceAttestation(
+        const attestation = await createVeniceInferenceAttestation(
           result.model,
           result.usage.promptTokens,
           result.usage.completionTokens,
           promptHash,
           vaultRecipient
         );
-        if (uid !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
-          console.log(chalk5.dim(`Attested: ${getEasScanUrl2(uid)}`));
+        if (attestation) {
+          console.log(chalk5.dim(`Attested: ${getEasScanUrl(attestation.uid)}`));
         }
       } catch {
       }
@@ -5806,8 +6116,8 @@ function printSimulationResult(result, callType) {
 }
 async function sendSimulationAlert(subdomain, proposalId, vault, execResult, settleResult) {
   try {
-    const xmtp = await import("./xmtp-2U7CSBXM.js");
-    const { getAccount: getAccount2 } = await import("./client-OPZ2ORWW.js");
+    const xmtp = await import("./xmtp-S7IGTIMZ.js");
+    const { getAccount: getAccount2 } = await import("./client-3SE632Q2.js");
     const group = await xmtp.getGroup("", subdomain);
     const allRisks = [...execResult.risks, ...settleResult?.risks ?? []];
     const criticals = allRisks.filter((r) => r.level === "critical");
@@ -5916,6 +6226,48 @@ function parseCallsFile(path) {
     value: BigInt(c.value || "0")
   }));
 }
+function parseSandboxCallsFile(path) {
+  const raw = readFileSync2(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    console.error(chalk9.red("  sandbox calls file must be a JSON array of {target, data} objects"));
+    process.exit(1);
+  }
+  return parsed.map((c, i) => {
+    if (!c || typeof c !== "object") {
+      console.error(chalk9.red(`  sandbox.calls[${i}] must be an object`));
+      process.exit(1);
+    }
+    const rec = c;
+    if (rec.value !== void 0 && rec.value !== null) {
+      console.error(
+        chalk9.red(
+          `  sandbox.calls[${i}] must be (address,bytes) only \u2014 ICallSandbox.Call has no value field.`
+        )
+      );
+      process.exit(1);
+    }
+    if (typeof rec.target !== "string" || !isAddress9(rec.target)) {
+      console.error(chalk9.red(`  sandbox.calls[${i}].target must be a 0x-prefixed address`));
+      process.exit(1);
+    }
+    if (typeof rec.data !== "string" || !/^0x[0-9a-fA-F]*$/.test(rec.data)) {
+      console.error(chalk9.red(`  sandbox.calls[${i}].data must be a 0x-prefixed hex string`));
+      process.exit(1);
+    }
+    return { target: rec.target, data: rec.data };
+  });
+}
+function parseSandboxTokens(list) {
+  if (list === void 0 || list.trim().length === 0) return [];
+  return list.split(",").map((x) => x.trim()).filter((x) => x.length > 0).map((a, i) => {
+    if (!isAddress9(a)) {
+      console.error(chalk9.red(`  --sandbox-tokens[${i}] is not a 0x-prefixed address: ${a}`));
+      process.exit(1);
+    }
+    return a;
+  });
+}
 var GUARDIAN_REGISTRY_ABI2 = [
   {
     type: "function",
@@ -5924,6 +6276,17 @@ var GUARDIAN_REGISTRY_ABI2 = [
     outputs: [{ type: "bool" }],
     stateMutability: "nonpayable"
   },
+  {
+    // Permissionless keeper entrypoint (SHE-162): opens the guardian review
+    // once `block.timestamp >= voteEnd`. Idempotent on-chain
+    // (`if (r.opened || r.resolved) return;`), so keeper races are harmless.
+    // No outputs — matches GuardianRegistry.openReview(address,uint256).
+    type: "function",
+    name: "openReview",
+    inputs: [{ name: "governor", type: "address" }, { name: "proposalId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
   {
     type: "function",
     name: "getReviewState",
@@ -5934,8 +6297,30 @@ var GUARDIAN_REGISTRY_ABI2 = [
       { name: "blocked", type: "bool" }
     ],
     stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "voteOnProposal",
+    inputs: [
+      { name: "governor", type: "address" },
+      { name: "proposalId", type: "uint256" },
+      { name: "support", type: "uint8" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
   }
 ];
+function parseGuardianReviewVote(raw) {
+  const v = String(raw).trim().toLowerCase();
+  if (v === "approve" || v === "yes") return "Approve";
+  if (v === "block" || v === "no") return "Block";
+  throw new Error(`Invalid support "${raw}". Use approve|block.`);
+}
+function formatUsd18(raw) {
+  const n = Number(raw) / 1e18;
+  if (!Number.isFinite(n)) return `${raw.toString()} (USD-18)`;
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
 function getRegistryAddress() {
   const addr = SHERWOOD().GUARDIAN_REGISTRY;
   if (addr === "0x0000000000000000000000000000000000000000") {
@@ -6177,6 +6562,171 @@ function registerProposalCommands(program2) {
       process.exit(1);
     }
   });
+  proposal.command("create-sandbox").description("Submit a strategy proposal with a CallSandbox payload (ICallSandbox.Call is (address,bytes) only \u2014 no value)").requiredOption("--vault <address>", "Vault address the proposal targets").requiredOption("--name <name>", "Strategy name").requiredOption("--description <text>", "Strategy rationale and risk summary").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").requiredOption(
+    "--sandbox-calls <path>",
+    "Path to JSON file of ICallSandbox.Call[] \u2014 [{target, data}, ...]. A value field is refused."
+  ).requiredOption(
+    "--sandbox-funding <amount>",
+    "Vault-asset amount the sandbox is funded with (decimals resolved from the asset). Must be > 0 and <= --max-capital."
+  ).option("--sandbox-tokens <list>", "Comma-separated declared non-asset token addresses the payload may hold").option("--strategy <address>", "Live-NAV strategy clone address (default: none \u2014 queue-only)").option(
+    "--max-capital <amount>",
+    "REQUIRED. Ceiling on what the execute batch may deploy, in vault-asset units."
+  ).option(
+    "--max-drawdown-bps <bps>",
+    "Declared loss allowance in bps of --max-capital (0-10000, default 2000 = 20%)."
+  ).option("--execute-caps <list>", "Comma-separated per-execute-call outflow caps in asset units").option("--settle-caps <list>", "Comma-separated per-settlement-call outflow caps in asset units").option("--metadata-uri <uri>", "Override \u2014 skip IPFS upload and use this URI directly").action(async (opts) => {
+    try {
+      const vault = opts.vault;
+      if (!isAddress9(vault)) {
+        console.error(chalk9.red(`Invalid vault address: ${opts.vault}`));
+        process.exit(1);
+      }
+      const strategyDuration = parseDuration(opts.duration);
+      const executeCalls = parseCallsFile(opts.executeCalls);
+      const settleCalls = parseCallsFile(opts.settleCalls);
+      const sandboxCalls = parseSandboxCallsFile(opts.sandboxCalls);
+      const declaredTokens = parseSandboxTokens(opts.sandboxTokens);
+      const ZERO_STRATEGY = "0x0000000000000000000000000000000000000000";
+      let strategy2 = ZERO_STRATEGY;
+      if (opts.strategy) {
+        if (!isAddress9(opts.strategy)) {
+          console.error(chalk9.red(`Invalid strategy address: ${opts.strategy}`));
+          process.exit(1);
+        }
+        strategy2 = opts.strategy;
+      }
+      const envelope = await resolveRiskEnvelope(opts, vault);
+      const asset = await getAssetAddress();
+      const decimals = await getPublicClient().readContract({
+        address: asset,
+        abi: ERC20_ABI,
+        functionName: "decimals"
+      });
+      const funding = parseUnits8(String(opts.sandboxFunding), decimals);
+      const executeCallCaps = resolveCaps(
+        opts.executeCaps,
+        executeCalls.length,
+        envelope.maxCapital,
+        "--execute-caps"
+      );
+      const settleCallCaps = resolveCaps(
+        opts.settleCaps,
+        settleCalls.length,
+        0n,
+        "--settle-caps"
+      );
+      const buildAction = async (metadataURI2) => encodeProposeWithSandbox(
+        {
+          vault,
+          governor: await getGovernorOf(vault),
+          strategy: strategy2,
+          metadataURI: metadataURI2,
+          strategyDuration,
+          envelope,
+          executeCalls,
+          executeCallCaps,
+          settlementCalls: settleCalls,
+          settlementCallCaps: settleCallCaps,
+          sandbox: { funding, calls: sandboxCalls, declaredTokens }
+        },
+        getChain().id
+      );
+      if (isCalldataOnly()) {
+        if (!opts.metadataUri) {
+          console.error(
+            chalk9.red(
+              "--calldata-only requires --metadata-uri (IPFS metadata upload needs a signing wallet)"
+            )
+          );
+          process.exit(1);
+        }
+        try {
+          emitCalldata(await buildAction(opts.metadataUri));
+        } catch (err) {
+          console.error(chalk9.red(err instanceof Error ? err.message : String(err)));
+          process.exit(1);
+        }
+        return;
+      }
+      let metadataURI = opts.metadataUri || "";
+      if (!metadataURI) {
+        const spinner2 = ora7({ text: W3("Uploading metadata to IPFS..."), color: "green" }).start();
+        try {
+          const account = getAccount();
+          const metadata = {
+            schema: "sherwood/proposal/v1",
+            name: opts.name,
+            description: opts.description,
+            chain: getNetwork(),
+            strategies: [],
+            terms: {},
+            links: {}
+          };
+          const proposalMeta = {
+            ...metadata,
+            proposer: account.address,
+            vault,
+            strategyDuration: Number(strategyDuration),
+            sandbox: true,
+            createdAt: Math.floor(Date.now() / 1e3)
+          };
+          metadataURI = await uploadMetadata(proposalMeta);
+          spinner2.succeed(G3(`Metadata pinned: ${DIM3(metadataURI)}`));
+        } catch (err) {
+          spinner2.warn(chalk9.yellow("IPFS upload failed \u2014 using inline metadata"));
+          const json = JSON.stringify({ name: opts.name, description: opts.description, vault, sandbox: true });
+          metadataURI = `data:application/json;base64,${Buffer.from(json).toString("base64")}`;
+        }
+      }
+      console.log();
+      console.log(LABEL3("  \u25C6 Sandbox Proposal Summary"));
+      SEP3();
+      console.log(W3(`  Name:             ${BOLD3(opts.name)}`));
+      console.log(W3(`  Vault:            ${G3(vault)}`));
+      console.log(W3(`  Duration:         ${formatDurationShort(strategyDuration)}`));
+      console.log(W3(`  Calls:            ${executeCalls.length} execute + ${settleCalls.length} settle + ${sandboxCalls.length} sandbox`));
+      console.log(W3(`  Sandbox funding:  ${opts.sandboxFunding}`));
+      console.log(W3(`  Metadata:         ${DIM3(metadataURI.length > 50 ? metadataURI.slice(0, 50) + "..." : metadataURI)}`));
+      SEP3();
+      const spinner = ora7({ text: W3("Submitting sandbox proposal..."), color: "green" }).start();
+      let action;
+      try {
+        action = await buildAction(metadataURI);
+      } catch (err) {
+        spinner.fail(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      const tx = action.txs[0];
+      const hash = await sendTxWithRetry({
+        account: getAccount(),
+        chain: getChain(),
+        to: tx.to,
+        data: tx.data,
+        value: 0n
+      });
+      const receipt = await waitForReceipt(hash);
+      let proposalId = parseProposalIdFromLogs(receipt.logs);
+      if (proposalId === void 0) {
+        try {
+          proposalId = await proposalCount(vault);
+        } catch {
+          proposalId = 0n;
+        }
+      }
+      spinner.succeed(G3("Sandbox proposal submitted"));
+      console.log();
+      console.log(LABEL3("  \u25C6 Sandbox Proposal Created"));
+      SEP3();
+      console.log(W3(`  Proposal ID:  ${G3(`#${proposalId}`)}`));
+      console.log(W3(`  Tx:           ${DIM3(getExplorerUrl(receipt.transactionHash))}`));
+      SEP3();
+      console.log();
+    } catch (err) {
+      console.error(chalk9.red(`
+  \u2716 ${formatContractError(err)}`));
+      process.exit(1);
+    }
+  });
   proposal.command("list").description("List a vault's proposals (per-vault governor \u2014 IDs are scoped to the vault)").requiredOption("--vault <address>", "Vault whose proposals to list").option("--state <filter>", "Filter by state: draft, pending, approved, executed, settled, all", "all").action(async (opts) => {
     const spinner = ora7("Loading proposals...").start();
     try {
@@ -6365,6 +6915,112 @@ function registerProposalCommands(program2) {
       process.exit(1);
     }
   });
+  proposal.command("review-vote").description("Cast a guardian review vote (Approve or Block) on a live review").requiredOption("--id <proposalId>", "Proposal ID").requiredOption("--vault <address>", "Vault the proposal belongs to (per-vault governor)").requiredOption("--support <approve|block>", "Guardian review vote: approve or block").action(async (opts) => {
+    try {
+      const proposalId = parseBigIntArg(opts.id, "proposal ID");
+      const vault = parseVaultOption(opts.vault);
+      const vote2 = parseGuardianReviewVote(String(opts.support));
+      const chainId = getChain().id;
+      const governor = await getGovernorOf(vault);
+      if (isCalldataOnly()) {
+        emitCalldata(encodeVoteOnProposal({ governor, proposalId, vote: vote2 }, chainId));
+        return;
+      }
+      const account = getAccount();
+      const spinner = ora7("Loading review...").start();
+      const registryAddr = getRegistryAddress();
+      const pc = getPublicClient();
+      const [p, state, reviewState] = await Promise.all([
+        getProposal(vault, proposalId),
+        getProposalState(vault, proposalId),
+        pc.readContract({
+          address: registryAddr,
+          abi: GUARDIAN_REGISTRY_ABI2,
+          functionName: "getReviewState",
+          args: [governor, proposalId]
+        })
+      ]);
+      const [opened, resolved] = reviewState;
+      const now = (await pc.getBlock()).timestamp;
+      spinner.stop();
+      if (!opened) {
+        console.error(chalk9.red(
+          `No live guardian review is open for proposal #${proposalId}. openReview must run (and the shareholder vote must have ended) before guardians can vote.`
+        ));
+        process.exit(1);
+      }
+      if (resolved) {
+        console.error(chalk9.red(`Guardian review for proposal #${proposalId} is already resolved.`));
+        process.exit(1);
+      }
+      if (now < p.voteEnd) {
+        console.error(chalk9.red(
+          `Shareholder vote is still open until ${formatTimestamp(p.voteEnd)}. Guardian review voting starts after voteEnd.`
+        ));
+        process.exit(1);
+      }
+      if (now >= p.reviewEnd) {
+        console.error(chalk9.red(
+          `Review window elapsed at ${formatTimestamp(p.reviewEnd)}. Use \`sherwood proposal resolve-reviews\`.`
+        ));
+        process.exit(1);
+      }
+      console.log();
+      console.log(LABEL3("  \u25C6 Guardian Review Vote"));
+      SEP3();
+      console.log(W3(`  Proposal:           #${proposalId}`));
+      console.log(W3(`  Vault:              ${G3(p.vault)}`));
+      console.log(W3(`  Governor:           ${governor}`));
+      console.log(W3(`  Strategy:           ${p.strategy}`));
+      console.log(W3(`  State:              ${PROPOSAL_STATES[state] || "Unknown"}`));
+      console.log(W3(`  Review ends:        ${formatTimestamp(p.reviewEnd)}`));
+      console.log(W3(
+        `  Support:            ${vote2 === "Approve" ? G3("APPROVE") : chalk9.red("BLOCK")}`
+      ));
+      console.log(W3(`  Max capital:        ${p.maxCapital.toString()} (asset base units)`));
+      console.log(W3(`  Required coverage:  ${formatUsd18(p.requiredCoverage)} (USD)`));
+      console.log(W3(`  Envelope tier:      ${p.envelopeTier}`));
+      console.log(W3(`  Caller:             ${account.address}`));
+      SEP3();
+      if (vote2 === "Approve") {
+        console.log(chalk9.yellow.bold("  \u26A0  UNDERWRITING"));
+        console.log(chalk9.yellow(
+          "  Approve books this proposal's coverage against YOUR own slashable"
+        ));
+        console.log(chalk9.yellow(
+          "  guardian bond (ExposureLedger.recordApproval). If the proposal is"
+        ));
+        console.log(chalk9.yellow(
+          "  later challenged or slashed, your WOOD stake is at risk \u2014 not"
+        ));
+        console.log(chalk9.yellow(
+          "  another guardian's. An over-exposed bond books nothing rather than"
+        ));
+        console.log(chalk9.yellow(
+          "  reverting; the vote still lands and the shortfall shows at execute."
+        ));
+        SEP3();
+      }
+      const action = encodeVoteOnProposal({ governor, proposalId, vote: vote2 }, chainId);
+      const tx = action.txs[0];
+      const voteSpinner = ora7({ text: W3("Submitting review vote..."), color: "green" }).start();
+      const hash = await sendTxWithRetry({
+        account,
+        chain: getChain(),
+        to: tx.to,
+        data: tx.data,
+        value: BigInt(tx.value)
+      });
+      await waitForReceipt(hash);
+      voteSpinner.succeed(G3(`Review vote cast (${vote2})`));
+      console.log(DIM3(`  ${getExplorerUrl(hash)}`));
+      console.log();
+    } catch (err) {
+      console.error(chalk9.red(`
+  \u2716 ${formatContractError(err)}`));
+      process.exit(1);
+    }
+  });
   proposal.command("execute").description("Execute an approved proposal").requiredOption("--id <proposalId>", "Proposal ID").requiredOption("--vault <address>", "Vault the proposal belongs to (per-vault governor)").option("--dry-run", "Simulate execution without sending a transaction").action(async (opts) => {
     try {
       const proposalId = parseBigIntArg(opts.id, "proposal ID");
@@ -6635,6 +7291,113 @@ function registerProposalCommands(program2) {
       process.exit(1);
     }
   });
+  proposal.command("open-reviews").description("Keeper: open guardian reviews whose vote has ended (window [voteEnd, reviewEnd))").requiredOption("--vault <address>", "Vault whose governor's reviews to scan (per-vault governor)").option("--dry-run", "List openable reviews without sending transactions").action(async (opts) => {
+    const spinner = ora7("Scanning proposals for openable reviews...").start();
+    try {
+      const vault = parseVaultOption(opts.vault, spinner);
+      const registryAddr = getRegistryAddress();
+      const pc = getPublicClient();
+      const governorAddr = await getGovernorOf(vault);
+      const count = await proposalCount(vault);
+      if (count === 0n) {
+        spinner.stop();
+        console.log(DIM3("\n  No proposals \u2014 nothing to open.\n"));
+        return;
+      }
+      const now = (await pc.getBlock()).timestamp;
+      const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
+      const { candidates, failures: scanFailures } = await scanReviewCandidates(
+        ids,
+        async (id) => {
+          const [p, reviewState] = await Promise.all([
+            getProposal(vault, id),
+            pc.readContract({
+              address: registryAddr,
+              abi: GUARDIAN_REGISTRY_ABI2,
+              functionName: "getReviewState",
+              args: [governorAddr, id]
+            })
+          ]);
+          const [opened, resolved] = reviewState;
+          const cls = classifyReviewOpen({
+            opened,
+            resolved,
+            voteEnd: p.voteEnd,
+            reviewEnd: p.reviewEnd,
+            now
+          });
+          return { id, cls, reviewEnd: p.reviewEnd, vault: p.vault };
+        }
+      );
+      const openable = candidates.filter((c) => c.cls === "openable");
+      spinner.stop();
+      const scanIncomplete = scanFailures.length > 0;
+      if (scanIncomplete) {
+        console.log();
+        for (const f of scanFailures) {
+          console.log(
+            chalk9.yellow(`  \u26A0 Proposal #${f.id} failed to load: ${formatContractError(f.error)}`)
+          );
+        }
+        console.log(
+          chalk9.yellow(
+            `  \u26A0 ${scanFailures.length} of ${ids.length} proposals failed to load \u2014 treat this run as incomplete.`
+          )
+        );
+      }
+      if (openable.length === 0) {
+        console.log(DIM3("\n  No reviews ready to open.\n"));
+        if (scanIncomplete) process.exit(1);
+        return;
+      }
+      console.log();
+      console.log(LABEL3(`  \u25C6 Openable Guardian Reviews (${openable.length})`));
+      SEP3();
+      for (const c of openable) {
+        console.log(
+          W3(`  Proposal #${c.id}  vault=${c.vault}  reviewEnd=${formatTimestamp(c.reviewEnd)}`)
+        );
+      }
+      SEP3();
+      if (opts.dryRun) {
+        console.log(G3("\n  (dry-run) Not broadcasting. Re-run without --dry-run to open.\n"));
+        if (scanIncomplete) process.exit(1);
+        return;
+      }
+      const openedOk = [];
+      for (const c of openable) {
+        const txSpinner = ora7(`Opening review for proposal #${c.id}...`).start();
+        try {
+          const hash = await writeContractWithRetry({
+            account: getAccount(),
+            chain: getChain(),
+            address: registryAddr,
+            abi: GUARDIAN_REGISTRY_ABI2,
+            functionName: "openReview",
+            args: [governorAddr, c.id]
+          });
+          assertReceiptSuccess(await waitForReceipt(hash));
+          openedOk.push({ id: c.id, hash });
+          txSpinner.succeed(G3(`Proposal #${c.id} review opened`));
+        } catch (err) {
+          txSpinner.fail(`Proposal #${c.id} open failed: ${formatContractError(err)}`);
+        }
+      }
+      console.log();
+      console.log(LABEL3(`  \u25C6 Opened ${openedOk.length}/${openable.length}`));
+      SEP3();
+      for (const r of openedOk) {
+        console.log(W3(`  Proposal #${r.id}  `) + DIM3(getExplorerUrl(r.hash)));
+      }
+      SEP3();
+      console.log();
+      if (openedOk.length < openable.length || scanIncomplete) process.exit(1);
+    } catch (err) {
+      spinner.fail("Failed to scan reviews");
+      console.error(chalk9.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
   proposal.command("resolve-reviews").description("Keeper: resolve guardian reviews whose review window has elapsed").requiredOption("--vault <address>", "Vault whose governor's reviews to scan (per-vault governor)").option("--dry-run", "List resolvable reviews without sending transactions").action(async (opts) => {
     const spinner = ora7("Scanning proposals for resolvable reviews...").start();
     try {
@@ -6650,29 +7413,40 @@ function registerProposalCommands(program2) {
       }
       const now = (await pc.getBlock()).timestamp;
       const ids = Array.from({ length: Number(count) }, (_, i) => BigInt(i + 1));
-      const candidates = await Promise.all(
-        ids.map(async (id) => {
-          try {
-            const [p, reviewState] = await Promise.all([
-              getProposal(vault, id),
-              pc.readContract({
-                address: registryAddr,
-                abi: GUARDIAN_REGISTRY_ABI2,
-                functionName: "getReviewState",
-                args: [governorAddr, id]
-              })
-            ]);
-            const [opened, resolved2] = reviewState;
-            const cls = classifyReview({ opened, resolved: resolved2, reviewEnd: p.reviewEnd, now });
-            return { id, cls, reviewEnd: p.reviewEnd, vault: p.vault };
-          } catch {
-            return { id, cls: "none", reviewEnd: 0n, vault: "0x" };
-          }
-        })
+      const { candidates, failures: scanFailures } = await scanReviewCandidates(
+        ids,
+        async (id) => {
+          const [p, reviewState] = await Promise.all([
+            getProposal(vault, id),
+            pc.readContract({
+              address: registryAddr,
+              abi: GUARDIAN_REGISTRY_ABI2,
+              functionName: "getReviewState",
+              args: [governorAddr, id]
+            })
+          ]);
+          const [opened, resolved2] = reviewState;
+          const cls = classifyReview({ opened, resolved: resolved2, reviewEnd: p.reviewEnd, now });
+          return { id, cls, reviewEnd: p.reviewEnd, vault: p.vault };
+        }
       );
       const resolvable = candidates.filter((c) => c.cls === "resolvable");
       const coldStart = candidates.filter((c) => c.cls === "cold-start");
       spinner.stop();
+      const scanIncomplete = scanFailures.length > 0;
+      if (scanIncomplete) {
+        console.log();
+        for (const f of scanFailures) {
+          console.log(
+            chalk9.yellow(`  \u26A0 Proposal #${f.id} failed to load: ${formatContractError(f.error)}`)
+          );
+        }
+        console.log(
+          chalk9.yellow(
+            `  \u26A0 ${scanFailures.length} of ${ids.length} proposals failed to load \u2014 treat this run as incomplete.`
+          )
+        );
+      }
       if (coldStart.length > 0) {
         console.log();
         console.log(LABEL3(`  \u25C6 Unopened Cold-Start Reviews (${coldStart.length})`));
@@ -6697,6 +7471,7 @@ function registerProposalCommands(program2) {
         } else {
           console.log(DIM3("\n  No opened reviews need an on-chain resolve.\n"));
         }
+        if (scanIncomplete) process.exit(1);
         return;
       }
       console.log();
@@ -6710,6 +7485,7 @@ function registerProposalCommands(program2) {
       SEP3();
       if (opts.dryRun) {
         console.log(G3("\n  (dry-run) Not broadcasting. Re-run without --dry-run to resolve.\n"));
+        if (scanIncomplete) process.exit(1);
         return;
       }
       const resolved = [];
@@ -6731,7 +7507,7 @@ function registerProposalCommands(program2) {
             functionName: "resolveReview",
             args: [governorAddr, c.id]
           });
-          await waitForReceipt(hash);
+          assertReceiptSuccess(await waitForReceipt(hash));
           resolved.push({ id: c.id, blocked, hash });
           txSpinner.succeed(
             G3(`Proposal #${c.id} resolved \u2014 blocked=${blocked ? chalk9.red("true") : "false"}`)
@@ -6750,7 +7526,7 @@ function registerProposalCommands(program2) {
       }
       SEP3();
       console.log();
-      if (resolved.length < resolvable.length) process.exit(1);
+      if (resolved.length < resolvable.length || scanIncomplete) process.exit(1);
     } catch (err) {
       spinner.fail("Failed to scan reviews");
       console.error(chalk9.red(formatContractError(err)));
@@ -10027,9 +10803,9 @@ try {
 } catch {
 }
 var require2 = createRequire(import.meta.url);
-var CLI_VERSION = "0.83.1";
+var CLI_VERSION = "0.84.0";
 async function loadXmtp() {
-  return import("./xmtp-2U7CSBXM.js");
+  return import("./xmtp-S7IGTIMZ.js");
 }
 async function loadCron() {
   return import("./cron-E3UAZF5B.js");
@@ -10652,7 +11428,7 @@ fund.command("add").description("Register an agent on a fund vault (creator only
     if (opts.agentId) {
       agentId = BigInt(opts.agentId);
     } else {
-      const { AGENT_REGISTRY: AGENT_REGISTRY2 } = await import("./addresses-MS6BB7AB.js");
+      const { AGENT_REGISTRY: AGENT_REGISTRY2 } = await import("./addresses-LFYVOPOH.js");
       const registry = AGENT_REGISTRY2().IDENTITY_REGISTRY;
       if (registry === "0x0000000000000000000000000000000000000000") {
         agentId = 0n;
@@ -10858,7 +11634,7 @@ fund.command("join").description("Request to join a fund (creates an EAS attesta
     }
     spinner.text = "Creating join request attestation...";
     const referrerAgentId = opts.ref ? parseInt(opts.ref, 10) : void 0;
-    const { uid, hash } = await createJoinRequest(
+    const joinAttestation = await createJoinRequest(
       fund2.id,
       BigInt(agentId),
       fund2.vault,
@@ -10893,9 +11669,12 @@ fund.command("join").description("Request to join a fund (creates an EAS attesta
     console.log(W6(`  Fund:    ${G6(`${subdomain}.sherwoodagent.eth`)}`));
     console.log(W6(`  Agent ID:     #${agentId}`));
     console.log(W6(`  Creator:      ${DIM6(fund2.creator)}`));
-    console.log(W6(`  Attestation:  ${DIM6(uid)}`));
-    console.log(W6(`  EAS Scan:     ${DIM6(getEasScanUrl(uid))}`));
-    console.log(W6(`  Explorer:     ${DIM6(getEasExplorerUrl(hash))}`));
+    if (joinAttestation) {
+      console.log(W6(`  Attestation:  ${DIM6(joinAttestation.uid)}`));
+      console.log(W6(`  Explorer:     ${DIM6(getEasExplorerUrl(joinAttestation.hash))}`));
+    } else {
+      console.log(W6(`  Attestation:  ${DIM6("skipped on this chain")}`));
+    }
     SEP6();
     console.log(G6("  \u2713 Fund saved to ~/.sherwood/config.json (set as primary)"));
     console.log(G6("  \u2713 The creator can review with:"));
@@ -11056,7 +11835,7 @@ fund.command("approve").description("Approve an agent join request (registers ag
         vaultAddress,
         agentWallet
       );
-      approvalUid = result.uid;
+      approvalUid = result?.uid ?? null;
     }
     try {
       spinner.text = "Adding to chat...";
@@ -11081,8 +11860,9 @@ fund.command("approve").description("Approve an agent join request (registers ag
     SEP6();
     console.log(W6(`  Agent ID:     #${opts.agentId}`));
     console.log(W6(`  Wallet:       ${G6(opts.wallet)}`));
-    console.log(W6(`  Approval:     ${DIM6(approvalUid)}`));
-    console.log(W6(`  EAS Scan:     ${DIM6(getEasScanUrl(approvalUid))}`));
+    console.log(
+      W6(`  Approval:     ${DIM6(approvalUid ?? "skipped on this chain")}`)
+    );
     SEP6();
   } catch (err) {
     spinner.fail("Approval failed");
@@ -11094,8 +11874,12 @@ fund.command("reject").description("Reject a join request by revoking its attest
   const spinner = ora10("Revoking attestation...").start();
   try {
     const hash = await revokeJoinRequest(opts.attestation);
-    spinner.succeed("Join request rejected");
-    console.log(DIM6(`  ${getEasExplorerUrl(hash)}`));
+    if (!hash) {
+      spinner.info("Revocation skipped: attestation writes are disabled on this chain");
+    } else {
+      spinner.succeed("Join request rejected");
+      console.log(DIM6(`  ${getEasExplorerUrl(hash)}`));
+    }
   } catch (err) {
     spinner.fail("Rejection failed");
     console.error(chalk18.red(formatContractError(err)));
@@ -11399,7 +12183,7 @@ vaultCmd.command("redeem").description("Redeem vault shares for the underlying a
 var strategy = program.command("strategy").description("Strategy templates \u2014 list, clone, propose");
 registerStrategyTemplateCommands(strategy);
 program.command("providers").description("List available providers (research + swap routing)").action(async () => {
-  const { listProviders } = await import("./providers-4HQHB7V5.js");
+  const { listProviders } = await import("./providers-BMOHHVUN.js");
   for (const info of listProviders()) {
     console.log(`
 ${info.name} (${info.type})`);
@@ -11409,7 +12193,7 @@ ${info.name} (${info.type})`);
   }
 });
 try {
-  const { registerChatCommands } = await import("./chat-FGTYCJ4B.js");
+  const { registerChatCommands } = await import("./chat-UZ3BBEXV.js");
   registerChatCommands(program);
 } catch {
   program.command("chat <name> [action] [actionArgs...]").description("Fund chat (XMTP) \u2014 requires @xmtp/cli").action(() => {
@@ -11419,7 +12203,7 @@ try {
     process.exit(1);
   });
 }
-var { registerSessionCommands } = await import("./session-SIOJZO6P.js");
+var { registerSessionCommands } = await import("./session-RMAIFRS6.js");
 registerSessionCommands(program);
 registerVeniceCommands(program);
 registerAllowanceCommands(program);
@@ -11428,11 +12212,11 @@ registerProposalCommands(program);
 registerQueueCommands(program);
 registerGovernorCommands(program);
 registerGuardianCommands(program);
-var { registerResearchCommands } = await import("./research-2RWAMWWH.js");
+var { registerResearchCommands } = await import("./research-YSNJ5HTM.js");
 registerResearchCommands(program);
-var { registerAgentCommands } = await import("./agent-C5XZSK7Z.js");
+var { registerAgentCommands } = await import("./agent-TBLC3WNJ.js");
 registerAgentCommands(program);
-var { registerTradeCommands } = await import("./trade-ZEIY3MCL.js");
+var { registerTradeCommands } = await import("./trade-YPLTIS56.js");
 registerTradeCommands(program);
 registerGridCommand(program);
 var configCmd = program.command("config");