@sherwoodagent/cli 0.59.18 → 0.64.1

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";
@@ -281,6 +281,18 @@ 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");
+}
+
 // src/strategies/moonwell-supply-template.ts
 import { encodeAbiParameters, encodeFunctionData } from "viem";
 function buildInitData(underlying, mToken, supplyAmount, minRedeemAmount) {
@@ -1383,11 +1395,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})`));
       }
     }
@@ -1527,6 +1539,29 @@ function registerStrategyTemplateCommands(strategy2) {
       process.exit(1);
     }
     const { def, address: templateAddr } = resolveTemplate(templateKey);
+    if (isCalldataOnly()) {
+      console.error(
+        chalk.red(
+          "strategy propose does not support --calldata-only (it clones + initializes on-chain first; the clone address isn't known until those txs are mined)."
+        )
+      );
+      console.error(
+        chalk.yellow(
+          `
+Keyless flow:
+  1. Build the calls (clone + init still need a signer):
+       sherwood strategy propose ${templateKey} --vault <vault> --write-calls ./calls [template flags]
+     This prints the strategy clone address + writes execute.json / settle.json.
+  2. Emit the propose calldata for your external signer:
+       sherwood proposal create --calldata-only --vault <vault> \\
+         --strategy <clone> --name '...' --description '...' \\
+         --performance-fee <bps> --duration <d> \\
+         --execute-calls ./calls/execute.json --settle-calls ./calls/settle.json \\
+         --metadata-uri ipfs://...`
+        )
+      );
+      process.exit(1);
+    }
     const account = getAccount();
     const preflightSpinner = ora("Preflight checks...").start();
     try {
@@ -2898,121 +2933,1708 @@ function registerAllowanceCommands(program2) {
 import chalk4 from "chalk";
 import ora4 from "ora";
 import { SDK } from "agent0-sdk";
-var IDENTITY_REGISTRY_ABI = [
+
+// ../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);
+
+// ../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: "owner", type: "address" }],
+    inputs: [{ name: "account", type: "address" }],
     outputs: [{ name: "", type: "uint256" }]
   },
   {
-    name: "ownerOf",
+    name: "owner",
     type: "function",
     stateMutability: "view",
-    inputs: [{ name: "tokenId", type: "uint256" }],
+    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: []
   }
 ];
-function getAgent0SDK() {
-  const config = loadConfig();
-  const key = config.privateKey || process.env.PRIVATE_KEY;
-  if (!key) {
-    throw new Error(
-      "Private key not found. Run 'sherwood config set --private-key <key>' or set PRIVATE_KEY env var."
-    );
-  }
-  return new SDK({
-    chainId: getChain().id,
-    rpcUrl: getRpcUrl(),
-    privateKey: key.startsWith("0x") ? key : `0x${key}`
-  });
-}
-function registerIdentityCommands(program2) {
-  const identity = program2.command("identity").description("Manage ERC-8004 agent identity (via Agent0 SDK)");
-  identity.command("mint").description("Register a new ERC-8004 agent identity (required before creating/joining syndicates)").requiredOption("--name <name>", "Agent name (e.g. 'Alpha Seeker Agent')").option("--description <desc>", "Agent description", "Sherwood syndicate agent").option("--image <uri>", "Agent image URI (IPFS recommended)").action(async (opts) => {
-    const account = getAccount();
-    const existingId = getAgentId();
-    if (existingId) {
-      console.log(chalk4.yellow(`You already have an agent identity saved: #${existingId}`));
-      console.log(chalk4.dim("  Minting a new one anyway. The old ID is not affected."));
-      console.log();
-    }
-    const spinner = ora4("Initializing Agent0 SDK...").start();
-    try {
-      const sdk = getAgent0SDK();
-      spinner.text = "Creating agent profile...";
-      const agent = sdk.createAgent(opts.name, opts.description, opts.image);
-      spinner.text = "Registering on-chain (minting ERC-8004 identity)...";
-      const txHandle = await agent.registerOnChain();
-      spinner.text = "Waiting for confirmation...";
-      await txHandle.waitMined();
-      const agentId = agent.agentId;
-      if (!agentId) {
-        spinner.warn("Identity registered but could not read agentId");
-        console.log(chalk4.dim("  Check the transaction on the explorer."));
-        return;
+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" }
+        ]
       }
-      const tokenId = Number(agentId.includes(":") ? agentId.split(":")[1] : agentId);
-      setAgentId(tokenId);
-      spinner.succeed(`Agent identity registered: #${tokenId}`);
-      console.log(chalk4.dim(`  Agent0 ID: ${agentId}`));
-      console.log(chalk4.dim(`  Name:      ${opts.name}`));
-      console.log(chalk4.dim(`  Owner:     ${account.address}`));
-      console.log(chalk4.dim(`  Saved to   ~/.sherwood/config.json`));
-      console.log();
-      console.log(chalk4.green("You can now create syndicates:"));
-      console.log(chalk4.dim(`  sherwood syndicate create --agent-id ${tokenId} --subdomain <name> --name <name>`));
-    } catch (err) {
-      spinner.fail("Failed to register identity");
-      console.error(chalk4.red(formatContractError(err)));
-      process.exit(1);
-    }
-  });
-  identity.command("load").description("Load an existing ERC-8004 agent identity into your config").requiredOption("--id <tokenId>", "Agent token ID to load").action(async (opts) => {
-    const account = getAccount();
-    const client = getPublicClient();
-    const registry2 = AGENT_REGISTRY().IDENTITY_REGISTRY;
-    const tokenId = Number(opts.id);
-    const spinner = ora4(`Verifying ownership of agent #${tokenId}...`).start();
-    try {
-      const owner = await client.readContract({
-        address: registry2,
-        abi: IDENTITY_REGISTRY_ABI,
-        functionName: "ownerOf",
-        args: [BigInt(tokenId)]
-      });
-      if (owner.toLowerCase() !== account.address.toLowerCase()) {
-        spinner.fail(`Agent #${tokenId} is owned by ${owner}, not your wallet`);
-        process.exit(1);
+    ],
+    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" }
+        ]
       }
-      setAgentId(tokenId);
-      spinner.succeed(`Agent #${tokenId} loaded and saved to config`);
-      console.log(chalk4.dim(`  Owner:  ${account.address}`));
-      console.log(chalk4.dim(`  Saved to ~/.sherwood/config.json`));
-    } catch (err) {
-      spinner.fail("Failed to load identity");
-      console.error(chalk4.red(formatContractError(err)));
-      process.exit(1);
-    }
-  });
-  identity.command("find").description("Search ERC-8004 agents by wallet address or name (recover a lost agent ID)").option("--wallet <address>", "Filter by owner / wallet address").option("--name <text>", "Filter by agent name (exact or substring match, depending on registry)").option("--all-chains", "Search across all chains, not just the active one").action(async (opts) => {
-    if (!opts.wallet && !opts.name) {
-      console.error(chalk4.red("Pass --wallet <address> or --name <text> (or both)."));
-      process.exit(1);
-    }
-    const spinner = ora4("Searching ERC-8004 registry...").start();
-    try {
-      const sdk = getAgent0SDK();
-      const filters = {};
-      if (opts.wallet) filters.walletAddress = opts.wallet;
-      if (opts.name) filters.name = opts.name;
-      filters.chains = opts.allChains ? "all" : [getChain().id];
-      const results = await sdk.searchAgents(filters);
-      spinner.stop();
-      if (results.length === 0) {
-        console.log(chalk4.dim("No agents found matching those filters."));
-        console.log(chalk4.dim("If you minted on a different chain, retry with --all-chains."));
+    ],
+    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" }]
+  }
+];
+
+// ../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"
+  },
+  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"
+  },
+  // 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"
+  },
+  // 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 as encodeFunctionData10, getAddress, maxUint256 as maxUint2564 } 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: encodeFunctionData10({
+      abi: ERC20_ABI2,
+      functionName: "approve",
+      args: [spender, amount]
+    }),
+    value: ZERO_VALUE,
+    chainId
+  };
+}
+function encodeDepositTx(vault, assets, receiver, chainId) {
+  return {
+    to: vault,
+    data: encodeFunctionData10({
+      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: encodeFunctionData10({ 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, maxUint2564, chainId));
+  }
+  txs.push(encodeDepositTx(vault, args.assets, receiver, chainId));
+  const minDecimal = formatUnits4(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 formatUnits4(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: encodeFunctionData10({
+          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: encodeFunctionData10({
+          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: encodeFunctionData10({
+          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 encodeFunctionData11, getAddress as getAddress2, isAddress as isAddress4 } 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 = encodeFunctionData11({
+    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 = encodeFunctionData11({
+    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" || !isAddress4(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" || !isAddress4(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 = encodeFunctionData11({
+    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 = encodeFunctionData11({
+    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 = encodeFunctionData11({
+    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 = encodeFunctionData11({
+    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 encodeFunctionData12, 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 = encodeFunctionData12({
+    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/identity.js
+import { encodeFunctionData as encodeFunctionData13, getAddress as getAddress4 } from "viem";
+var ZERO_ADDRESS3 = "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_ADDRESS3) {
+    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: getAddress4(registry2),
+        data: encodeFunctionData13({
+          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 encodeAbiParameters10, encodeFunctionData as encodeFunctionData14, getAddress as getAddress5, parseAbiParameters } from "viem";
+var ZERO_ADDRESS4 = "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: getAddress5(easAddress),
+    data: encodeFunctionData14({
+      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_ADDRESS4) {
+    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 = encodeAbiParameters10(JOIN_REQUEST_PARAMS, [
+    toBig(args.syndicateId),
+    toBig(args.agentId),
+    getAddress5(args.vault),
+    message
+  ]);
+  return {
+    txs: [
+      buildAttestTx(eas.address, eas.schemas.joinRequest, getAddress5(args.creator), data, eas.chainId)
+    ],
+    preconditions: [],
+    description: `Request to join syndicate ${toBig(args.syndicateId).toString()} (vault ${getAddress5(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_ADDRESS4) {
+    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 = encodeAbiParameters10(AGENT_APPROVED_PARAMS, [
+    toBig(args.syndicateId),
+    toBig(args.agentId),
+    getAddress5(args.vault)
+  ]);
+  const attestTx = buildAttestTx(eas.address, eas.schemas.agentApproved, getAddress5(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 encodeFunctionData15, getAddress as getAddress6 } from "viem";
+var ZERO_VALUE4 = "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_VALUE4, 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 = encodeFunctionData15({
+    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 = encodeFunctionData15({
+    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 = getAddress6(args.delegate);
+  const data = encodeFunctionData15({
+    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 = getAddress6(args.delegate);
+  const data = encodeFunctionData15({
+    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 = encodeFunctionData15({
+    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 = encodeFunctionData15({
+    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 = getAddress6(args.delegate);
+  const data = encodeFunctionData15({
+    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 getAddress7 } from "viem";
+
+// src/commands/identity.ts
+var IDENTITY_REGISTRY_ABI2 = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+function getAgent0SDK() {
+  const config = loadConfig();
+  const key = config.privateKey || process.env.PRIVATE_KEY;
+  if (!key) {
+    throw new Error(
+      "Private key not found. Run 'sherwood config set --private-key <key>' or set PRIVATE_KEY env var."
+    );
+  }
+  return new SDK({
+    chainId: getChain().id,
+    rpcUrl: getRpcUrl(),
+    privateKey: key.startsWith("0x") ? key : `0x${key}`
+  });
+}
+function registerIdentityCommands(program2) {
+  const identity = program2.command("identity").description("Manage ERC-8004 agent identity (via Agent0 SDK)");
+  identity.command("mint").description("Register a new ERC-8004 agent identity (required before creating/joining syndicates)").requiredOption("--name <name>", "Agent name (e.g. 'Alpha Seeker Agent')").option("--description <desc>", "Agent description", "Sherwood syndicate agent").option("--image <uri>", "Agent image URI (IPFS recommended)").action(async (opts) => {
+    if (isCalldataOnly()) {
+      emitCalldata(
+        encodeIdentityMint(
+          {
+            name: opts.name,
+            description: opts.description,
+            image: opts.image
+          },
+          getChain().id
+        )
+      );
+      return;
+    }
+    const account = getAccount();
+    const existingId = getAgentId();
+    if (existingId) {
+      console.log(chalk4.yellow(`You already have an agent identity saved: #${existingId}`));
+      console.log(chalk4.dim("  Minting a new one anyway. The old ID is not affected."));
+      console.log();
+    }
+    const spinner = ora4("Initializing Agent0 SDK...").start();
+    try {
+      const sdk = getAgent0SDK();
+      spinner.text = "Creating agent profile...";
+      const agent = sdk.createAgent(opts.name, opts.description, opts.image);
+      spinner.text = "Registering on-chain (minting ERC-8004 identity)...";
+      const txHandle = await agent.registerOnChain();
+      spinner.text = "Waiting for confirmation...";
+      await txHandle.waitMined();
+      const agentId = agent.agentId;
+      if (!agentId) {
+        spinner.warn("Identity registered but could not read agentId");
+        console.log(chalk4.dim("  Check the transaction on the explorer."));
+        return;
+      }
+      const tokenId = Number(agentId.includes(":") ? agentId.split(":")[1] : agentId);
+      setAgentId(tokenId);
+      spinner.succeed(`Agent identity registered: #${tokenId}`);
+      console.log(chalk4.dim(`  Agent0 ID: ${agentId}`));
+      console.log(chalk4.dim(`  Name:      ${opts.name}`));
+      console.log(chalk4.dim(`  Owner:     ${account.address}`));
+      console.log(chalk4.dim(`  Saved to   ~/.sherwood/config.json`));
+      console.log();
+      console.log(chalk4.green("You can now create syndicates:"));
+      console.log(chalk4.dim(`  sherwood syndicate create --agent-id ${tokenId} --subdomain <name> --name <name>`));
+    } catch (err) {
+      spinner.fail("Failed to register identity");
+      console.error(chalk4.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("load").description("Load an existing ERC-8004 agent identity into your config").requiredOption("--id <tokenId>", "Agent token ID to load").action(async (opts) => {
+    const account = getAccount();
+    const client = getPublicClient();
+    const registry2 = AGENT_REGISTRY().IDENTITY_REGISTRY;
+    const tokenId = Number(opts.id);
+    const spinner = ora4(`Verifying ownership of agent #${tokenId}...`).start();
+    try {
+      const owner = await client.readContract({
+        address: registry2,
+        abi: IDENTITY_REGISTRY_ABI2,
+        functionName: "ownerOf",
+        args: [BigInt(tokenId)]
+      });
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        spinner.fail(`Agent #${tokenId} is owned by ${owner}, not your wallet`);
+        process.exit(1);
+      }
+      setAgentId(tokenId);
+      spinner.succeed(`Agent #${tokenId} loaded and saved to config`);
+      console.log(chalk4.dim(`  Owner:  ${account.address}`));
+      console.log(chalk4.dim(`  Saved to ~/.sherwood/config.json`));
+    } catch (err) {
+      spinner.fail("Failed to load identity");
+      console.error(chalk4.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("find").description("Search ERC-8004 agents by wallet address or name (recover a lost agent ID)").option("--wallet <address>", "Filter by owner / wallet address").option("--name <text>", "Filter by agent name (exact or substring match, depending on registry)").option("--all-chains", "Search across all chains, not just the active one").action(async (opts) => {
+    if (!opts.wallet && !opts.name) {
+      console.error(chalk4.red("Pass --wallet <address> or --name <text> (or both)."));
+      process.exit(1);
+    }
+    const spinner = ora4("Searching ERC-8004 registry...").start();
+    try {
+      const sdk = getAgent0SDK();
+      const filters = {};
+      if (opts.wallet) filters.walletAddress = opts.wallet;
+      if (opts.name) filters.name = opts.name;
+      filters.chains = opts.allChains ? "all" : [getChain().id];
+      const results = await sdk.searchAgents(filters);
+      spinner.stop();
+      if (results.length === 0) {
+        console.log(chalk4.dim("No agents found matching those filters."));
+        console.log(chalk4.dim("If you minted on a different chain, retry with --all-chains."));
         return;
       }
       console.log();
@@ -3048,7 +4670,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 +4686,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 +4748,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 encodeFunctionData17 } 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 encodeFunctionData16 } 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 +5046,7 @@ var MOONWELL_CTOKEN_ABI = [
     outputs: [{ name: "", type: "uint256" }]
   }
 ];
-var MOONWELL_COMPTROLLER_ABI = [
+var MOONWELL_COMPTROLLER_ABI2 = [
   {
     name: "enterMarkets",
     type: "function",
@@ -3232,7 +5062,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 +5167,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 +5205,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 +5238,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 +5246,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 +5257,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 +5289,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 +5342,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 +5358,7 @@ async function simulateViaApi(vault, calls) {
 async function simulateViaEthCall(vault, calls) {
   const governor = getGovernorAddress();
   const client = getPublicClient();
-  const input2 = encodeFunctionData10({
+  const input2 = encodeFunctionData16({
     abi: SYNDICATE_VAULT_ABI,
     functionName: "executeGovernorBatch",
     args: [calls.map((c) => ({ target: c.target, data: c.data, value: c.value }))]
@@ -3743,7 +5411,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 +5589,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 +5600,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 +5713,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 +5869,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 +5913,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 +5957,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 +6013,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 +6066,7 @@ function registerProposalCommands(program2) {
         process.exit(1);
       }
       const asset = await getAssetAddress();
-      const noopCalldata = encodeFunctionData11({
+      const noopCalldata = encodeFunctionData17({
         abi: ERC20_ABI,
         functionName: "balanceOf",
         args: [vault]
@@ -4400,6 +6136,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 +6214,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 +6265,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 +6329,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 +6426,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 +6449,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 +6482,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 +6501,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 +6513,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 +6529,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 +6543,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 +6554,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 +6574,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 +6592,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 +6616,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 +6625,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 +6648,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 +6667,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 +6685,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 +6728,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 +6979,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 +7268,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 +7347,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 +7362,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 +7454,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 +7552,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 encodeAbiParameters12, parseUnits as parseUnits6 } from "viem";
 
 // src/grid/cloid.ts
-import { keccak256, encodeAbiParameters as encodeAbiParameters10 } from "viem";
+import { keccak256, encodeAbiParameters as encodeAbiParameters11 } from "viem";
 function gridCloid(strategy2, assetIndex, isBuy, levelIndex, nonce) {
   const hash = keccak256(
-    encodeAbiParameters10(
+    encodeAbiParameters11(
       [
         { type: "address" },
         { type: "uint32" },
@@ -5782,11 +7618,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 +7646,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 +7785,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 = encodeAbiParameters12(
         [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
         [ACTION_PLACE_GRID, encoded]
       );
@@ -5956,7 +7803,7 @@ var OnchainGridExecutor = class {
       this.bumpNonce(token);
       return "0x";
     }
-    const data = encodeAbiParameters11(
+    const data = encodeAbiParameters12(
       [{ type: "uint8" }, { type: "uint32" }, { type: "uint128[]" }],
       [ACTION_CANCEL_ALL, assetIndex, cloids]
     );
@@ -5985,7 +7832,7 @@ var OnchainGridExecutor = class {
       const { encoded, cloids } = this.encodeOrders(assetIndex, chunk, meta, newNonce);
       let data;
       if (i === 0) {
-        data = encodeAbiParameters11(
+        data = encodeAbiParameters12(
           [
             { type: "uint8" },
             { type: "uint32" },
@@ -5995,7 +7842,7 @@ var OnchainGridExecutor = class {
           [ACTION_CANCEL_AND_PLACE, assetIndex, oldCloids, encoded]
         );
       } else {
-        data = encodeAbiParameters11(
+        data = encodeAbiParameters12(
           [{ type: "uint8" }, { type: "tuple[]", components: [...GRID_ORDER_COMPONENTS] }],
           [ACTION_PLACE_GRID, encoded]
         );
@@ -6008,6 +7855,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 +8039,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 +8486,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 +8818,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 +8913,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 +8965,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 +9128,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 +9174,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 +9292,7 @@ try {
 } catch {
 }
 var require2 = createRequire(import.meta.url);
-var { version: CLI_VERSION } = require2("../package.json");
+var CLI_VERSION = "0.64.1";
 async function loadXmtp() {
   return import("./xmtp-MR6OJ76L.js");
 }
@@ -7295,7 +9306,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 +9320,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 +9349,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 +9452,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 +9801,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 +9837,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 +10008,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 +10201,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 +10397,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 +10515,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 +10568,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 +10582,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 +10591,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)));