@continuumdao/ctm-mpc-defi 0.2.29 → 0.2.31

package/dist/agent/catalog.cjs

@@ -95,17 +95,27 @@ var init_api = __esm({
 // src/protocols/evm/morpho/midnightConstants.ts
 var midnightConstants_exports = {};
 __export(midnightConstants_exports, {
+  MORPHO_BLUE_CANONICAL: () => MORPHO_BLUE_CANONICAL,
   MORPHO_MIDNIGHT_ADDRESSES: () => MORPHO_MIDNIGHT_ADDRESSES,
   MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS: () => MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS,
   MORPHO_MIDNIGHT_BASE_CHAIN_ID: () => MORPHO_MIDNIGHT_BASE_CHAIN_ID,
+  MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS,
   MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT: () => MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT,
   MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS: () => MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_CALLBACK_SALT: () => MORPHO_MIDNIGHT_CALLBACK_SALT,
+  MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS: () => MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS,
   MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS,
+  MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS: () => MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS,
   MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT: () => MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT,
   MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK: () => MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK,
+  MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID: () => MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID,
   MORPHO_MIDNIGHT_LEND_FALLBACK_GAS: () => MORPHO_MIDNIGHT_LEND_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS: () => MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS,
   MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS: () => MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS,
   MORPHO_MIDNIGHT_REST_BASE: () => MORPHO_MIDNIGHT_REST_BASE,
+  MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS: () => MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS,
+  MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS: () => MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS,
   MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK: () => MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK,
   TOKEN_PERMIT_NONE: () => TOKEN_PERMIT_NONE,
   morphoMidnightAddressesForChain: () => morphoMidnightAddressesForChain
@@ -113,18 +123,36 @@ __export(midnightConstants_exports, {
 function morphoMidnightAddressesForChain(chainId) {
   return MORPHO_MIDNIGHT_ADDRESSES[chainId] ?? null;
 }
-var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK;
+var MORPHO_MIDNIGHT_REST_BASE, MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT, MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT, MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS, MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS, MORPHO_MIDNIGHT_BASE_CHAIN_ID, MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID, MORPHO_BLUE_CANONICAL, MORPHO_MIDNIGHT_CALLBACK_SALT, MORPHO_MIDNIGHT_ADDRESSES, TOKEN_PERMIT_NONE, MORPHO_MIDNIGHT_LEND_FALLBACK_GAS, MORPHO_MIDNIGHT_BORROW_FALLBACK_GAS, MORPHO_MIDNIGHT_REPAY_FALLBACK_GAS, MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS, MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK, MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK, MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS, MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS, MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS, MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS, MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS, MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS;
 var init_midnightConstants = __esm({
   "src/protocols/evm/morpho/midnightConstants.ts"() {
     MORPHO_MIDNIGHT_REST_BASE = "https://api.morpho.org/v0/midnight";
     MORPHO_MIDNIGHT_BOOKS_MAX_LIMIT = 20;
     MORPHO_MIDNIGHT_DEFAULT_SLIPPAGE_PCT = "0.5";
     MORPHO_MIDNIGHT_DEFAULT_DEADLINE_SECONDS = 3600;
+    MORPHO_MIDNIGHT_DEFAULT_OFFER_TTL_SECONDS = 7 * 24 * 3600;
     MORPHO_MIDNIGHT_BASE_CHAIN_ID = 8453;
+    MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID = 1;
+    MORPHO_BLUE_CANONICAL = "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb";
+    MORPHO_MIDNIGHT_CALLBACK_SALT = viem.keccak256(viem.toBytes("continuum-midnight-lend-v1"));
     MORPHO_MIDNIGHT_ADDRESSES = {
+      [MORPHO_MIDNIGHT_ETHEREUM_CHAIN_ID]: {
+        midnight: "0x471686c42792F93528B000beF54bC10E3aa2045f",
+        bundles: "0x7c00dBB2b6b6b9B28745332e550dC8782Fcf77EC",
+        mempool: "0xde2d62449301a09A51EbF9326EA60d2e8BF4A8F7",
+        setterRatifier: "0xb72c416382c8A6399D0765CebfB032F040B00B3c",
+        ecrecoverRatifier: "0xAC439c81CAA6ef4C7B7E8F0110F8CE63A4b6D43e",
+        blueBuyCallbackFactory: "0x172d1FdC5f79bFe1ED46448f18541E591E5c93a7",
+        morphoBlue: MORPHO_BLUE_CANONICAL
+      },
       [MORPHO_MIDNIGHT_BASE_CHAIN_ID]: {
-        midnight: "0xadedd8ab6de832766fedf0fac4992e5c4d3ea18a",
-        bundles: "0x6688dEc8878f43905e11B3C6Bc025E098133144f"
+        midnight: "0xAdedD8ab6dE832766Fedf0FaC4992E5C4D3EA18A",
+        bundles: "0x091183d729BE9f808c212b475E387A12E67850A7",
+        mempool: "0xdD6DCE32e21f7b020898a8258dA37355b4017993",
+        setterRatifier: "0x800B5F12A61B8198a5a6EfD794Cac6699B294d63",
+        ecrecoverRatifier: "0xd6e70365C8E8DDa9a4ca662C07bbE663b017755E",
+        blueBuyCallbackFactory: "0x7337f119Eca028bD39E0e543cEf71631D2333425",
+        morphoBlue: MORPHO_BLUE_CANONICAL
       }
     };
     TOKEN_PERMIT_NONE = { kind: 0, data: "0x" };
@@ -134,6 +162,12 @@ var init_midnightConstants = __esm({
     MORPHO_MIDNIGHT_AUTHORIZE_FALLBACK_GAS = 80000n;
     MORPHO_MIDNIGHT_ERC20_APPROVE_FALLBACK = 100000n;
     MORPHO_MIDNIGHT_WETH_DEPOSIT_FALLBACK = 120000n;
+    MORPHO_MIDNIGHT_CREATE_CALLBACK_FALLBACK_GAS = 1200000n;
+    MORPHO_MIDNIGHT_BLUE_SUPPLY_FALLBACK_GAS = 400000n;
+    MORPHO_MIDNIGHT_BLUE_WITHDRAW_FALLBACK_GAS = 350000n;
+    MORPHO_MIDNIGHT_SET_ROOT_FALLBACK_GAS = 80000n;
+    MORPHO_MIDNIGHT_MEMPOOL_PUBLISH_FALLBACK_GAS = 250000n;
+    MORPHO_MIDNIGHT_SET_CONSUMED_FALLBACK_GAS = 80000n;
   }
 });
 
@@ -143,6 +177,7 @@ __export(midnightApi_exports, {
   fetchMorphoMidnightBook: () => fetchMorphoMidnightBook,
   fetchMorphoMidnightBookQuote: () => fetchMorphoMidnightBookQuote,
   fetchMorphoMidnightBooks: () => fetchMorphoMidnightBooks,
+  fetchMorphoMidnightMakerOffers: () => fetchMorphoMidnightMakerOffers,
   fetchMorphoMidnightMarketById: () => fetchMorphoMidnightMarketById,
   fetchMorphoMidnightUserMarketPosition: () => fetchMorphoMidnightUserMarketPosition,
   fetchMorphoMidnightUserPositions: () => fetchMorphoMidnightUserPositions,
@@ -284,6 +319,39 @@ async function fetchMorphoMidnightUserPositions(args) {
   }
   return rows;
 }
+async function fetchMorphoMidnightMakerOffers(args) {
+  const qs = new URLSearchParams();
+  qs.set("maker", viem.getAddress(args.maker));
+  if (args.chainId != null) qs.set("chain_ids", String(args.chainId));
+  const j = await midnightGetJson(`/takeable-offers?${qs}`);
+  const out = [];
+  for (const row of j.data ?? []) {
+    const o = row.offer;
+    if (!o?.maker || !viem.isAddress(o.maker) || !o.market?.loan_token || !viem.isAddress(o.market.loan_token)) continue;
+    if (!o.market.midnight || !viem.isAddress(o.market.midnight)) continue;
+    const group = (o.group ?? "").trim();
+    if (!group.startsWith("0x") || group.length !== 66) continue;
+    const callback = o.callback && viem.isAddress(o.callback) ? viem.getAddress(o.callback) : "0x0000000000000000000000000000000000000000";
+    out.push({
+      marketId: String(row.market_id ?? ""),
+      chainId: Number(o.market.chain_id ?? args.chainId ?? 0),
+      midnight: viem.getAddress(o.market.midnight),
+      loanToken: viem.getAddress(o.market.loan_token),
+      maker: viem.getAddress(o.maker),
+      buy: o.buy === true,
+      tick: String(o.tick ?? "0"),
+      maxAssets: String(o.max_assets ?? "0"),
+      maxUnits: String(o.max_units ?? "0"),
+      expiry: Number(o.expiry ?? 0),
+      group,
+      callback,
+      callbackData: o.callback_data ?? "0x",
+      units: String(row.units ?? "0"),
+      maturity: o.market.maturity != null ? Number(o.market.maturity) : null
+    });
+  }
+  return out;
+}
 async function fetchMorphoMidnightUserMarketPosition(args) {
   const marketId = args.marketId.trim();
   const user = args.user.trim();
@@ -921,7 +989,7 @@ var evmMultisignCommonInputSchema = zod.z.object({
   chainDetail: chainDetailSchema.optional().describe("Server-filled gas row from chain registry when keyGenId is set."),
   customGasChainDetails: zod.z.record(zod.z.unknown()).optional().describe("Snapshot written to extraJSON.customGasChainDetails when useCustomGas is true."),
   expiryDate: zod.z.number().int().positive().optional().describe(
-    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, and Curve DAO default to 30 minutes when omitted; other protocols use the node default (7 days)."
+    "Optional Unix seconds (UTC) when the MPC sign request expires. Uniswap V4, GMX, Hyperliquid, Curve DAO, and Aerodrome default to 30 minutes when omitted; other protocols use the node default (7 days)."
   )
 });
 function withMultisignKeySourceRefine(schema) {
@@ -1657,6 +1725,182 @@ var mcpCurveDaoBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var chain8453 = agentEvmChainIdSchema.describe("Must be 8453 (Base). Aerodrome is Base-only.");
+var rpcUrlOptional = zod.z.string().min(1).optional().describe("JSON-RPC URL; continuum-mcp-server injects from chain registry \u2014 do not pass a public RPC URL");
+var mcpAerodromeDiscoverPoolsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  token: zod.z.string().min(1).describe("Ticker or 0x address to find pools for (AAPLc, USDC, ETH, WETH, AERO)."),
+  tokenOut: zod.z.string().min(1).optional().describe("Optional counterpart. Defaults to USDC so B20 stocks resolve. Tickers OK.")
+});
+var mcpAerodromeDiscoverPoolsOutputSchema = jsonObjectSchema.describe(
+  "{ token, tokenOut, pools[] (lp, kind, tickSpacing, factory), notes }. Factory getPool only \u2014 not LpSugar. Then call ctm_aerodrome_quote."
+);
+var mcpAerodromeFetchPoolsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  limit: zod.z.number().int().positive().max(200).optional(),
+  offset: zod.z.number().int().min(0).optional()
+});
+var mcpAerodromeFetchPoolsOutputSchema = jsonObjectSchema.describe("{ chainId, pools[] }");
+var mcpAerodromeFetchPositionsInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  account: evmAddressSchema.optional(),
+  executorAddress: evmAddressSchema.optional().describe("Server-filled from keyGenId when omitted")
+});
+var mcpAerodromeFetchPositionsOutputSchema = jsonObjectSchema.describe(
+  "{ chainId, account, notes, positions[] } \u2014 each row has label (vAMM-USDC/AERO \xB7 #id), kind, gauge, stakedInGauge, claimFees.pool, claimEmissions (gauge + tokenId/cl for Slipstream, or null if no gauge). Dust v2 rows omitted."
+);
+var mcpAerodromeQuoteInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  tokenIn: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address. Native: 0x0 / eth. B20 stocks need no address lookup."),
+  tokenOut: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address. Native: 0x0 / eth."),
+  amountHuman: zod.z.string().min(1).describe("Human-readable amount of tokenIn (B20 stocks are 8 decimals)"),
+  tokenInDecimals: zod.z.number().int().min(0).max(18).optional().describe("Optional override. Omit for known tickers \u2014 AAPLc and other B20 stocks always use 8.")
+});
+var mcpAerodromeQuoteOutputSchema = jsonObjectSchema.describe(
+  "{ tokenIn, tokenOut, amountInWei, amountOutWei, amountOutHuman, priceImpactPercent (0\u2013100 vs a tiny same-route probe, or null), hops, pathPacked, isNativeIn, isNativeOut, source }"
+);
+var mcpAerodromeBuildSwapMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenIn: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address / 0x0 native"),
+    tokenOut: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x address / 0x0 native"),
+    amountHuman: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100),
+    quoteSnapshot: jsonObjectSchema.optional()
+  })
+);
+var mcpAerodromeQuoteAddLiquidityInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  tokenA: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native"),
+  tokenB: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native"),
+  stable: agentBooleanSchema(false),
+  amountAHuman: zod.z.string().optional().describe("Human amount of tokenA. Omit to solve from tokenB (one-sided, same as the dialog)."),
+  amountBHuman: zod.z.string().optional().describe("Human amount of tokenB. Omit to solve from tokenA (one-sided, same as the dialog)."),
+  tokenADecimals: zod.z.number().int().min(0).max(18).optional(),
+  tokenBDecimals: zod.z.number().int().min(0).max(18).optional()
+}).refine((v) => Boolean((v.amountAHuman ?? "").trim() || (v.amountBHuman ?? "").trim()), {
+  message: "Enter amountAHuman or amountBHuman. The other side is filled from the current vAMM, sAMM, or Slipstream pool."
+});
+var mcpAerodromeQuoteAddLiquidityOutputSchema = jsonObjectSchema.describe(
+  "{ tokenA, tokenB, amountAHuman, amountBHuman, kind (stable|volatile|cl), tickSpacing?, emptyPool, seedable, hint }. seedable:false = do not first-deposit (ETH/AAPLc has no pool \u2014 pair vs USDC). kind:cl is a Slipstream ratio; basic addLiquidity is v2 only."
+);
+var mcpAerodromeQuoteClDepositInputSchema = zod.z.object({
+  chainId: chain8453,
+  rpcUrl: rpcUrlOptional,
+  token0: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+  token1: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+  amount0Human: zod.z.string().optional(),
+  amount1Human: zod.z.string().optional(),
+  tickSpacing: zod.z.number().int(),
+  tickLower: zod.z.number().int(),
+  tickUpper: zod.z.number().int(),
+  sqrtPriceX96: zod.z.string().min(1).describe("0 if the CL pool already exists")
+});
+var mcpAerodromeQuoteClDepositOutputSchema = jsonObjectSchema;
+var mcpAerodromeBuildAddLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenA: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+    tokenB: zod.z.string().min(1).describe("Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native"),
+    stable: agentBooleanSchema(false),
+    amountAHuman: zod.z.string().optional().describe("Omit to solve from amountBHuman (one-sided)."),
+    amountBHuman: zod.z.string().optional().describe("Omit to solve from amountAHuman (one-sided)."),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  }).refine((v) => Boolean((v.amountAHuman ?? "").trim() || (v.amountBHuman ?? "").trim()), {
+    message: "Enter amountAHuman or amountBHuman."
+  })
+);
+var mcpAerodromeBuildRemoveLiquidityMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenA: zod.z.string().min(1),
+    tokenB: zod.z.string().min(1),
+    stable: agentBooleanSchema(false),
+    lpToken: evmAddressSchema,
+    liquidityHuman: zod.z.string().min(1),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    amountAMinHuman: zod.z.string().optional(),
+    amountBMinHuman: zod.z.string().optional()
+  })
+);
+var mcpAerodromeBuildClMintMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    token0: zod.z.string().min(1),
+    token1: zod.z.string().min(1),
+    amount0Human: zod.z.string().optional(),
+    amount1Human: zod.z.string().optional(),
+    tickSpacing: zod.z.number().int(),
+    tickLower: zod.z.number().int(),
+    tickUpper: zod.z.number().int(),
+    sqrtPriceX96: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  })
+);
+var mcpAerodromeBuildClIncreaseMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1),
+    token0: zod.z.string().min(1),
+    token1: zod.z.string().min(1),
+    amount0Wei: zod.z.string().min(1),
+    amount1Wei: zod.z.string().min(1),
+    slippagePercent: zod.z.number().gt(0).lt(100)
+  })
+);
+var mcpAerodromeBuildClDecreaseMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1),
+    liquidity: zod.z.string().min(1),
+    amount0MinWei: zod.z.string().optional(),
+    amount1MinWei: zod.z.string().optional()
+  })
+);
+var mcpAerodromeBuildClBurnMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1)
+  })
+);
+var mcpAerodromeBuildGaugeStakeMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema,
+    lpToken: evmAddressSchema.optional(),
+    amountHuman: zod.z.string().optional(),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    tokenId: zod.z.string().optional(),
+    cl: agentBooleanSchema(false)
+  })
+);
+var mcpAerodromeBuildGaugeUnstakeMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema,
+    amountHuman: zod.z.string().optional(),
+    lpDecimals: zod.z.number().int().min(0).max(18).optional(),
+    tokenId: zod.z.string().optional(),
+    cl: agentBooleanSchema(false)
+  })
+);
+var mcpAerodromeBuildClaimFeesMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    pool: evmAddressSchema.describe(
+      "Pool (lp) from ctm_aerodrome_fetch_positions claimFees.pool \u2014 not the gauge. Dialog: \u201CFees from the pool\u201D."
+    )
+  })
+);
+var mcpAerodromeBuildClCollectFeesMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    tokenId: zod.z.string().min(1)
+  })
+);
+var mcpAerodromeBuildClaimEmissionsMultisignInputSchema = withMultisignKeySourceRefine(
+  evmMultisignCommonInputSchema.extend({
+    gauge: evmAddressSchema.describe(
+      "Gauge from fetch_positions claimEmissions.gauge \u2014 not the pool. Dialog: \u201CEmissions from the gauge in AERO\u201D. Skip if claimEmissions is null."
+    ),
+    tokenId: zod.z.string().optional().describe("Required for Slipstream staked positions (claimEmissions.tokenId)."),
+    cl: agentBooleanSchema(false).describe("true when claimEmissions.cl (Slipstream NFT getReward).")
+  })
+);
 
 // src/protocols/evm/morpho/robinhoodEarn.ts
 var ROBINHOOD_CHAIN_ID = 4663;
@@ -1833,6 +2077,23 @@ function preprocessMorphoMidnightBorrowInput(raw) {
   }
   return o;
 }
+function preprocessMorphoMidnightLendOfferInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) {
+    const amt = String(o.amountHuman ?? "").trim();
+    if (amt) o.purposeText = `Morpho Midnight lend offer ${amt}`;
+  }
+  return o;
+}
+function preprocessMorphoMidnightCancelLendOfferInput(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const o = { ...raw };
+  const purposeText = String(o.purposeText ?? o.purpose ?? "").trim();
+  if (!purposeText) o.purposeText = "Morpho Midnight cancel lend offer";
+  return o;
+}
 function preprocessMorphoMidnightRepayInput(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
   const o = { ...raw };
@@ -1914,6 +2175,34 @@ var mcpMorphoFetchMidnightPositionsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpMorphoFetchMidnightOffersInputSchema = zod.z.object({
+  user: zod.z.string().min(1).describe("Maker EVM address"),
+  chainId: agentEvmChainIdSchema.optional()
+});
+var mcpMorphoFetchMidnightOffersOutputSchema = zod.z.object({
+  offers: zod.z.array(
+    zod.z.object({
+      marketId: zod.z.string(),
+      chainId: zod.z.number().int(),
+      midnightAddress: zod.z.string(),
+      loanTokenAddress: zod.z.string(),
+      maker: zod.z.string(),
+      group: zod.z.string().describe("Pass to ctm_morpho_build_midnight_cancel_lend_offer_multisign"),
+      callback: zod.z.string(),
+      callbackData: zod.z.string(),
+      tick: zod.z.string(),
+      maxAssets: zod.z.string(),
+      remainingUnits: zod.z.string(),
+      expiry: zod.z.number(),
+      expiryIso: zod.z.string(),
+      maturity: zod.z.number().nullable(),
+      maturityIso: zod.z.string(),
+      lendApr: zod.z.string(),
+      lendAprNumeric: zod.z.number().nullable(),
+      marketLabel: zod.z.string()
+    })
+  )
+});
 var mcpServerCommonInputSchema = zod.z.object({
   keyGenId: zod.z.string().min(1).describe("KeyGen id from fetch_key_gen_result / node preferred KeyGen"),
   chainId: zod.z.number().int().positive().describe("EVM chain id; RPC and gas config resolved from chain registry"),
@@ -2293,6 +2582,35 @@ var mcpMorphoMidnightBorrowInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var mcpMorphoMidnightLendOfferInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightLendOfferInput,
+    evmMultisignCommonInputSchema.extend({
+      marketId: zod.z.string().min(1).describe("marketId from ctm_morpho_fetch_midnight_books"),
+      amountHuman: zod.z.string().min(1).describe("Loan-token amount to park in Blue and quote on Midnight"),
+      loanToken: evmAddressSchema.optional(),
+      lendAprPct: zod.z.string().optional().describe("Target fixed lend APR percent, e.g. 5.2. Defaults to book best bid."),
+      tick: zod.z.string().optional().describe("Override Midnight tick (takes precedence over lendAprPct)"),
+      blueMarketId: zod.z.string().optional().describe("Morpho Blue market to earn variable yield until the offer fills"),
+      expirySeconds: agentCoercedOptionalIntSchema(zod.z.number().int().min(60)),
+      marketLabel: zod.z.string().optional(),
+      isNativeIn: agentOptionalBooleanSchema()
+    })
+  )
+);
+var mcpMorphoMidnightCancelLendOfferInputSchema = withMultisignKeySourceRefine(
+  zod.z.preprocess(
+    preprocessMorphoMidnightCancelLendOfferInput,
+    evmMultisignCommonInputSchema.extend({
+      group: zod.z.string().min(1).describe("Offer group id from ctm_morpho_fetch_midnight_offers"),
+      callback: evmAddressSchema.optional(),
+      callbackData: zod.z.string().optional().describe("Hex Blue MarketParams from the offer row"),
+      midnight: evmAddressSchema.optional(),
+      withdrawRemaining: agentOptionalBooleanSchema(),
+      marketLabel: zod.z.string().optional()
+    })
+  )
+);
 var mcpMorphoMidnightRepayInputSchema = withMultisignKeySourceRefine(
   zod.z.preprocess(
     preprocessMorphoMidnightRepayInput,
@@ -2305,6 +2623,473 @@ var mcpMorphoMidnightRepayInputSchema = withMultisignKeySourceRefine(
     })
   )
 );
+var mcpContinuumDaoCreateLockInputSchema = mcpMultisignInput({
+  amountHuman: zod.z.string().min(1).describe("CTM amount to lock"),
+  lockDurationSeconds: zod.z.union([zod.z.string(), zod.z.number()]).describe("Lock duration in seconds"),
+  ctm: evmAddressSchema.optional(),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoIncreaseAmountInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  amountHuman: zod.z.string().min(1),
+  ctm: evmAddressSchema.optional(),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoIncreaseUnlockTimeInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  lockDurationSeconds: zod.z.union([zod.z.string(), zod.z.number()]),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoSplitInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  extractedHuman: zod.z.string().min(1),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoMergeInputSchema = mcpMultisignInput({
+  fromTokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  toTokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoTokenIdInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoDelegateInputSchema = mcpMultisignInput({
+  delegatee: evmAddressSchema,
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoUndelegateInputSchema = mcpMultisignInput({
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoFetchDelegatesInputSchema = zod.z.object({
+  chainId: zod.z.union([zod.z.string(), zod.z.number()]),
+  rpcUrl: zod.z.string().min(1),
+  account: evmAddressSchema,
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoFetchDelegatesOutputSchema = zod.z.object({
+  account: evmAddressSchema,
+  delegatee: evmAddressSchema,
+  self: zod.z.boolean()
+});
+var mcpContinuumDaoTransferInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  to: evmAddressSchema,
+  votingEscrow: evmAddressSchema.optional()
+});
+var mcpContinuumDaoAttachInputSchema = mcpMultisignInput({
+  nodeKey: zod.z.string().min(1),
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  mpaWallet: evmAddressSchema,
+  forumHandle: zod.z.string().optional(),
+  email: zod.z.string().optional(),
+  vps: zod.z.string().optional(),
+  ram: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  cpu: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  dIDType: zod.z.string().optional(),
+  dID: zod.z.string().optional()
+});
+var mcpContinuumDaoRequestDetachInputSchema = mcpMultisignInput({
+  tokenId: zod.z.union([zod.z.string(), zod.z.number()]),
+  nodeProperties: evmAddressSchema
+});
+var govActionSchema = zod.z.object({
+  target: evmAddressSchema,
+  value: zod.z.string().optional(),
+  signature: zod.z.string().optional(),
+  inputs: zod.z.array(zod.z.object({ name: zod.z.string().optional(), type: zod.z.string(), value: zod.z.string() })).optional()
+});
+var govOptionSchema = zod.z.object({
+  label: zod.z.string().min(1),
+  actions: zod.z.array(govActionSchema)
+});
+var forumTopicKeyField = zod.z.string().min(1).describe(
+  "URL of the Governance forum thread created first with ctm_continuum_dao_forum_create_topic (decision / election / treasury / constitution / admin). Must be /topic/:tid or /t/:tid. Ideas threads and the homepage are refused."
+);
+var mcpContinuumDaoProposeBravoInputSchema = mcpMultisignInput({
+  title: zod.z.string().min(1).max(128),
+  actions: zod.z.array(govActionSchema).optional(),
+  governor: evmAddressSchema.optional(),
+  noOpTarget: evmAddressSchema.optional(),
+  forumKey: forumTopicKeyField,
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoProposeDeltaInputSchema = mcpMultisignInput({
+  title: zod.z.string().min(1).max(128),
+  options: zod.z.array(govOptionSchema).min(2),
+  nWinners: zod.z.union([zod.z.string(), zod.z.number()]),
+  governor: evmAddressSchema.optional(),
+  noOpTarget: evmAddressSchema.optional(),
+  forumKey: forumTopicKeyField,
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoCastVoteBravoInputSchema = mcpMultisignInput({
+  proposalId: zod.z.union([zod.z.string(), zod.z.number()]),
+  support: zod.z.union([zod.z.literal(0), zod.z.literal(1), zod.z.literal(2), zod.z.string()]),
+  governor: evmAddressSchema.optional()
+});
+var mcpContinuumDaoCastVoteDeltaInputSchema = mcpMultisignInput({
+  proposalId: zod.z.union([zod.z.string(), zod.z.number()]),
+  weights: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
+  governor: evmAddressSchema.optional()
+});
+var mcpContinuumDaoProposalIdInputSchema = mcpMultisignInput({
+  proposalId: zod.z.union([zod.z.string(), zod.z.number()]),
+  governor: evmAddressSchema.optional()
+});
+var mcpContinuumDaoFetchVotingPowerInputSchema = zod.z.object({
+  chainId: zod.z.union([zod.z.string(), zod.z.number()]),
+  rpcUrl: zod.z.string().min(1),
+  account: evmAddressSchema,
+  governor: evmAddressSchema.optional()
+});
+var mcpContinuumDaoFetchVotingPowerOutputSchema = zod.z.object({
+  votes: zod.z.string(),
+  threshold: zod.z.string(),
+  clock: zod.z.string()
+});
+var mcpContinuumDaoFetchProposalStateInputSchema = zod.z.object({
+  chainId: zod.z.union([zod.z.string(), zod.z.number()]),
+  rpcUrl: zod.z.string().min(1),
+  proposalId: zod.z.union([zod.z.string(), zod.z.number()]),
+  governor: evmAddressSchema.optional()
+});
+var mcpContinuumDaoFetchProposalStateOutputSchema = zod.z.object({
+  state: zod.z.number(),
+  againstVotes: zod.z.string(),
+  forVotes: zod.z.string(),
+  abstainVotes: zod.z.string()
+});
+var mcpContinuumDaoFetchProposalsInputSchema = zod.z.object({
+  start: zod.z.number().int().nonnegative().optional(),
+  end: zod.z.number().int().positive().optional()
+});
+var mcpContinuumDaoFetchProposalsOutputSchema = zod.z.object({
+  proposals: zod.z.array(zod.z.unknown()),
+  total: zod.z.number().optional()
+});
+var mcpContinuumDaoFetchProposalInputSchema = zod.z.object({
+  id: zod.z.union([zod.z.string(), zod.z.number()])
+});
+var mcpContinuumDaoFetchProposalOutputSchema = zod.z.object({
+  proposal: zod.z.unknown()
+});
+var liveProposalRowSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  onchainId: zod.z.string(),
+  title: zod.z.string(),
+  configuration: zod.z.number().optional(),
+  state: zod.z.number().nullable(),
+  stateLabel: zod.z.string(),
+  bucket: zod.z.enum(["live", "pending", "readyToExecute", "recentlyCompleted", "unknown"]),
+  againstVotes: zod.z.string().optional(),
+  forVotes: zod.z.string().optional(),
+  abstainVotes: zod.z.string().optional()
+});
+var mcpContinuumDaoFetchLiveProposalsInputSchema = zod.z.object({
+  chainId: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  rpcUrl: zod.z.string().optional(),
+  governor: evmAddressSchema.optional(),
+  limit: zod.z.number().int().positive().max(100).optional(),
+  completedLimit: zod.z.number().int().nonnegative().max(20).optional()
+});
+var mcpContinuumDaoFetchLiveProposalsOutputSchema = zod.z.object({
+  overlay: zod.z.enum(["on-chain", "backend-only"]),
+  scanned: zod.z.number(),
+  live: zod.z.array(liveProposalRowSchema),
+  pending: zod.z.array(liveProposalRowSchema),
+  readyToExecute: zod.z.array(liveProposalRowSchema),
+  recentlyCompleted: zod.z.array(liveProposalRowSchema),
+  unknown: zod.z.array(liveProposalRowSchema),
+  note: zod.z.string()
+});
+var mcpContinuumDaoExplainProposalInputSchema = zod.z.object({
+  id: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  onchainId: zod.z.string().optional(),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoExplainProposalOutputSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  onchainId: zod.z.string(),
+  title: zod.z.string(),
+  description: zod.z.string(),
+  proposer: zod.z.string(),
+  forumKey: zod.z.string(),
+  forumSection: zod.z.string().nullable().optional(),
+  forumCid: zod.z.number().nullable().optional(),
+  typeLabel: zod.z.string(),
+  configuration: zod.z.enum(["bravo", "delta"]),
+  nWinners: zod.z.number().optional(),
+  briefing: zod.z.string(),
+  actions: zod.z.array(zod.z.unknown()),
+  options: zod.z.array(zod.z.unknown()),
+  risks: zod.z.array(zod.z.string())
+});
+var mcpContinuumDaoRegisterProposalInputSchema = zod.z.object({
+  onchainId: zod.z.string().min(1),
+  title: zod.z.string().min(1),
+  description: zod.z.string(),
+  proposer: evmAddressSchema,
+  forumKey: forumTopicKeyField,
+  type: zod.z.number().int().min(0).max(4),
+  configuration: zod.z.union([zod.z.literal(0), zod.z.literal(1)]),
+  actions: zod.z.array(zod.z.unknown()).optional(),
+  options: zod.z.array(zod.z.unknown()).optional()
+});
+var mcpContinuumDaoRegisterProposalOutputSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  result: zod.z.unknown()
+});
+var forumUrlField = { forumUrl: zod.z.string().optional(), ticket: zod.z.string().optional() };
+var mcpContinuumDaoForumResolveInputSchema = zod.z.object({
+  url: zod.z.string().optional(),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumResolveOutputSchema = zod.z.object({
+  tid: zod.z.number(),
+  slug: zod.z.string().optional(),
+  url: zod.z.string()
+});
+var mcpContinuumDaoForumFetchThreadInputSchema = zod.z.object({
+  url: zod.z.string().optional(),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  index: zod.z.number().int().nonnegative().optional(),
+  start: zod.z.number().int().nonnegative().optional(),
+  limit: zod.z.number().int().positive().max(100).optional(),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumFetchThreadOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumReplyCountInputSchema = zod.z.object({
+  url: zod.z.string().optional(),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumReplyCountOutputSchema = zod.z.object({
+  tid: zod.z.number(),
+  postcount: zod.z.number(),
+  replyCount: zod.z.number()
+});
+var mcpContinuumDaoForumFetchPostInputSchema = zod.z.object({
+  pid: zod.z.union([zod.z.string(), zod.z.number()]),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumFetchPostOutputSchema = zod.z.unknown();
+var forumRecencyFields = {
+  hours: agentCoercedOptionalNumberSchema(zod.z.number().positive().max(24 * 365)).describe(
+    "Only posts from the last X hours."
+  ),
+  since: zod.z.string().min(1).optional().describe("Only posts at or after this ISO date (YYYY-MM-DD or full ISO) or unix timestamp."),
+  start: agentCoercedOptionalIntSchema(zod.z.number().int().nonnegative()),
+  limit: agentCoercedOptionalIntSchema(zod.z.number().int().positive().max(100)),
+  forumUrl: zod.z.string().optional()
+};
+var mcpContinuumDaoForumSearchInputSchema = zod.z.object({
+  query: zod.z.string().max(200).optional().describe(
+    "Case-insensitive substring. Matches a new thread title or any post body. Omit with hours/since to list recent posts."
+  ),
+  ...forumRecencyFields
+}).refine((v) => Boolean(v.query?.trim()) || v.hours != null || Boolean(v.since?.trim()), {
+  message: "Provide query and/or a time filter (hours or since)"
+});
+var forumPostListItemSchema = zod.z.object({
+  id: zod.z.number().int().positive().describe("Post id (pid). Open with ctm_continuum_dao_forum_fetch_post."),
+  title: zod.z.string().describe("Thread title (new thread, or parent thread title for a reply)."),
+  username: zod.z.string().describe("Author username."),
+  timestamp: zod.z.number().int().nonnegative().describe("Creation time as unix milliseconds."),
+  createdAt: zod.z.string().describe("Creation time as UTC ISO-8601.")
+});
+var mcpContinuumDaoForumSearchOutputSchema = zod.z.object({
+  results: zod.z.array(forumPostListItemSchema),
+  start: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  nextStart: zod.z.number().nullable().optional()
+});
+var mcpContinuumDaoForumRecentInputSchema = zod.z.object({
+  ...forumRecencyFields,
+  ticket: zod.z.string().optional().describe("Optional forum ticket so private categories the user can read are included.")
+}).refine((v) => v.hours != null || Boolean(v.since?.trim()), {
+  message: "Provide a time filter (hours or since)"
+});
+var mcpContinuumDaoForumRecentOutputSchema = zod.z.object({
+  results: zod.z.array(forumPostListItemSchema),
+  start: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  nextStart: zod.z.number().nullable().optional()
+});
+var mcpContinuumDaoForumDeleteInputSchema = zod.z.object({
+  pid: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Delete this post (pid)."),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Delete this thread (tid)."),
+  url: zod.z.string().optional().describe("Delete this thread by forum topic URL."),
+  username: zod.z.string().min(1).optional().describe("Delete all posts by this username (privilege-filtered)."),
+  hours: agentCoercedOptionalNumberSchema(zod.z.number().positive().max(24 * 365)).describe(
+    "Only delete posts/threads in the last X hours. Omit with since for all."
+  ),
+  since: zod.z.string().min(1).optional().describe("Only delete posts/threads at or after this ISO date or unix timestamp. Omit with hours for all."),
+  ticket: zod.z.string().min(1).describe("Forum write ticket from EIP-712 sign-in. Caller must be an admin or moderator."),
+  forumUrl: zod.z.string().optional()
+}).refine(
+  (v) => {
+    const post = v.pid != null && String(v.pid).trim() !== "";
+    const thread = Boolean(v.url?.trim() || v.tid != null && String(v.tid).trim() !== "");
+    const user = Boolean(v.username?.trim());
+    return Number(post) + Number(thread) + Number(user) === 1;
+  },
+  { message: "Provide exactly one of pid, tid/url, or username" }
+);
+var mcpContinuumDaoForumDeleteOutputSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  mode: zod.z.enum(["post", "thread", "user"]),
+  username: zod.z.string().optional(),
+  uid: zod.z.number().optional(),
+  deleted: zod.z.array(
+    zod.z.object({
+      id: zod.z.number().int().positive(),
+      kind: zod.z.enum(["post", "thread"]),
+      title: zod.z.string().optional(),
+      username: zod.z.string().optional()
+    })
+  ),
+  skipped: zod.z.array(
+    zod.z.object({
+      id: zod.z.number().int().nonnegative(),
+      reason: zod.z.string()
+    })
+  )
+});
+var mcpContinuumDaoForumUserPostIdsInputSchema = zod.z.object({
+  username: zod.z.string().min(1),
+  start: zod.z.number().int().nonnegative().optional(),
+  limit: zod.z.number().int().positive().max(100).optional(),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumUserPostIdsOutputSchema = zod.z.object({
+  username: zod.z.string(),
+  uid: zod.z.number(),
+  pids: zod.z.array(zod.z.number()),
+  start: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  nextStart: zod.z.number().nullable().optional()
+});
+var mcpContinuumDaoForumReplyInputSchema = zod.z.object({
+  url: zod.z.string().optional(),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  content: zod.z.string().min(1).max(8e3),
+  toPid: zod.z.number().int().positive().optional(),
+  ...forumUrlField
+});
+var mcpContinuumDaoForumReplyOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumReactInputSchema = zod.z.object({
+  pid: zod.z.union([zod.z.string(), zod.z.number()]),
+  emoji: zod.z.string().min(1),
+  ...forumUrlField
+});
+var mcpContinuumDaoForumReactOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumCreateTopicInputSchema = zod.z.object({
+  section: zod.z.enum(["decision", "election", "treasury", "constitution", "admin"]).optional(),
+  cid: zod.z.number().int().positive().optional(),
+  title: zod.z.string().min(8).max(128),
+  content: zod.z.string().min(1).max(8e3),
+  ...forumUrlField
+});
+var mcpContinuumDaoForumCreateTopicOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumCreateIdeaInputSchema = zod.z.object({
+  title: zod.z.string().min(8).max(128),
+  content: zod.z.string().min(1).max(8e3),
+  ...forumUrlField
+});
+var mcpContinuumDaoForumCreateIdeaOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumMeInputSchema = zod.z.object({
+  ...forumUrlField
+});
+var mcpContinuumDaoForumMeOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumUnreadInputSchema = zod.z.object({
+  ticket: zod.z.string().min(1).describe("Forum write ticket from EIP-712 sign-in"),
+  filter: zod.z.enum(["all", "new", "watched", "unreplied"]).optional().describe("NodeBB Unread filter. Default all (watched/tracked categories + followed topics)."),
+  start: agentCoercedOptionalIntSchema(zod.z.number().int().nonnegative()),
+  limit: agentCoercedOptionalIntSchema(zod.z.number().int().positive().max(100)),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumUnreadOutputSchema = zod.z.object({
+  username: zod.z.string().optional(),
+  uid: zod.z.number().optional(),
+  filter: zod.z.string().optional(),
+  counts: zod.z.object({
+    all: zod.z.number(),
+    new: zod.z.number(),
+    watched: zod.z.number(),
+    unreplied: zod.z.number()
+  }).optional(),
+  results: zod.z.array(
+    zod.z.object({
+      tid: zod.z.number().int().positive(),
+      title: zod.z.string(),
+      url: zod.z.string(),
+      cid: zod.z.number().nullable().optional(),
+      section: zod.z.string().nullable().optional(),
+      postcount: zod.z.number().optional(),
+      replyCount: zod.z.number().optional(),
+      lastposttime: zod.z.number().optional(),
+      lastPostAt: zod.z.string().optional()
+    })
+  ),
+  start: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  nextStart: zod.z.number().nullable().optional()
+});
+var mcpContinuumDaoForumMarkReadInputSchema = zod.z.object({
+  ticket: zod.z.string().min(1).describe("Forum write ticket from EIP-712 sign-in"),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Mark this thread read."),
+  url: zod.z.string().optional().describe("Mark this thread read by topic URL."),
+  tids: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional().describe("Mark these threads read."),
+  all: agentOptionalBooleanSchema().describe("Mark every unread topic read. Confirm with the operator first."),
+  forumUrl: zod.z.string().optional()
+}).refine(
+  (v) => {
+    const one = Boolean(v.url?.trim() || v.tid != null && String(v.tid).trim() !== "");
+    const many = Boolean(v.tids && v.tids.length > 0);
+    return Number(Boolean(v.all)) + Number(one) + Number(many) === 1;
+  },
+  { message: "Provide exactly one of tid/url, tids, or all" }
+);
+var mcpContinuumDaoForumMarkReadOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumMarkUnreadInputSchema = zod.z.object({
+  ticket: zod.z.string().min(1).describe("Forum write ticket from EIP-712 sign-in"),
+  tid: zod.z.union([zod.z.string(), zod.z.number()]).optional(),
+  url: zod.z.string().optional(),
+  forumUrl: zod.z.string().optional()
+}).refine((v) => Boolean(v.url?.trim() || v.tid != null && String(v.tid).trim() !== ""), {
+  message: "Provide tid or url"
+});
+var mcpContinuumDaoForumMarkUnreadOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumSignOutInputSchema = zod.z.object({
+  ticket: zod.z.string().min(1).describe("Forum write ticket from EIP-712 sign-in"),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumSignOutOutputSchema = zod.z.object({
+  ok: zod.z.literal(true),
+  loggedIn: zod.z.literal(false),
+  uid: zod.z.number().optional()
+});
+var mcpContinuumDaoForumSectionsInputSchema = zod.z.object({
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumSectionsOutputSchema = zod.z.unknown();
+var mcpContinuumDaoForumSignInEligibleInputSchema = zod.z.object({
+  address: evmAddressSchema.describe("KeyGen or personal wallet address to check against the forum veCTM login gate"),
+  forumUrl: zod.z.string().optional()
+});
+var mcpContinuumDaoForumSignInEligibleOutputSchema = zod.z.object({
+  ok: zod.z.boolean(),
+  eligible: zod.z.boolean(),
+  address: zod.z.string().optional(),
+  reason: zod.z.string().optional()
+});
+var mcpContinuumDaoForumSignInInputSchema = mcpMultisignInput({
+  nodeKey: zod.z.string().optional().describe("Attached node key. When set, username is the first 16 characters. Optional for a personal/KeyGen address with no node."),
+  username: zod.z.string().min(2).max(16).optional().describe("Required on first login when there is no node key (2\u201316 letters, numbers, . _ -)."),
+  forumUrl: zod.z.string().optional()
+});
 var mcpEulerV2FetchLendVaultsInputSchema = zod.z.object({
   chainId: agentEvmChainIdSchema,
   underlyingAddress: evmAddressSchema.describe(
@@ -2327,6 +3112,96 @@ var mcpEulerV2FetchLendVaultsOutputSchema = zod.z.object({
     })
   )
 });
+var mcpCompoundV3FetchMarketsInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3MarketAssetSchema = zod.z.object({
+  asset: zod.z.string(),
+  symbol: zod.z.string(),
+  decimals: zod.z.number(),
+  borrowCollateralFactorPercent: zod.z.number(),
+  liquidateCollateralFactorPercent: zod.z.number(),
+  priceRaw: zod.z.string(),
+  role: zod.z.enum(["base", "collateral"])
+});
+var mcpCompoundV3MarketSummarySchema = zod.z.object({
+  chainId: zod.z.number(),
+  slug: zod.z.string(),
+  symbol: zod.z.string(),
+  comet: zod.z.string().describe("Comet proxy \u2014 copy as comet for write tools"),
+  rewards: zod.z.string(),
+  bulker: zod.z.string().nullable(),
+  baseToken: zod.z.string().nullable(),
+  utilization: zod.z.number().nullable(),
+  supplyAprPercent: zod.z.string().nullable(),
+  borrowAprPercent: zod.z.string().nullable(),
+  assets: zod.z.array(mcpCompoundV3MarketAssetSchema)
+});
+var mcpCompoundV3FetchMarketsOutputSchema = zod.z.object({
+  markets: zod.z.array(mcpCompoundV3MarketSummarySchema),
+  notes: zod.z.string()
+});
+var mcpCompoundV3FetchMarketInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3FetchMarketOutputSchema = mcpCompoundV3MarketSummarySchema;
+var mcpCompoundV3FetchAccountInputSchema = zod.z.object({
+  chainId: agentEvmChainIdSchema,
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  account: evmAddressSchema.describe("MPC executor / user address"),
+  rpcUrl: zod.z.string().min(1).optional().describe("Server-filled from chain registry. Agents should omit.")
+});
+var mcpCompoundV3FetchAccountOutputSchema = zod.z.object({
+  comet: zod.z.string(),
+  symbol: zod.z.string(),
+  baseSupplied: zod.z.string(),
+  baseBorrowed: zod.z.string(),
+  collaterals: zod.z.array(
+    zod.z.object({
+      asset: zod.z.string(),
+      symbol: zod.z.string(),
+      balance: zod.z.string()
+    })
+  ),
+  isBorrowCollateralized: zod.z.boolean(),
+  isLiquidatable: zod.z.boolean(),
+  rewardToken: zod.z.string().nullable(),
+  rewardOwed: zod.z.string().nullable()
+});
+var compoundV3WriteFields = {
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets. Never the implementation."),
+  asset: evmAddressSchema.describe(
+    "Token to supply/withdraw. Native ETH: 0x0000000000000000000000000000000000000000 or set isNative true."
+  ),
+  amountHuman: zod.z.string().min(1).describe('Human amount (e.g. "100"). Withdraw base while undercollateralized borrows.'),
+  isNative: agentOptionalBooleanSchema().describe(
+    "Wrap/unwrap native ETH automatically (WETH.deposit/withdraw). Independent of useBulker."
+  ),
+  isNativeIn: agentOptionalBooleanSchema().describe("Alias of isNative for supply/repay."),
+  useBulker: agentOptionalBooleanSchema().describe(
+    "If true, prefer ctm_compound_v3_build_bulker_multisign for combined actions. ETH wrap still works when false."
+  )
+};
+var mcpCompoundV3SupplyInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3WithdrawInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3RepayInputSchema = mcpMultisignInput(compoundV3WriteFields);
+var mcpCompoundV3ClaimRewardsInputSchema = mcpMultisignInput({
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets")
+});
+var mcpCompoundV3BulkerInputSchema = mcpMultisignInput({
+  comet: evmAddressSchema.describe("Comet proxy from ctm_compound_v3_fetch_markets"),
+  steps: zod.z.array(
+    zod.z.object({
+      action: zod.z.enum(["supply", "withdraw", "claim"]),
+      asset: evmAddressSchema.optional(),
+      amountHuman: zod.z.string().optional(),
+      isNative: agentOptionalBooleanSchema()
+    })
+  ).min(1).describe("Combined Bulker actions. Native supply/withdraw uses Bulker native token actions.")
+});
 function mcpGmxMultisignInput(fields, preprocess) {
   const inner = evmMultisignCommonInputSchema.extend(fields);
   const shaped = preprocess ? zod.z.preprocess(preprocess, inner) : inner;
@@ -3611,6 +4486,26 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightLendBatch" },
     inputZod: mcpMorphoMidnightLendInputSchema
   }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_lend_offer_multisign",
+    actionId: "morpho.midnight-lend-offer",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Build a Morpho Midnight lend limit offer. Parks the loan token in Morpho Blue (variable yield) until a borrower takes the offer via BlueBuyCallback.",
+    prerequisites: ["keyGenId", "chainId", "marketId from ctm_morpho_fetch_midnight_books", "amountHuman"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightLendOfferBatch" },
+    inputZod: mcpMorphoMidnightLendOfferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_morpho_build_midnight_cancel_lend_offer_multisign",
+    actionId: "morpho.midnight-cancel-lend-offer",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Cancel a Morpho Midnight lend offer (exhaust the offer group) and withdraw unused Blue-parked funds.",
+    prerequisites: ["keyGenId", "chainId", "group from ctm_morpho_fetch_midnight_offers"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "buildEvmMultisignBodyMorphoMidnightCancelLendOfferBatch" },
+    inputZod: mcpMorphoMidnightCancelLendOfferInputSchema
+  }),
   defineProtocolMcpTool({
     name: "ctm_morpho_build_midnight_borrow_multisign",
     actionId: "morpho.midnight-borrow",
@@ -3972,6 +4867,267 @@ var MCP_PROTOCOL_TOOL_DEFINITIONS = [
       exportName: "buildEvmMultisignBodyCctpBurnBatchFromMcp"
     },
     inputZod: mcpCctpBuildBurnMultisignInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_create_lock_multisign",
+    actionId: "continuum-dao.create-lock",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build batch: CTM approve (if needed) + VotingEscrow.create_lock. Linea only. Do not prepend billing legs.",
+    prerequisites: ["keyGen", "executorAddress", "Linea RPC", "configured CTM and VotingEscrow addresses"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoCreateLock" },
+    inputZod: mcpContinuumDaoCreateLockInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_increase_amount_multisign",
+    actionId: "continuum-dao.increase-amount",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build batch: CTM approve (if needed) + increase_amount.",
+    prerequisites: ["keyGen", "tokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoIncreaseAmount" },
+    inputZod: mcpContinuumDaoIncreaseAmountInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_increase_unlock_time_multisign",
+    actionId: "continuum-dao.increase-unlock-time",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build increase_unlock_time. lockDurationSeconds is from the week boundary to the new unlock.",
+    prerequisites: ["keyGen", "tokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoIncreaseUnlockTime" },
+    inputZod: mcpContinuumDaoIncreaseUnlockTimeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_split_multisign",
+    actionId: "continuum-dao.split",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.split. Blocked on-chain while the token is node-attached.",
+    prerequisites: ["keyGen", "tokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoSplit" },
+    inputZod: mcpContinuumDaoSplitInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_merge_multisign",
+    actionId: "continuum-dao.merge",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.merge. Blocked on-chain while either token is node-attached.",
+    prerequisites: ["keyGen", "fromTokenId", "toTokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoMerge" },
+    inputZod: mcpContinuumDaoMergeInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_withdraw_multisign",
+    actionId: "continuum-dao.withdraw",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.withdraw for an expired, unattached lock.",
+    prerequisites: ["keyGen", "tokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoWithdraw" },
+    inputZod: mcpContinuumDaoTokenIdInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_liquidate_multisign",
+    actionId: "continuum-dao.liquidate",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.liquidate. Blocked on-chain while the token is node-attached.",
+    prerequisites: ["keyGen", "tokenId", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoLiquidate" },
+    inputZod: mcpContinuumDaoTokenIdInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_delegate_multisign",
+    actionId: "continuum-dao.delegate",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.delegate(delegatee). Moves all veCTM voting power from the KeyGen to delegatee. Governor getVotes is then at the delegatee. Use undelegate to return power to the KeyGen.",
+    prerequisites: ["keyGen", "delegatee", "Linea RPC"],
+    followUp: ["ctm_continuum_dao_fetch_delegates", "ctm_continuum_dao_build_undelegate_multisign"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoDelegate" },
+    inputZod: mcpContinuumDaoDelegateInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_undelegate_multisign",
+    actionId: "continuum-dao.undelegate",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Return veCTM voting power to the KeyGen. There is no undelegate() on VotingEscrow \u2014 this calls delegate(self). address(0) would also become self on-chain.",
+    prerequisites: ["keyGen", "Linea RPC"],
+    followUp: ["ctm_continuum_dao_fetch_delegates"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoUndelegate" },
+    inputZod: mcpContinuumDaoUndelegateInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_transfer_multisign",
+    actionId: "continuum-dao.transfer",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build VotingEscrow.transferFrom. Blocked on-chain while the token is node-attached.",
+    prerequisites: ["keyGen", "tokenId", "to", "Linea RPC"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoTransfer" },
+    inputZod: mcpContinuumDaoTransferInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_attach_multisign",
+    actionId: "continuum-dao.attach",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build MultiSignAgentWallet.attachVeCtm. Authority KeyGen only. Cannot replace an attached NFT. No billing legs.",
+    prerequisites: ["keyGen", "nodeKey", "tokenId", "mpaWallet"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoAttachVeCtmFromMcp" },
+    inputZod: mcpContinuumDaoAttachInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_request_detach_multisign",
+    actionId: "continuum-dao.request-detach",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build NodeProperties.setNodeRemovalStatus(tokenId, true). Governance must complete detach.",
+    prerequisites: ["keyGen", "tokenId", "nodeProperties"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoRequestDetach" },
+    inputZod: mcpContinuumDaoRequestDetachInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_propose_bravo_multisign",
+    actionId: "continuum-dao.propose-bravo",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.propose for a Bravo (For/Against/Abstain) proposal. Refuses if getVotes(KeyGen) < live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). forumKey is required and must be a Governance thread (/topic/:tid) from ctm_continuum_dao_forum_create_topic (decision / election / treasury / constitution / admin). Ideas threads and the homepage are refused. Empty actions insert a no-op to the KeyGen address. Linea only. No billing legs. After the request is mined, call ctm_continuum_dao_register_proposal with the same forumKey.",
+    prerequisites: [
+      "keyGen",
+      "Linea RPC",
+      "configured governor",
+      "veCTM voting power >= live proposalThreshold()",
+      "forumKey from forum_create_topic"
+    ],
+    followUp: [...MCP_MULTISIGN_SUBMIT_FOLLOW_UP, "ctm_continuum_dao_register_proposal"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoProposeBravo" },
+    inputZod: mcpContinuumDaoProposeBravoInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_propose_delta_multisign",
+    actionId: "continuum-dao.propose-delta",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.propose for a Delta multi-option proposal. Refuses if getVotes(KeyGen) < live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). forumKey is required and must be a Governance thread from ctm_continuum_dao_forum_create_topic. Ideas threads are not valid forumKey values. Empty options get a no-op so indices increment. Linea only. No billing legs.",
+    prerequisites: [
+      "keyGen",
+      "at least 2 options",
+      "nWinners < nOptions",
+      "veCTM voting power >= live proposalThreshold()",
+      "forumKey from forum_create_topic"
+    ],
+    followUp: [...MCP_MULTISIGN_SUBMIT_FOLLOW_UP, "ctm_continuum_dao_register_proposal"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoProposeDeltaFromMcp" },
+    inputZod: mcpContinuumDaoProposeDeltaInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_cast_vote_bravo_multisign",
+    actionId: "continuum-dao.cast-vote-bravo",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.castVote. support: 0 against, 1 for, 2 abstain.",
+    prerequisites: ["keyGen", "proposalId", "Active proposal"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoCastVoteBravoFromMcp" },
+    inputZod: mcpContinuumDaoCastVoteBravoInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_cast_vote_delta_multisign",
+    actionId: "continuum-dao.cast-vote-delta",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.castVoteWithReasonAndParams. weights must be nOptions + 1 (final slot is NOTA).",
+    prerequisites: ["keyGen", "proposalId", "weights including NOTA"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoCastVoteDelta" },
+    inputZod: mcpContinuumDaoCastVoteDeltaInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_execute_multisign",
+    actionId: "continuum-dao.execute",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.execute(proposalId). Call after Succeeded. Queue is not implemented.",
+    prerequisites: ["keyGen", "proposalId", "Succeeded state"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoExecute" },
+    inputZod: mcpContinuumDaoProposalIdInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_cancel_multisign",
+    actionId: "continuum-dao.cancel",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build ContinuumDAO.cancel(proposalId). Proposer while Pending, or the proposal guardian.",
+    prerequisites: ["keyGen", "proposalId"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoCancel" },
+    inputZod: mcpContinuumDaoProposalIdInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_continuum_dao_build_forum_sign_in_multisign",
+    actionId: "continuum-dao.forum-sign-in",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Build an EIP-712 forum login multi-sign (no EVM tx). Checks the KeyGen address against the forum veCTM threshold first and refuses if ineligible so other nodes never enter the sign loop. Pass nodeKey (username = first 16 chars) or a username on first login. After Get Sig, node-app exchanges the signature for a forum ticket.",
+    prerequisites: [
+      "keyGen",
+      "veCTM at or above MultiSignAgentWallet.veCtmThresholdPower (holder or attach-key)",
+      "nodeKey or username"
+    ],
+    followUp: [...MCP_MULTISIGN_SUBMIT_FOLLOW_UP, "ctm_continuum_dao_forum_me"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "buildEvmMultisignBodyContinuumDaoForumSignIn" },
+    inputZod: mcpContinuumDaoForumSignInInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_supply_multisign",
+    actionId: "compound-v3.supply",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Supply base (earn or repay) or collateral to a Comet proxy. Native ETH always wraps via WETH.deposit even when useBulker is false.",
+    prerequisites: ["keyGenId", "chainId", "comet from ctm_compound_v3_fetch_markets", "asset", "amountHuman"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Supply" },
+    inputZod: mcpCompoundV3SupplyInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_withdraw_multisign",
+    actionId: "compound-v3.withdraw",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Withdraw collateral or base from a Comet. Withdraw of base while undercollateralized borrows. Native ETH always unwraps via WETH.withdraw.",
+    prerequisites: ["keyGenId", "chainId", "comet", "asset", "amountHuman", "ctm_compound_v3_fetch_account"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Withdraw" },
+    inputZod: mcpCompoundV3WithdrawInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_repay_multisign",
+    actionId: "compound-v3.repay",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Repay Comet base debt by supplying the base asset (same as supply of base while borrowed).",
+    prerequisites: ["keyGenId", "chainId", "comet", "asset (base token)", "amountHuman"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Repay" },
+    inputZod: mcpCompoundV3RepayInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_claim_rewards_multisign",
+    actionId: "compound-v3.claim-rewards",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Claim COMP / reward token from the market Rewards contract.",
+    prerequisites: ["keyGenId", "chainId", "comet", "ctm_compound_v3_fetch_account for claimable"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3ClaimRewards" },
+    inputZod: mcpCompoundV3ClaimRewardsInputSchema
+  }),
+  defineProtocolMcpTool({
+    name: "ctm_compound_v3_build_bulker_multisign",
+    actionId: "compound-v3.bulker",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "Optional combined Bulker.invoke (supply + borrow, claim + withdraw, native via Bulker). ETH wrap still works without this tool.",
+    prerequisites: ["keyGenId", "chainId", "comet", "steps"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "buildEvmMultisignBodyCompoundV3Bulker" },
+    inputZod: mcpCompoundV3BulkerInputSchema
   })
 ];
 
@@ -4350,14 +5506,218 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpCurveDaoBuildSwapMultisignInputSchema
   }),
   defineMcpTool({
-    name: "ctm_gmx_fetch_markets",
-    actionId: "gmx.fetch-markets",
-    protocolId: "gmx",
+    name: "ctm_aerodrome_discover_pools",
+    actionId: "aerodrome.discover-pools",
+    protocolId: "aerodrome",
     chainCategory: "evm",
-    description: "List GMX V2 perp markets for a chain (symbol, market token, maxLeverageLabel). Read-only; uses GMX HTTP API.",
-    prerequisites: ["chainId"],
-    followUp: ["ctm_gmx_build_increase_multisign", "ctm_gmx_build_decrease_multisign"],
-    handler: { importPath: "protocols/evm/gmx", exportName: "gmxFetchMarketsSummary" },
+    description: "Find Aerodrome v2 + Slipstream pools for one token (optional tokenOut, default USDC) via factory getPool. Tickers OK (AAPLc, USDC, ETH). Use this instead of dumping listed tokens or LpSugar.all. For a price, skip this and call ctm_aerodrome_quote. rpcUrl is injected.",
+    prerequisites: ["chainId 8453", "token (ticker or 0x)"],
+    followUp: ["ctm_aerodrome_quote", "ctm_aerodrome_quote_add_liquidity"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeDiscoverPoolsSummary" },
+    inputZod: mcpAerodromeDiscoverPoolsInputSchema,
+    outputZod: mcpAerodromeDiscoverPoolsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_fetch_pools",
+    actionId: "aerodrome.fetch-pools",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Paginated LpSugar.all pool dump on Base. Heavy \u2014 can time out. Not required for swaps: ctm_aerodrome_quote discovers Slipstream 3 / v2 routes itself (including AAPLc/USDC). Use only when browsing LP inventory.",
+    prerequisites: ["chainId 8453"],
+    followUp: ["ctm_aerodrome_quote_add_liquidity", "ctm_aerodrome_fetch_positions"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchPoolsSummary" },
+    inputZod: mcpAerodromeFetchPoolsInputSchema,
+    outputZod: mcpAerodromeFetchPoolsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_fetch_positions",
+    actionId: "aerodrome.fetch-positions",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "KeyGen Aerodrome positions (same picker as the Multi-Sign Rewards tab). Each row has label, kind (vAMM/sAMM/CL), gauge, stakedInGauge, claimFees.pool, and claimEmissions (gauge + tokenId/cl, or null). Dust v2 rows omitted. Read-only.",
+    prerequisites: ["chainId 8453", "account or keyGenId"],
+    followUp: [
+      "ctm_aerodrome_build_claim_fees_multisign",
+      "ctm_aerodrome_build_claim_emissions_multisign",
+      "ctm_aerodrome_build_cl_collect_fees_multisign"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeFetchPositionsSummary" },
+    inputZod: mcpAerodromeFetchPositionsInputSchema,
+    outputZod: mcpAerodromeFetchPositionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote",
+    actionId: "aerodrome.quote",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote an Aerodrome swap on Base. tokenIn/tokenOut accept tickers (AAPLc, USDC, ETH, WETH, AERO) or 0x addresses. Coinbase B20 stocks are 8 decimals and route via Slipstream 3 (usually a USDC hop). Returns amountOutHuman and priceImpactPercent (0\u2013100 vs a tiny same-route probe). Call this directly \u2014 do not fetch_pools or ask the user for a stock address. Does NOT create a sign request.",
+    prerequisites: ["chainId 8453", "tokenIn + tokenOut + amountHuman (tickers OK)"],
+    followUp: ["ctm_aerodrome_build_swap_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuote" },
+    inputZod: mcpAerodromeQuoteInputSchema,
+    outputZod: mcpAerodromeQuoteOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_swap_multisign",
+    actionId: "aerodrome.swap",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Create and submit mpc-auth multiSignRequest for an Aerodrome swap (optional ERC-20 approve + Router / Slipstream SwapRouter). Default deadline 30 minutes \u2014 ask the user to confirm that window and useCustomGas (via get_multi_sign_gas_options) before calling. Activate aerodrome:swap first.",
+    prerequisites: [
+      "ctm_aerodrome_quote",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + chainId 8453 + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeSwapBatch" },
+    inputZod: mcpAerodromeBuildSwapMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote_add_liquidity",
+    actionId: "aerodrome.quote-add-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote an Aerodrome deposit on Base (same as the Liquidity tab). One-sided: pass amountAHuman or amountBHuman; the other side comes from the current vAMM/sAMM reserves or Slipstream slot0. Tickers OK (AAPLc, USDC, ETH). B20 stocks are 8 decimals. ETH/stock has no pool \u2014 seedable:false and hint says pair vs USDC. Do not first-deposit an empty vAMM. Read-only.",
+    prerequisites: ["chainId 8453", "tokenA + tokenB + amountAHuman or amountBHuman (tickers OK)"],
+    followUp: ["ctm_aerodrome_build_add_liquidity_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuoteAddLiquidity" },
+    inputZod: mcpAerodromeQuoteAddLiquidityInputSchema,
+    outputZod: mcpAerodromeQuoteAddLiquidityOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_aerodrome_quote_cl_deposit",
+    actionId: "aerodrome.quote-cl-deposit",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Quote a Slipstream CL deposit (SugarHelper estimate when one side is omitted). token0/token1 accept tickers (AAPLc, USDC, ETH). Use when quote_add_liquidity returns kind:cl. Read-only.",
+    prerequisites: ["chainId 8453", "ticks + sqrtPriceX96"],
+    followUp: ["ctm_aerodrome_build_cl_mint_multisign"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "aerodromeQuoteClDeposit" },
+    inputZod: mcpAerodromeQuoteClDepositInputSchema,
+    outputZod: mcpAerodromeQuoteClDepositOutputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_add_liquidity_multisign",
+    actionId: "aerodrome.add-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to add basic vAMM/sAMM liquidity (approve + addLiquidity / addLiquidityETH). One-sided amounts OK. Refuses empty/unseedable pairs (ETH/AAPLc) and Slipstream-only quotes (use CL mint). Activate aerodrome:lp first.",
+    prerequisites: [
+      "ctm_aerodrome_quote_add_liquidity",
+      "get_multi_sign_gas_options + user confirms useCustomGas and 30-minute deadline",
+      "keyGenId + purposeText + slippagePercent"
+    ],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeAddLiquidityBatch" },
+    inputZod: mcpAerodromeBuildAddLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_remove_liquidity_multisign",
+    actionId: "aerodrome.remove-liquidity",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to remove basic-pool liquidity.",
+    prerequisites: ["keyGenId", "lpToken + liquidityHuman"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeRemoveLiquidityBatch" },
+    inputZod: mcpAerodromeBuildRemoveLiquidityMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_mint_multisign",
+    actionId: "aerodrome.cl-mint",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to mint a Slipstream concentrated liquidity NFT.",
+    prerequisites: ["ctm_aerodrome_quote_cl_deposit", "keyGenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClMintBatch" },
+    inputZod: mcpAerodromeBuildClMintMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_increase_multisign",
+    actionId: "aerodrome.cl-increase",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to increase Slipstream liquidity.",
+    prerequisites: ["keyGenId", "tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClIncreaseBatch" },
+    inputZod: mcpAerodromeBuildClIncreaseMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_decrease_multisign",
+    actionId: "aerodrome.cl-decrease",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to decrease Slipstream liquidity.",
+    prerequisites: ["keyGenId", "tokenId + liquidity"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClDecreaseBatch" },
+    inputZod: mcpAerodromeBuildClDecreaseMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_burn_multisign",
+    actionId: "aerodrome.cl-burn",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to burn an empty Slipstream position NFT.",
+    prerequisites: ["keyGenId", "tokenId (liquidity withdrawn, fees collected)"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClBurnBatch" },
+    inputZod: mcpAerodromeBuildClBurnMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_gauge_stake_multisign",
+    actionId: "aerodrome.gauge-stake",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to stake basic LP tokens or a Slipstream NFT in a gauge.",
+    prerequisites: ["keyGenId", "gauge + lpToken or tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeGaugeStakeBatch" },
+    inputZod: mcpAerodromeBuildGaugeStakeMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_gauge_unstake_multisign",
+    actionId: "aerodrome.gauge-unstake",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Submit multiSignRequest to unstake from an Aerodrome gauge.",
+    prerequisites: ["keyGenId", "gauge"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeGaugeUnstakeBatch" },
+    inputZod: mcpAerodromeBuildGaugeUnstakeMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_claim_fees_multisign",
+    actionId: "aerodrome.claim-fees",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Claim unstaked fees from the pool (dialog: \u201CFees from the pool\u201D). Pass claimFees.pool from ctm_aerodrome_fetch_positions \u2014 not the gauge. Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + purposeText + pool=claimFees.pool"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClaimFeesBatch" },
+    inputZod: mcpAerodromeBuildClaimFeesMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_cl_collect_fees_multisign",
+    actionId: "aerodrome.cl-collect-fees",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Collect Slipstream NFT fees via NFPM.collect. Pass the position id from fetch_positions (kind:cl). Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + tokenId"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClCollectBatch" },
+    inputZod: mcpAerodromeBuildClCollectFeesMultisignInputSchema
+  }),
+  defineMultisignSubmitMcpTool({
+    name: "ctm_aerodrome_build_claim_emissions_multisign",
+    actionId: "aerodrome.claim-emissions",
+    protocolId: "aerodrome",
+    chainCategory: "evm",
+    description: "Claim gauge emissions in AERO (dialog: \u201CEmissions from the gauge in AERO\u201D). Pass claimEmissions from ctm_aerodrome_fetch_positions (gauge; CL staked also needs tokenId + cl:true). Skip when claimEmissions is null. Activate aerodrome:rewards first.",
+    prerequisites: ["ctm_aerodrome_fetch_positions", "keyGenId + purposeText + gauge=claimEmissions.gauge"],
+    handler: { importPath: "protocols/evm/aerodrome", exportName: "buildEvmMultisignBodyAerodromeClaimEmissionsBatch" },
+    inputZod: mcpAerodromeBuildClaimEmissionsMultisignInputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_gmx_fetch_markets",
+    actionId: "gmx.fetch-markets",
+    protocolId: "gmx",
+    chainCategory: "evm",
+    description: "List GMX V2 perp markets for a chain (symbol, market token, maxLeverageLabel). Read-only; uses GMX HTTP API.",
+    prerequisites: ["chainId"],
+    followUp: ["ctm_gmx_build_increase_multisign", "ctm_gmx_build_decrease_multisign"],
+    handler: { importPath: "protocols/evm/gmx", exportName: "gmxFetchMarketsSummary" },
     inputZod: mcpGmxFetchMarketsInputSchema,
     outputZod: mcpGmxFetchMarketsOutputSchema
   }),
@@ -4767,6 +6127,7 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     followUp: [
       "ctm_morpho_fetch_midnight_quote",
       "ctm_morpho_build_midnight_lend_multisign",
+      "ctm_morpho_build_midnight_lend_offer_multisign",
       "ctm_morpho_build_midnight_borrow_multisign"
     ],
     handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightBooksSummary" },
@@ -4780,7 +6141,11 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     chainCategory: "evm",
     description: "Quote a Morpho Midnight book fill. side asks = lend, bids = borrow. assets is raw loan-token units.",
     prerequisites: ["marketId from ctm_morpho_fetch_midnight_books", "assets raw amount"],
-    followUp: ["ctm_morpho_build_midnight_lend_multisign", "ctm_morpho_build_midnight_borrow_multisign"],
+    followUp: [
+      "ctm_morpho_build_midnight_lend_multisign",
+      "ctm_morpho_build_midnight_lend_offer_multisign",
+      "ctm_morpho_build_midnight_borrow_multisign"
+    ],
     handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightQuoteSummary" },
     inputZod: mcpMorphoFetchMidnightQuoteInputSchema,
     outputZod: mcpMorphoFetchMidnightQuoteOutputSchema
@@ -4797,6 +6162,18 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     inputZod: mcpMorphoFetchMidnightPositionsInputSchema,
     outputZod: mcpMorphoFetchMidnightPositionsOutputSchema
   }),
+  defineMcpTool({
+    name: "ctm_morpho_fetch_midnight_offers",
+    actionId: "morpho.fetch-midnight-offers",
+    protocolId: "morpho",
+    chainCategory: "evm",
+    description: "Open Morpho Midnight maker lend offers for a user. Use group/callback/callbackData to cancel and withdraw unused Blue park.",
+    prerequisites: ["user address"],
+    followUp: ["ctm_morpho_build_midnight_cancel_lend_offer_multisign"],
+    handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchMidnightMakerOffersSummary" },
+    inputZod: mcpMorphoFetchMidnightOffersInputSchema,
+    outputZod: mcpMorphoFetchMidnightOffersOutputSchema
+  }),
   defineMcpTool({
     name: "ctm_euler_v2_fetch_lend_vaults",
     actionId: "euler-v2.fetch-lend-vaults",
@@ -4911,6 +6288,395 @@ var CORE_MCP_TOOL_DEFINITIONS = [
     handler: { importPath: "protocols/evm/morpho", exportName: "morphoFetchEarnVaultsSummary" },
     inputZod: mcpMorphoFetchEarnVaultsInputSchema,
     outputZod: mcpMorphoFetchEarnVaultsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_voting_power",
+    actionId: "continuum-dao.fetch-voting-power",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Read ContinuumDAO getVotes(account) and live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Gate propose on votes >= threshold. Linea only.",
+    prerequisites: ["rpcUrl", "account (KeyGen ETH address)", "governor"],
+    followUp: [
+      "ctm_continuum_dao_fetch_delegates",
+      "ctm_continuum_dao_build_propose_bravo_multisign",
+      "ctm_continuum_dao_build_propose_delta_multisign"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchVotingPower" },
+    inputZod: mcpContinuumDaoFetchVotingPowerInputSchema,
+    outputZod: mcpContinuumDaoFetchVotingPowerOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_delegates",
+    actionId: "continuum-dao.fetch-delegates",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Read VotingEscrow.delegates(account). self is true when voting power is not delegated away. Linea only.",
+    prerequisites: ["rpcUrl", "account (KeyGen ETH address)", "votingEscrow"],
+    followUp: [
+      "ctm_continuum_dao_build_delegate_multisign",
+      "ctm_continuum_dao_build_undelegate_multisign"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchDelegates" },
+    inputZod: mcpContinuumDaoFetchDelegatesInputSchema,
+    outputZod: mcpContinuumDaoFetchDelegatesOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_proposal_state",
+    actionId: "continuum-dao.fetch-proposal-state",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Read ContinuumDAO.state and proposalVotes for an on-chain proposal id.",
+    prerequisites: ["rpcUrl", "proposalId", "governor"],
+    followUp: [
+      "ctm_continuum_dao_build_cast_vote_bravo_multisign",
+      "ctm_continuum_dao_build_execute_multisign"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposalState" },
+    inputZod: mcpContinuumDaoFetchProposalStateInputSchema,
+    outputZod: mcpContinuumDaoFetchProposalStateOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_proposals",
+    actionId: "continuum-dao.fetch-proposals",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "List proposals from the public ContinuumDAO backend (POST /proposals). Do not use this to answer \u201Cwhat is live now\u201D \u2014 use ctm_continuum_dao_fetch_live_proposals so on-chain state is overlaid.",
+    prerequisites: [],
+    followUp: ["ctm_continuum_dao_fetch_live_proposals", "ctm_continuum_dao_fetch_proposal"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposals" },
+    inputZod: mcpContinuumDaoFetchProposalsInputSchema,
+    outputZod: mcpContinuumDaoFetchProposalsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_proposal",
+    actionId: "continuum-dao.fetch-proposal",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Fetch one proposal from the public ContinuumDAO backend (GET /proposals/:id).",
+    prerequisites: ["id"],
+    followUp: ["ctm_continuum_dao_explain_proposal", "ctm_continuum_dao_fetch_proposal_state"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchProposal" },
+    inputZod: mcpContinuumDaoFetchProposalInputSchema,
+    outputZod: mcpContinuumDaoFetchProposalOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_fetch_live_proposals",
+    actionId: "continuum-dao.fetch-live-proposals",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Answer \u201Cwhat proposals are live now?\u201D. Lists the backend catalog and overlays ContinuumDAO.state. live = Active (voting). pending = Pending. readyToExecute = Succeeded (execute from here; no queue). recentlyCompleted = Canceled/Defeated/Expired/Executed in this scan. Requires Linea chainId + rpcUrl + governor for on-chain overlay. Read the `note` field aloud.",
+    prerequisites: ["load_defi_protocol continuum-dao", "Linea chainId 59144 or 59141", "rpcUrl", "governor if constant is zero"],
+    followUp: [
+      "ctm_continuum_dao_explain_proposal",
+      "ctm_continuum_dao_fetch_proposal",
+      "ctm_continuum_dao_build_cast_vote_bravo_multisign",
+      "ctm_continuum_dao_build_execute_multisign"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoFetchLiveProposals" },
+    inputZod: mcpContinuumDaoFetchLiveProposalsInputSchema,
+    outputZod: mcpContinuumDaoFetchLiveProposalsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_explain_proposal",
+    actionId: "continuum-dao.explain-proposal",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Deconstruct a ContinuumDAO proposal for the operator. Walks every user action (Bravo) or every option (Delta), labels encoder no-ops as signaling, flags C3 / value / approve / unknown signatures, and checks the forum thread section against the proposal type. Read the `briefing` field aloud. Does not vote. For a policy recommendation load the mpc-config continuum-dao-vote-policy skill.",
+    prerequisites: ["id (backend) or onchainId"],
+    followUp: ["ctm_continuum_dao_fetch_proposal_state", "ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoExplainProposal" },
+    inputZod: mcpContinuumDaoExplainProposalInputSchema,
+    outputZod: mcpContinuumDaoExplainProposalOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_register_proposal",
+    actionId: "continuum-dao.register-proposal",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "POST /proposals/create so app.continuumdao.org stays in sync. Call after the propose multi-sign request is mined. Does not revert the chain tx if this fails \u2014 retry.",
+    prerequisites: ["onchainId from hashProposal or ProposalCreated", "title", "proposer", "forumKey", "type", "configuration"],
+    followUp: [],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoRegisterProposal" },
+    inputZod: mcpContinuumDaoRegisterProposalInputSchema,
+    outputZod: mcpContinuumDaoRegisterProposalOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_sign_in_eligible",
+    actionId: "continuum-dao.forum-sign-in-eligible",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Check whether an address may EIP-712 sign in to the forum (holder or attach-key veCTM at MultiSignAgentWallet.veCtmThresholdPower). Call this before ctm_continuum_dao_build_forum_sign_in_multisign. If eligible is false, do not start a multi-sign request.",
+    prerequisites: ["address (KeyGen ethereumaddress)"],
+    followUp: ["ctm_continuum_dao_build_forum_sign_in_multisign"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumSignInEligible" },
+    inputZod: mcpContinuumDaoForumSignInEligibleInputSchema,
+    outputZod: mcpContinuumDaoForumSignInEligibleOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_resolve",
+    actionId: "continuum-dao.forum-resolve",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Parse a ContinuumDAO forumKey URL into a NodeBB topic id.",
+    prerequisites: ["url or tid"],
+    followUp: ["ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumResolve" },
+    inputZod: mcpContinuumDaoForumResolveInputSchema,
+    outputZod: mcpContinuumDaoForumResolveOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_fetch_thread",
+    actionId: "continuum-dao.forum-fetch-thread",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Fetch a forum thread from forum.continuumdao.org. Returns cid and section (ideas / decision / election / treasury / constitution / admin). index 0 is the original post. Omit index to page through posts (start/limit). Prefer forum_fetch_post for one pid. Compare section to proposal type when evaluating.",
+    prerequisites: ["url or tid"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post", "ctm_continuum_dao_forum_reply"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumFetchThread" },
+    inputZod: mcpContinuumDaoForumFetchThreadInputSchema,
+    outputZod: mcpContinuumDaoForumFetchThreadOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_fetch_post",
+    actionId: "continuum-dao.forum-fetch-post",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Read one forum post by pid. Not the whole thread.",
+    prerequisites: ["pid"],
+    followUp: ["ctm_continuum_dao_forum_react", "ctm_continuum_dao_forum_reply"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumFetchPost" },
+    inputZod: mcpContinuumDaoForumFetchPostInputSchema,
+    outputZod: mcpContinuumDaoForumFetchPostOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_search",
+    actionId: "continuum-dao.forum-search",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Search forum.continuumdao.org. Case-insensitive match on a new thread title or any post body. Optional hours (last X hours) or since (ISO date / unix timestamp). Empty query with a time filter lists recent posts. Returns id (pid), thread title, author username, and createdAt \u2014 then ctm_continuum_dao_forum_fetch_post.",
+    prerequisites: ["query and/or hours or since"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post", "ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumSearch" },
+    inputZod: mcpContinuumDaoForumSearchInputSchema,
+    outputZod: mcpContinuumDaoForumSearchOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_recent",
+    actionId: "continuum-dao.forum-recent",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "List the most recent posts across the whole forum that the caller may read. Requires hours (last X hours) or since (ISO date / unix timestamp). Newest first. Returns id (pid), thread title, author username, and createdAt \u2014 then ctm_continuum_dao_forum_fetch_post. Optional ticket includes private categories the user can access.",
+    prerequisites: ["hours or since"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post", "ctm_continuum_dao_forum_search"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumRecent" },
+    inputZod: mcpContinuumDaoForumRecentInputSchema,
+    outputZod: mcpContinuumDaoForumRecentOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_delete",
+    actionId: "continuum-dao.forum-delete",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Admin or moderator soft-delete on forum.continuumdao.org. Requires a forum ticket. Caller must be an administrator or category moderator \u2014 post owners are refused. Exactly one of: pid (one post), tid/url (one thread), or username (that user\u2019s posts). Optional hours or since; omit both to delete all matches. Confirm with the operator before calling, especially username. Then forum_fetch_post / forum_search to verify.",
+    prerequisites: ["ticket", "exactly one of pid, tid/url, or username"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post", "ctm_continuum_dao_forum_recent", "ctm_continuum_dao_forum_sign_out"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumDelete" },
+    inputZod: mcpContinuumDaoForumDeleteInputSchema,
+    outputZod: mcpContinuumDaoForumDeleteOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_user_post_ids",
+    actionId: "continuum-dao.forum-user-post-ids",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "List forum post ids for a username (no bodies). Then call forum_fetch_post for each pid.",
+    prerequisites: ["username"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumUserPostIds" },
+    inputZod: mcpContinuumDaoForumUserPostIdsInputSchema,
+    outputZod: mcpContinuumDaoForumUserPostIdsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_reply_count",
+    actionId: "continuum-dao.forum-reply-count",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Reply count for a forum thread (excludes the original post).",
+    prerequisites: ["url or tid"],
+    followUp: ["ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumReplyCount" },
+    inputZod: mcpContinuumDaoForumReplyCountInputSchema,
+    outputZod: mcpContinuumDaoForumReplyCountOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_reply",
+    actionId: "continuum-dao.forum-reply",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Post an English reply (max 8000 characters) to a forum thread. Requires forumTicket from EIP-712 login.",
+    prerequisites: ["ticket", "content", "url or tid"],
+    followUp: ["ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumReply" },
+    inputZod: mcpContinuumDaoForumReplyInputSchema,
+    outputZod: mcpContinuumDaoForumReplyOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_react",
+    actionId: "continuum-dao.forum-react",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Toggle an allowlisted reaction on a post: +1, -1, heart, tada, eyes. Requires forumTicket.",
+    prerequisites: ["ticket", "pid", "emoji"],
+    followUp: ["ctm_continuum_dao_forum_fetch_post"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumReact" },
+    inputZod: mcpContinuumDaoForumReactInputSchema,
+    outputZod: mcpContinuumDaoForumReactOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_create_topic",
+    actionId: "continuum-dao.forum-create-topic",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Create a formal proposal thread in a Governance section: decision, election, treasury, constitution, or admin. Requires getVotes >= live proposalThreshold() and a forumTicket. Never use Ideas & Suggestions here. Pass the returned url as forumKey on build_propose_* and register_proposal. Map type Decision\u2192decision, Election\u2192election, Treasury\u2192treasury, Constitution\u2192constitution, Admin\u2192admin.",
+    prerequisites: ["ticket", "title", "content", "section or cid", "governor configured on the forum"],
+    followUp: ["ctm_continuum_dao_build_propose_bravo_multisign", "ctm_continuum_dao_build_propose_delta_multisign"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumCreateTopic" },
+    inputZod: mcpContinuumDaoForumCreateTopicInputSchema,
+    outputZod: mcpContinuumDaoForumCreateTopicOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_create_idea",
+    actionId: "continuum-dao.forum-create-idea",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Post an Idea or Suggestion (discussion only) to Ideas & Suggestions. Not a proposal and not a valid forumKey. Use this when the operator wants feedback before a Temperature Check, or the ask is not ready for on-chain governance. Wallet login required; proposalThreshold is not. Do not follow with build_propose_*.",
+    prerequisites: ["ticket", "title", "content"],
+    followUp: ["ctm_continuum_dao_forum_reply", "ctm_continuum_dao_forum_sign_out"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumCreateIdea" },
+    inputZod: mcpContinuumDaoForumCreateIdeaInputSchema,
+    outputZod: mcpContinuumDaoForumCreateIdeaOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_me",
+    actionId: "continuum-dao.forum-me",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Current forum user, votes, canPropose (Governance threads), and canPostIdea (Ideas & Suggestions).",
+    prerequisites: [],
+    followUp: [
+      "ctm_continuum_dao_forum_unread",
+      "ctm_continuum_dao_forum_sections",
+      "ctm_continuum_dao_forum_sign_out"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumMe" },
+    inputZod: mcpContinuumDaoForumMeInputSchema,
+    outputZod: mcpContinuumDaoForumMeOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_unread",
+    actionId: "continuum-dao.forum-unread",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "List unread Forum topics for the logged-in user (NodeBB Unread). Requires a forum ticket. Optional filter all/new/watched/unreplied. Returns tid, title, url, replyCount, lastPostAt \u2014 then forum_fetch_thread and forum_mark_read. Interactive only; never from cron.",
+    prerequisites: ["ticket"],
+    followUp: ["ctm_continuum_dao_forum_fetch_thread", "ctm_continuum_dao_forum_mark_read"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumUnread" },
+    inputZod: mcpContinuumDaoForumUnreadInputSchema,
+    outputZod: mcpContinuumDaoForumUnreadOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_mark_read",
+    actionId: "continuum-dao.forum-mark-read",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Mark Forum topic(s) read for the logged-in user (clears NodeBB Unread and topic notifications). Requires a ticket. Exactly one of tid/url, tids, or all. Confirm before all. Interactive only; never from cron.",
+    prerequisites: ["ticket", "exactly one of tid/url, tids, or all"],
+    followUp: ["ctm_continuum_dao_forum_unread", "ctm_continuum_dao_forum_fetch_thread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumMarkRead" },
+    inputZod: mcpContinuumDaoForumMarkReadInputSchema,
+    outputZod: mcpContinuumDaoForumMarkReadOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_mark_unread",
+    actionId: "continuum-dao.forum-mark-unread",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Mark one Forum topic unread for the logged-in user. Requires a ticket and tid or url. Interactive only; never from cron.",
+    prerequisites: ["ticket", "tid or url"],
+    followUp: ["ctm_continuum_dao_forum_unread"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumMarkUnread" },
+    inputZod: mcpContinuumDaoForumMarkUnreadInputSchema,
+    outputZod: mcpContinuumDaoForumMarkUnreadOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_sign_out",
+    actionId: "continuum-dao.forum-sign-out",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Revoke the forum ticket and destroy NodeBB sessions for that user. Requires the ticket from EIP-712 sign-in. Does not create a multi-sign request.",
+    prerequisites: ["ticket from forum sign-in"],
+    followUp: ["ctm_continuum_dao_forum_me"],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumSignOut" },
+    inputZod: mcpContinuumDaoForumSignOutInputSchema,
+    outputZod: mcpContinuumDaoForumSignOutOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_continuum_dao_forum_sections",
+    actionId: "continuum-dao.forum-sections",
+    protocolId: "continuum-dao",
+    chainCategory: "evm",
+    description: "Forum category ids: ideas (discussion only) plus Governance proposal sections decision, election, treasury, constitution, admin. Use forum_create_idea for ideas; forum_create_topic for Governance.",
+    prerequisites: [],
+    followUp: [
+      "ctm_continuum_dao_forum_recent",
+      "ctm_continuum_dao_forum_search",
+      "ctm_continuum_dao_forum_create_topic",
+      "ctm_continuum_dao_forum_create_idea"
+    ],
+    handler: { importPath: "protocols/evm/continuum-dao", exportName: "continuumDaoForumSections" },
+    inputZod: mcpContinuumDaoForumSectionsInputSchema,
+    outputZod: mcpContinuumDaoForumSectionsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_markets",
+    actionId: "compound-v3.fetch-markets",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "List Compound III Comet markets on a chain. Each market has one borrowable base and a collateral list \u2014 use this (not web search) to answer what you can borrow against an asset or which collaterals a Comet accepts. Copy comet for fetch_market / fetch_account / build_*_multisign.",
+    prerequisites: ["chainId", "get_defi_protocol_supported_chains"],
+    followUp: ["ctm_compound_v3_fetch_market", "ctm_compound_v3_fetch_account"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchMarketsSummary" },
+    inputZod: mcpCompoundV3FetchMarketsInputSchema,
+    outputZod: mcpCompoundV3FetchMarketsOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_market",
+    actionId: "compound-v3.fetch-market",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "One Comet: collateral list (what backs a borrow), collateral factors, prices, utilization, supply/borrow APR. Base is the only borrowable asset. Always uses the Comet proxy + CometInterface.",
+    prerequisites: ["comet from ctm_compound_v3_fetch_markets", "rpcUrl from chain registry"],
+    followUp: ["ctm_compound_v3_fetch_account", "ctm_compound_v3_build_supply_multisign"],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchMarketSummary" },
+    inputZod: mcpCompoundV3FetchMarketInputSchema,
+    outputZod: mcpCompoundV3FetchMarketOutputSchema
+  }),
+  defineMcpTool({
+    name: "ctm_compound_v3_fetch_account",
+    actionId: "compound-v3.fetch-account",
+    protocolId: "compound-v3",
+    chainCategory: "evm",
+    description: "User position on a Comet: base supplied, base borrowed, each collateral, isBorrowCollateralized, isLiquidatable, claimable rewards.",
+    prerequisites: ["comet from ctm_compound_v3_fetch_markets", "account", "rpcUrl from chain registry"],
+    followUp: [
+      "ctm_compound_v3_build_supply_multisign",
+      "ctm_compound_v3_build_withdraw_multisign",
+      "ctm_compound_v3_build_repay_multisign",
+      "ctm_compound_v3_build_claim_rewards_multisign"
+    ],
+    handler: { importPath: "protocols/evm/compound-v3", exportName: "compoundV3FetchAccountSummary" },
+    inputZod: mcpCompoundV3FetchAccountInputSchema,
+    outputZod: mcpCompoundV3FetchAccountOutputSchema
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -6059,6 +7825,8 @@ var morphoProtocolModule = {
     { id: "morpho.fetch-midnight-quote", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Quote Morpho Midnight lend/borrow fill", commonParams: [], params: {} },
     { id: "morpho.fetch-midnight-positions", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "List Morpho Midnight user positions", commonParams: [], params: {} },
     { id: "morpho.midnight-lend", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate lend (take asks)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-lend-offer", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight lend limit offer parked in Blue until filled", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "morpho.midnight-cancel-lend-offer", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a Morpho Midnight lend offer and withdraw unused Blue park", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.midnight-borrow", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight fixed-rate borrow (supply collateral + take bids)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
     { id: "morpho.midnight-repay", protocolId: MORPHO_PROTOCOL_ID, chainCategory: "evm", description: "Morpho Midnight repay debt and withdraw collateral", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} }
   ]
@@ -6334,6 +8102,884 @@ var veniceProtocolModule = {
   ]
 };
 registerProtocolModule(veniceProtocolModule);
+var AERODROME_PROTOCOL_ID = "aerodrome";
+var AERODROME_CHAIN_ID = 8453;
+var AERODROME_WETH_BASE = "0x4200000000000000000000000000000000000006";
+var AERODROME_USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+function isAerodromeChainSupported(chainId) {
+  const n = typeof chainId === "number" ? chainId : Number.parseInt(String(chainId), 10);
+  return n === AERODROME_CHAIN_ID;
+}
+var AERODROME_BASE_ADDRESSES_FALLBACK = {
+  aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"};
+var AERODROME_COINBASE_STOCK_TOKENS = [
+  { symbol: "AAPLc", name: "Apple Inc.", address: "0xb200000000000000000000C2e324d24d7eEcd1fb" },
+  { symbol: "NVDAc", name: "NVIDIA Corporation", address: "0xb20000000000000000000078ee7ce2fE4908108C" },
+  { symbol: "METAc", name: "Meta Platforms Inc.", address: "0xb2000000000000000000008bC8786B856E61707C" },
+  { symbol: "GOOGLc", name: "Alphabet Inc.", address: "0xb2000000000000000000002D0BA3164cc74f58B7" },
+  { symbol: "AMZNc", name: "Amazon.com Inc.", address: "0xb200000000000000000000d9192b6B456483C2E8" },
+  { symbol: "TSLAc", name: "Tesla Inc.", address: "0xb2000000000000000000001e800a7f5189430cD0" },
+  { symbol: "MSFTc", name: "Microsoft Corporation", address: "0xB200000000000000000000Ab99cFa739E253872B" },
+  { symbol: "COINc", name: "Coinbase Global Inc.", address: "0xb200000000000000000000c85a31389D71F3ecfb" },
+  { symbol: "MSTRc", name: "Strategy Inc.", address: "0xb2000000000000000000004884b426556b92883d" },
+  { symbol: "CRCLc", name: "Circle Internet Group Inc.", address: "0xB20000000000000000000019f6E7C675b73C2e4D" },
+  { symbol: "INTCc", name: "Intel Corporation", address: "0xB2000000000000000000004AFF16039bA04bdFBc" },
+  { symbol: "SNDKc", name: "Sandisk Corporation", address: "0xb200000000000000000000397293Cb8cda9a10c5" },
+  { symbol: "SPCXc", name: "Space Exploration Technologies Corp.", address: "0xb2000000000000000000007b9fcbd005511aCBd5" }
+];
+var AERODROME_COINBASE_STOCK_DECIMALS = 8;
+
+// src/protocols/evm/aerodrome/index.ts
+var aerodromeProtocolModule = {
+  id: AERODROME_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    return isAerodromeChainSupported(ctx.chainId);
+  },
+  isTokenSupported(token) {
+    if (token.category !== "evm") return false;
+    return token.kind === "native" || token.kind === "erc20";
+  },
+  actions: [
+    {
+      id: "aerodrome.quote",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Quote an Aerodrome swap on Base via factory discovery + MixedRouteQuoterV3 / Router. Tickers (AAPLc, USDC, ETH) accepted.",
+      commonParams: [],
+      params: {
+        chainId: { type: "number", required: true, description: `Must be ${AERODROME_CHAIN_ID}` },
+        tokenIn: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native" },
+        tokenOut: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH, WETH, AERO) or 0x / 0x0 native" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount (B20 stocks are 8 decimals)" }
+      }
+    },
+    {
+      id: "aerodrome.swap",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Swap via Aerodrome Router / Slipstream SwapRouter (optional ERC-20 approve batch)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenIn: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        tokenOut: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        amountHuman: { type: "string", required: true, description: "Human-readable input amount" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent (0\u2013100 exclusive)" }
+      }
+    },
+    {
+      id: "aerodrome.add-liquidity",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Deposit into a basic vAMM/sAMM pool (one-sided amounts; tickers OK)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        tokenA: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        tokenB: { type: "address", required: true, description: "Ticker (AAPLc, USDC, ETH) or 0x / 0x0 native" },
+        stable: { type: "boolean", required: true, description: "true = sAMM, false = vAMM" },
+        amountAHuman: { type: "string", required: false, description: "Amount A; omit to solve from B" },
+        amountBHuman: { type: "string", required: false, description: "Amount B; omit to solve from A" },
+        slippagePercent: { type: "number", required: true, description: "Slippage percent" }
+      }
+    },
+    {
+      id: "aerodrome.remove-liquidity",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw from a basic vAMM/sAMM pool",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        lpToken: { type: "address", required: true, description: "LP token" },
+        liquidityHuman: { type: "string", required: true, description: "LP amount" }
+      }
+    },
+    {
+      id: "aerodrome.cl-mint",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Mint a Slipstream concentrated liquidity NFT",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        token0: { type: "address", required: true, description: "Token0" },
+        token1: { type: "address", required: true, description: "Token1" },
+        tickSpacing: { type: "number", required: true, description: "Pool tick spacing" },
+        tickLower: { type: "number", required: true, description: "Lower tick" },
+        tickUpper: { type: "number", required: true, description: "Upper tick" }
+      }
+    },
+    {
+      id: "aerodrome.gauge-stake",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Stake basic LP tokens or a Slipstream NFT in a gauge",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {
+        gauge: { type: "address", required: true, description: "Gauge address" }
+      }
+    },
+    {
+      id: "aerodrome.claim-fees",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim unstaked fees from the pool (not the gauge)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { pool: { type: "address", required: true, description: "Pool lp from fetch_positions claimFees.pool" } }
+    },
+    {
+      id: "aerodrome.claim-emissions",
+      protocolId: AERODROME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim gauge emissions in AERO (not the pool)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: { gauge: { type: "address", required: true, description: "Gauge from fetch_positions claimEmissions" } }
+    }
+  ]
+};
+registerProtocolModule(aerodromeProtocolModule);
+var CONTINUUM_DAO_PROTOCOL_ID = "continuum-dao";
+var CONTINUUM_DAO_ETHEREUM_CHAIN_ID = 1;
+var CONTINUUM_DAO_LINEA_CHAIN_ID = 59144;
+var CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID = 59141;
+var CTM_TOKEN_NAME = "Continuum";
+var CTM_TOKEN_SYMBOL = "CTM";
+var VECTM_TOKEN_NAME = "Voting Escrow Continuum";
+var VECTM_TOKEN_SYMBOL = "veCTM";
+var CTM_TOKEN_DECIMALS = 18;
+var UNSET = {
+  ctm: viem.zeroAddress,
+  votingEscrow: viem.zeroAddress,
+  nodeProperties: viem.zeroAddress,
+  rewards: viem.zeroAddress,
+  governor: viem.zeroAddress
+};
+var CONTINUUM_DAO_DEPLOYMENTS = {
+  [CONTINUUM_DAO_LINEA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID]: { ...UNSET },
+  [CONTINUUM_DAO_ETHEREUM_CHAIN_ID]: {
+    ctm: viem.zeroAddress,
+    votingEscrow: viem.zeroAddress,
+    nodeProperties: viem.zeroAddress,
+    rewards: viem.zeroAddress,
+    governor: viem.zeroAddress
+  }
+};
+function isConfiguredAddress(addr) {
+  if (!addr?.trim()) return false;
+  try {
+    return viem.getAddress(addr) !== viem.zeroAddress;
+  } catch {
+    return false;
+  }
+}
+function continuumDaoDeployment(chainId) {
+  return CONTINUUM_DAO_DEPLOYMENTS[chainId] ?? null;
+}
+function isContinuumDaoLockChain(chainId) {
+  return chainId === CONTINUUM_DAO_LINEA_CHAIN_ID || chainId === CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID;
+}
+function isContinuumDaoSupportedChainId(chainId) {
+  return continuumDaoDeployment(chainId) != null;
+}
+function ctmTokenAddressOnEvmChain(chainId) {
+  const ctm = continuumDaoDeployment(chainId)?.ctm;
+  return ctm && isConfiguredAddress(ctm) ? viem.getAddress(ctm) : null;
+}
+function votingEscrowAddressOnEvmChain(chainId) {
+  const ve = continuumDaoDeployment(chainId)?.votingEscrow;
+  return ve && isConfiguredAddress(ve) ? viem.getAddress(ve) : null;
+}
+function listContinuumDaoDefaultAssets() {
+  const out = [];
+  for (const chainId of [
+    CONTINUUM_DAO_LINEA_CHAIN_ID,
+    CONTINUUM_DAO_LINEA_SEPOLIA_CHAIN_ID,
+    CONTINUUM_DAO_ETHEREUM_CHAIN_ID
+  ]) {
+    const dep = continuumDaoDeployment(chainId);
+    if (!dep) continue;
+    if (isConfiguredAddress(dep.ctm)) {
+      out.push({
+        chainId,
+        tokenType: "CTMERC20",
+        contractAddress: viem.getAddress(dep.ctm),
+        name: CTM_TOKEN_NAME,
+        symbol: CTM_TOKEN_SYMBOL,
+        decimals: CTM_TOKEN_DECIMALS
+      });
+    }
+    if (isContinuumDaoLockChain(chainId) && isConfiguredAddress(dep.votingEscrow)) {
+      out.push({
+        chainId,
+        tokenType: "ERC721",
+        contractAddress: viem.getAddress(dep.votingEscrow),
+        name: VECTM_TOKEN_NAME,
+        symbol: VECTM_TOKEN_SYMBOL
+      });
+    }
+  }
+  return out;
+}
+
+// src/protocols/evm/continuum-dao/index.ts
+var continuumDaoProtocolModule = {
+  id: CONTINUUM_DAO_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const n = typeof ctx.chainId === "number" ? ctx.chainId : Number.parseInt(String(ctx.chainId), 10);
+    return isContinuumDaoSupportedChainId(n);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "erc20" || token.kind === "erc721");
+  },
+  actions: [
+    { id: "continuum-dao.create-lock", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Approve CTM + create_lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { amountHuman: { type: "string", required: true, description: "CTM amount" }, lockDurationSeconds: { type: "string", required: true, description: "Lock duration in seconds" } } },
+    { id: "continuum-dao.increase-amount", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Increase lock amount", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, amountHuman: { type: "string", required: true, description: "CTM amount to add" } } },
+    { id: "continuum-dao.increase-unlock-time", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Increase unlock time", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, lockDurationSeconds: { type: "string", required: true, description: "Duration from week boundary to new unlock" } } },
+    { id: "continuum-dao.split", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Split a veCTM lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "Source token id" }, extractedHuman: { type: "string", required: true, description: "CTM extracted into the new lock" } } },
+    { id: "continuum-dao.merge", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Merge two veCTM locks", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { fromTokenId: { type: "string", required: true, description: "Burned token id" }, toTokenId: { type: "string", required: true, description: "Surviving token id" } } },
+    { id: "continuum-dao.withdraw", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Withdraw an expired lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao.liquidate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Liquidate a lock", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" } } },
+    { id: "continuum-dao.delegate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Delegate voting power", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { delegatee: { type: "string", required: true, description: "Delegatee address" } } },
+    { id: "continuum-dao.undelegate", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Return voting power to the KeyGen (delegate to self)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: {} },
+    { id: "continuum-dao.fetch-delegates", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Read VotingEscrow.delegates(account)", commonParams: [], params: { account: { type: "string", required: true, description: "KeyGen or wallet address" } } },
+    { id: "continuum-dao.transfer", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Transfer a veCTM NFT", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "veCTM token id" }, to: { type: "string", required: true, description: "Recipient" } } },
+    { id: "continuum-dao.attach", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Attach veCTM to the node (authority KeyGen)", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { nodeKey: { type: "string", required: true, description: "Node key" }, tokenId: { type: "string", required: true, description: "veCTM token id" }, mpaWallet: { type: "string", required: true, description: "MultiSignAgentWallet address" } } },
+    { id: "continuum-dao.request-detach", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Request governance detach", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { tokenId: { type: "string", required: true, description: "Attached token id" }, nodeProperties: { type: "string", required: true, description: "NodeProperties address" } } },
+    { id: "continuum-dao.propose-bravo", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Propose a Bravo (For/Against/Abstain) proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { title: { type: "string", required: true, description: "On-chain description (title)" }, forumKey: { type: "string", required: true, description: "Created forum thread URL from forum_create_topic" } } },
+    { id: "continuum-dao.propose-delta", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Propose a Delta multi-option proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { title: { type: "string", required: true, description: "On-chain description (title)" }, nWinners: { type: "number", required: true, description: "Winning options to execute" }, forumKey: { type: "string", required: true, description: "Created forum thread URL from forum_create_topic" } } },
+    { id: "continuum-dao.cast-vote-bravo", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cast a Bravo vote", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" }, support: { type: "number", required: true, description: "0 against, 1 for, 2 abstain" } } },
+    { id: "continuum-dao.cast-vote-delta", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cast a Delta vote including NOTA", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.execute", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Execute a succeeded proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.cancel", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Cancel a proposal", commonParams: ["keyGen", "purposeText", "useCustomGas"], params: { proposalId: { type: "string", required: true, description: "On-chain proposal id" } } },
+    { id: "continuum-dao.fetch-live-proposals", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List live/pending/succeeded proposals with on-chain state overlay", commonParams: [], params: { chainId: { type: "number", required: false, description: "Linea chain id" }, rpcUrl: { type: "string", required: false, description: "Linea RPC for state overlay" } } },
+    { id: "continuum-dao.explain-proposal", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Deconstruct a proposal into a readable briefing (actions, C3, no-ops, risks)", commonParams: [], params: { id: { type: "string", required: false, description: "Backend proposal id" }, onchainId: { type: "string", required: false, description: "Governor proposal id" } } },
+    { id: "continuum-dao.forum-sign-in", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "EIP-712 forum login (veCTM gate first)", commonParams: ["keyGen", "purposeText"], params: { nodeKey: { type: "string", required: false, description: "Attached node key" }, username: { type: "string", required: false, description: "Username when there is no node key" } } },
+    { id: "continuum-dao.forum-sign-in-eligible", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Check veCTM forum login eligibility", commonParams: [], params: { address: { type: "string", required: true, description: "KeyGen or wallet address" } } },
+    { id: "continuum-dao.forum-sign-out", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Revoke forum ticket and sessions", commonParams: [], params: { ticket: { type: "string", required: true, description: "Forum write ticket" } } },
+    { id: "continuum-dao.forum-create-topic", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Create a Governance proposal thread (not Ideas)", commonParams: [], params: { section: { type: "string", required: false, description: "decision | election | treasury | constitution | admin" }, title: { type: "string", required: true, description: "Thread title" }, content: { type: "string", required: true, description: "Proposal body" } } },
+    { id: "continuum-dao.forum-create-idea", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Post an Idea or Suggestion (not a proposal)", commonParams: [], params: { title: { type: "string", required: true, description: "Thread title" }, content: { type: "string", required: true, description: "Idea body" } } },
+    { id: "continuum-dao.forum-search", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Search forum titles and bodies; optional hours/since", commonParams: [], params: { query: { type: "string", required: false, description: "Case-insensitive title or body substring" }, hours: { type: "number", required: false, description: "Only posts from the last X hours" }, since: { type: "string", required: false, description: "Only posts since this ISO date or unix timestamp" } } },
+    { id: "continuum-dao.forum-recent", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List recent readable posts (id, title, username, createdAt); requires hours or since", commonParams: [], params: { hours: { type: "number", required: false, description: "Only posts from the last X hours" }, since: { type: "string", required: false, description: "Only posts since this ISO date or unix timestamp" } } },
+    { id: "continuum-dao.forum-delete", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Admin/moderator soft-delete a post, thread, or a user\u2019s posts", commonParams: [], params: { pid: { type: "string", required: false, description: "Post id" }, tid: { type: "string", required: false, description: "Thread id" }, username: { type: "string", required: false, description: "Delete all posts by this user" }, hours: { type: "number", required: false, description: "Only in the last X hours (default all)" }, since: { type: "string", required: false, description: "Only since this date (default all)" } } },
+    { id: "continuum-dao.forum-unread", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "List unread topics for the logged-in user", commonParams: [], params: { filter: { type: "string", required: false, description: "all | new | watched | unreplied" } } },
+    { id: "continuum-dao.forum-mark-read", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Mark topic(s) read (tid/url, tids, or all)", commonParams: [], params: { tid: { type: "string", required: false, description: "Thread id" }, all: { type: "boolean", required: false, description: "Mark every unread topic read" } } },
+    { id: "continuum-dao.forum-mark-unread", protocolId: CONTINUUM_DAO_PROTOCOL_ID, chainCategory: "evm", description: "Mark one topic unread", commonParams: [], params: { tid: { type: "string", required: false, description: "Thread id" } } }
+  ]
+};
+registerProtocolModule(continuumDaoProtocolModule);
+var COMPOUND_V3_PROTOCOL_ID = "compound-v3";
+var COMPOUND_V3_CHAIN_IDS = [1, 8453, 42161, 10, 137, 5e3, 130, 59144];
+var COMPOUND_V3_WRAPPED_NATIVE = {
+  1: viem.getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  8453: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  42161: viem.getAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+  10: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  137: viem.getAddress("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+  5e3: viem.getAddress("0x78c1b0C915c4CD0f08633e2ec3d4961Ab0237669"),
+  130: viem.getAddress("0x4200000000000000000000000000000000000006"),
+  59144: viem.getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f")
+};
+function isCompoundV3ChainSupported(chainId) {
+  return COMPOUND_V3_CHAIN_IDS.includes(chainId);
+}
+function compoundV3WrappedNative(chainId) {
+  return COMPOUND_V3_WRAPPED_NATIVE[chainId] ?? null;
+}
+var COMPOUND_V3_MARKETS = [
+  // Ethereum
+  {
+    chainId: 1,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xc3d688B66703497DAA19211EEdff47f25384cdc3"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "usds",
+    symbol: "cUSDSv3",
+    comet: viem.getAddress("0x5D409e56D886231aDAf00c8775665AD0f9897b56"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xdC035D45d973E3EC169d2276DDab16f1e407384F"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0x3Afdc9BCA9213A35503b077a6072F3D0d5AB0840"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "wbtc",
+    symbol: "cWBTCv3",
+    comet: viem.getAddress("0xe85Dc543813B8c2CFEaAc371517b925a166a9293"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0xA17581A9E3356d9A858b789D68B4d866e593aE94"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0xa397a8C2086C554B531c02E29f3291c9704B00c7"),
+    baseToken: viem.getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 1,
+    slug: "wsteth",
+    symbol: "cWstETHv3",
+    comet: viem.getAddress("0x3D0bb1ccaB520A66e607822fC55BC921738fAFE3"),
+    rewards: viem.getAddress("0x1B0e765F6224C21223AeA2af16c1C46E38885a40"),
+    bulker: viem.getAddress("0x2c776041CCFe903071AF44aa147368a9c8EEA518"),
+    baseToken: viem.getAddress("0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0"),
+    source: "comet-deployments"
+  },
+  // Base
+  {
+    chainId: 8453,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xb125E6687d4313864e53df431d5425969c15Eb2F"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "usdbc",
+    symbol: "cUSDbCv3",
+    comet: viem.getAddress("0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "usds",
+    symbol: "cUSDSv3",
+    comet: viem.getAddress("0x2c776041CCFe903071AF44aa147368a9c8EEA518"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x820C137fa70C8691f0e44Dc420a5e53c168921Dc"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x46e6b214b524310239732D51387075E0e70970bf"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 8453,
+    slug: "aero",
+    symbol: "cAEROv3",
+    comet: viem.getAddress("0x784efeB622244d2348d4F2522f8860B96fbEcE89"),
+    rewards: viem.getAddress("0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1"),
+    bulker: viem.getAddress("0x78D0677032A35c63D142a48A2037048871212a8C"),
+    baseToken: viem.getAddress("0x940181a94A35A4569E4529A3CDfB74e38FD98631"),
+    source: "comet-deployments"
+  },
+  // Arbitrum
+  {
+    chainId: 42161,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "usdc.e",
+    symbol: "cUSDC.ev3",
+    comet: viem.getAddress("0xA5EDBDD9646f8dFF606d7448e414884C7d905dCA"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0xd98Be00b5D27fc98112BdE293e487f8D4cA57d07"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 42161,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    rewards: viem.getAddress("0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae"),
+    bulker: viem.getAddress("0xbdE8F31D2DdDA895264e27DD990faB3DC87b372d"),
+    baseToken: viem.getAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+    source: "comet-deployments"
+  },
+  // Optimism
+  {
+    chainId: 10,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x2e44e174f7D53F0212823acC11C01A11d58c5bCB"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 10,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0x995E394b8B2437aC8Ce61Ee0bC610D617962B214"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 10,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0xE36A30D249f7761327fd973001A32010b521b6Fd"),
+    rewards: viem.getAddress("0x443EA0340cb75a160F31A440722dec7b5bc3C2E9"),
+    bulker: viem.getAddress("0xcb3643CC8294B23171272845473dEc49739d4Ba3"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  // Polygon
+  {
+    chainId: 137,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0xF25212E676D1F7F89Cd72fFEe66158f541246445"),
+    rewards: viem.getAddress("0x45939657d1CA34A8FA39A924B71D28Fe8431e581"),
+    bulker: viem.getAddress("0x59e242D352ae13166B4987aE5c990C232f7f7CD6"),
+    baseToken: viem.getAddress("0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 137,
+    slug: "usdt",
+    symbol: "cUSDTv3",
+    comet: viem.getAddress("0xaeB318360f27748Acb200CE616E389A6C9409a07"),
+    rewards: viem.getAddress("0x45939657d1CA34A8FA39A924B71D28Fe8431e581"),
+    bulker: viem.getAddress("0x59e242D352ae13166B4987aE5c990C232f7f7CD6"),
+    baseToken: viem.getAddress("0xc2132D05D31c914a87C6611C10748AEb04B58e8F"),
+    source: "comet-deployments"
+  },
+  // Mantle
+  {
+    chainId: 5e3,
+    slug: "usde",
+    symbol: "cUSDev3",
+    comet: viem.getAddress("0x606174f62cd968d8e684c645080fa694c1D7786E"),
+    rewards: viem.getAddress("0xCd83CbBFCE149d141A5171C3D6a0F0fCCeE225Ab"),
+    bulker: viem.getAddress("0x67DFCa85CcEEFA2C5B1dB4DEe3BEa716A28B9baa"),
+    source: "comet-deployments"
+  },
+  // Unichain
+  {
+    chainId: 130,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    rewards: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    bulker: viem.getAddress("0x58EbB8Db8b4FdF2dCbbB16E04c2F5b952963B514"),
+    baseToken: viem.getAddress("0x078D782b760474a361dDA0AF3839290b0EF57AD6"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 130,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x6C987dDE50dB1dcDd32Cd4175778C2a291978E2a"),
+    rewards: viem.getAddress("0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486"),
+    bulker: viem.getAddress("0x58EbB8Db8b4FdF2dCbbB16E04c2F5b952963B514"),
+    baseToken: viem.getAddress("0x4200000000000000000000000000000000000006"),
+    source: "comet-deployments"
+  },
+  // Linea
+  {
+    chainId: 59144,
+    slug: "usdc",
+    symbol: "cUSDCv3",
+    comet: viem.getAddress("0x8D38A3d6B3c3B7d96D6536DA7Eef94A9d7dbC991"),
+    rewards: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    bulker: viem.getAddress("0x023ee795361B28cDbB94e302983578486A0A5f1B"),
+    baseToken: viem.getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff"),
+    source: "comet-deployments"
+  },
+  {
+    chainId: 59144,
+    slug: "weth",
+    symbol: "cWETHv3",
+    comet: viem.getAddress("0x60F2058379716A64a7A5d29219397e79bC552194"),
+    rewards: viem.getAddress("0x2c7118c4C88B9841FCF839074c26Ae8f035f2921"),
+    bulker: viem.getAddress("0x023ee795361B28cDbB94e302983578486A0A5f1B"),
+    baseToken: viem.getAddress("0xe5D7C2a44FfDDf6b295A15c148167daaAf5Cf34f"),
+    source: "comet-deployments"
+  }
+];
+function listCompoundV3SupportedChainIds() {
+  return [...COMPOUND_V3_CHAIN_IDS];
+}
+function listCompoundV3MarketsForChain(chainId) {
+  if (!isCompoundV3ChainSupported(chainId)) return [];
+  return COMPOUND_V3_MARKETS.filter((m) => m.chainId === chainId);
+}
+var cometInterfaceAbi = viem.parseAbi([
+  "function supply(address asset, uint256 amount)",
+  "function supplyTo(address dst, address asset, uint256 amount)",
+  "function withdraw(address asset, uint256 amount)",
+  "function withdrawTo(address to, address asset, uint256 amount)",
+  "function allow(address manager, bool isAllowed)",
+  "function hasPermission(address owner, address manager) view returns (bool)",
+  "function balanceOf(address account) view returns (uint256)",
+  "function borrowBalanceOf(address account) view returns (uint256)",
+  "function collateralBalanceOf(address account, address asset) view returns (uint128)",
+  "function baseToken() view returns (address)",
+  "function baseTokenPriceFeed() view returns (address)",
+  "function decimals() view returns (uint8)",
+  "function numAssets() view returns (uint8)",
+  "function getUtilization() view returns (uint256)",
+  "function getSupplyRate(uint256 utilization) view returns (uint64)",
+  "function getBorrowRate(uint256 utilization) view returns (uint64)",
+  "function getPrice(address priceFeed) view returns (uint256)",
+  "function isBorrowCollateralized(address account) view returns (bool)",
+  "function isLiquidatable(address account) view returns (bool)",
+  "function getAssetInfo(uint8 i) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))",
+  "function getAssetInfoByAddress(address asset) view returns ((uint8 offset, address asset, address priceFeed, uint64 scale, uint64 borrowCollateralFactor, uint64 liquidateCollateralFactor, uint64 liquidationFactor, uint128 supplyCap))"
+]);
+viem.parseAbi([
+  "function getRewardOwed(address comet, address account) view returns ((address token, uint256 owed))",
+  "function claim(address comet, address src, bool shouldAccrue)"
+]);
+viem.parseAbi([
+  "function invoke(bytes32[] actions, bytes[] data) payable"
+]);
+var erc20ReadAbi = viem.parseAbi([
+  "function allowance(address owner, address spender) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function symbol() view returns (string)",
+  "function name() view returns (string)"
+]);
+viem.parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]);
+viem.parseAbi(["function deposit() payable", "function withdraw(uint256 wad)"]);
+function bulkerActionId(name) {
+  return viem.stringToHex(name, { size: 32 });
+}
+bulkerActionId("ACTION_SUPPLY_ASSET");
+bulkerActionId("ACTION_SUPPLY_NATIVE_TOKEN");
+bulkerActionId("ACTION_WITHDRAW_ASSET");
+bulkerActionId("ACTION_WITHDRAW_NATIVE_TOKEN");
+bulkerActionId("ACTION_CLAIM_REWARD");
+bulkerActionId("ACTION_TRANSFER_ASSET");
+
+// src/protocols/evm/compound-v3/apr.ts
+var COMPOUND_V3_SECONDS_PER_YEAR = 365 * 24 * 60 * 60;
+function compoundV3RatePerSecondToAprDecimal(ratePerSecond) {
+  if (ratePerSecond <= 0n) return 0;
+  return Number(ratePerSecond) / 1e18 * COMPOUND_V3_SECONDS_PER_YEAR;
+}
+function compoundV3AprToPercentLabel(aprDecimal) {
+  if (!Number.isFinite(aprDecimal)) return "\u2014";
+  const pct = aprDecimal * 100;
+  if (Math.abs(pct) < 1e-3) return "0.00%";
+  return `${pct.toFixed(2)}%`;
+}
+function compoundV3UtilizationToDecimal(utilization) {
+  if (utilization <= 0n) return 0;
+  return Number(utilization) / 1e18;
+}
+function compoundV3FactorToPercent(factor) {
+  return Number(factor) / 1e16;
+}
+
+// src/protocols/evm/compound-v3/subgraph.ts
+var COMPOUND_V3_SUBGRAPH_BY_CHAIN = {
+  1: "5nwMCSHaTqG3Kd2gHznbTXEnZ9QNWsssQfbHhDqQSQFp",
+  137: "AaFtUWKfFdj2x8nnE3RxTSJkHwGHvawH3VWFBykCGzLs",
+  42161: "Ff7ha9ELmpmg81D6nYxy4t8aGP26dPztqD1LDJNPqjLS",
+  8453: "2hcXhs36pTBDVUmk5K2Zkr6N4UYGwaHuco2a6jyTsijo",
+  10: "FhHNkfh5z6Z2WCEBxB6V3s8RPxnJfWZ9zAfM5bVvbvbb"
+};
+function compoundV3SubgraphIdForChain(chainId) {
+  return COMPOUND_V3_SUBGRAPH_BY_CHAIN[chainId] ?? null;
+}
+async function fetchCompoundV3SubgraphMarkets(args) {
+  const id = compoundV3SubgraphIdForChain(args.chainId);
+  const apiKey = (args.apiKey ?? process.env.THE_GRAPH_API_KEY ?? "").trim();
+  if (!id || !apiKey) return null;
+  const url = `https://gateway.thegraph.com/api/${apiKey}/subgraphs/id/${id}`;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        query: `query CompoundV3Markets { markets(first: 50) { id } }`
+      })
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const markets = json.data?.markets;
+    if (!markets) return null;
+    return markets.map((m) => ({ id: m.id, comet: m.id }));
+  } catch {
+    return null;
+  }
+}
+function publicClient(rpcUrl, chainId) {
+  const chain = viem.defineChain({
+    id: chainId,
+    name: "Destination",
+    nativeCurrency: { decimals: 18, name: "Ether", symbol: "ETH" },
+    rpcUrls: { default: { http: [rpcUrl] } }
+  });
+  return viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+}
+async function readTokenMeta(client, asset) {
+  const [symbol, decimals] = await Promise.all([
+    client.readContract({ address: asset, abi: erc20ReadAbi, functionName: "symbol" }).catch(() => "TOKEN"),
+    client.readContract({ address: asset, abi: erc20ReadAbi, functionName: "decimals" }).catch(() => 18)
+  ]);
+  return { symbol: String(symbol), decimals: Number(decimals) };
+}
+async function enrichMarketOnChain(client, market) {
+  const comet = market.comet;
+  const [baseToken, utilization, numAssets, decimals] = await Promise.all([
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseToken" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getUtilization" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "numAssets" }),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "decimals" })
+  ]);
+  const [supplyRate, borrowRate, baseMeta, baseFeed] = await Promise.all([
+    client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getSupplyRate",
+      args: [utilization]
+    }),
+    client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getBorrowRate",
+      args: [utilization]
+    }),
+    readTokenMeta(client, viem.getAddress(baseToken)),
+    client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "baseTokenPriceFeed" })
+  ]);
+  const basePrice = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [baseFeed] }).catch(() => 0n);
+  const assets = [
+    {
+      asset: viem.getAddress(baseToken),
+      symbol: baseMeta.symbol,
+      decimals: Number(decimals) || baseMeta.decimals,
+      borrowCollateralFactorPercent: 0,
+      liquidateCollateralFactorPercent: 0,
+      priceRaw: basePrice.toString(),
+      role: "base"
+    }
+  ];
+  const n = Number(numAssets);
+  for (let i = 0; i < n; i++) {
+    const info = await client.readContract({
+      address: comet,
+      abi: cometInterfaceAbi,
+      functionName: "getAssetInfo",
+      args: [i]
+    });
+    const token = viem.getAddress(info.asset);
+    const meta = await readTokenMeta(client, token);
+    const price = await client.readContract({ address: comet, abi: cometInterfaceAbi, functionName: "getPrice", args: [info.priceFeed] }).catch(() => 0n);
+    assets.push({
+      asset: token,
+      symbol: meta.symbol,
+      decimals: meta.decimals,
+      borrowCollateralFactorPercent: compoundV3FactorToPercent(info.borrowCollateralFactor),
+      liquidateCollateralFactorPercent: compoundV3FactorToPercent(info.liquidateCollateralFactor),
+      priceRaw: price.toString(),
+      role: "collateral"
+    });
+  }
+  return {
+    chainId: market.chainId,
+    slug: market.slug,
+    symbol: market.symbol,
+    comet: market.comet,
+    rewards: market.rewards,
+    bulker: market.bulker,
+    baseToken: viem.getAddress(baseToken),
+    utilization: compoundV3UtilizationToDecimal(utilization),
+    supplyAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(supplyRate)),
+    borrowAprPercent: compoundV3AprToPercentLabel(compoundV3RatePerSecondToAprDecimal(borrowRate)),
+    assets
+  };
+}
+function registryMarketRow(market) {
+  return {
+    chainId: market.chainId,
+    slug: market.slug,
+    symbol: market.symbol,
+    comet: market.comet,
+    rewards: market.rewards,
+    bulker: market.bulker,
+    baseToken: market.baseToken ?? null,
+    utilization: null,
+    supplyAprPercent: null,
+    borrowAprPercent: null,
+    assets: market.baseToken ? [
+      {
+        asset: market.baseToken,
+        symbol: market.slug.toUpperCase(),
+        decimals: 18,
+        borrowCollateralFactorPercent: 0,
+        liquidateCollateralFactorPercent: 0,
+        priceRaw: "0",
+        role: "base"
+      }
+    ] : []
+  };
+}
+async function compoundV3FetchMarketsSummary(args) {
+  if (!isCompoundV3ChainSupported(args.chainId)) {
+    return { markets: [], notes: `Compound III is not deployed on chain ${args.chainId}.` };
+  }
+  const registry = listCompoundV3MarketsForChain(args.chainId);
+  let subgraphNote = "";
+  const subgraph = await fetchCompoundV3SubgraphMarkets({ chainId: args.chainId });
+  if (subgraph) {
+    subgraphNote = ` Subgraph listed ${subgraph.length} market id(s); official comet deployments are the address source.`;
+  }
+  if (!args.rpcUrl?.trim()) {
+    return {
+      markets: registry.map(registryMarketRow),
+      notes: "Registry from official comet deployments. Pass rpcUrl (MCP server injects it) to enrich APRs and collaterals." + subgraphNote
+    };
+  }
+  const client = publicClient(args.rpcUrl, args.chainId);
+  const markets = [];
+  for (const row of registry) {
+    try {
+      markets.push(await enrichMarketOnChain(client, row));
+    } catch {
+      markets.push(registryMarketRow(row));
+    }
+  }
+  return {
+    markets,
+    notes: "Comet proxy addresses from official deployments; rates and collaterals from on-chain CometInterface." + subgraphNote
+  };
+}
+var chainAssetCache2 = /* @__PURE__ */ new Map();
+async function ensureCompoundV3ChainAssetCache(args) {
+  const existing = chainAssetCache2.get(args.chainId);
+  if (existing && existing.size > 0 && !args.rpcUrl) return existing;
+  const map = /* @__PURE__ */ new Map();
+  const add = (address, role) => {
+    const key = viem.getAddress(address).toLowerCase();
+    const cur = map.get(key) ?? { base: false, collateral: false };
+    cur[role] = true;
+    map.set(key, cur);
+  };
+  if (args.rpcUrl?.trim()) {
+    try {
+      const { markets } = await compoundV3FetchMarketsSummary({ chainId: args.chainId, rpcUrl: args.rpcUrl });
+      for (const m of markets) {
+        for (const a of m.assets) add(a.asset, a.role === "base" ? "base" : "collateral");
+      }
+      chainAssetCache2.set(args.chainId, map);
+      return map;
+    } catch {
+    }
+  }
+  for (const m of listCompoundV3MarketsForChain(args.chainId)) {
+    if (m.baseToken) add(m.baseToken, "base");
+  }
+  chainAssetCache2.set(args.chainId, map);
+  return map;
+}
+
+// src/protocols/evm/compound-v3/index.ts
+var compoundV3ProtocolModule = {
+  id: COMPOUND_V3_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    const id = typeof ctx.chainId === "string" ? Number(ctx.chainId) : ctx.chainId;
+    return ctx.chainCategory === "evm" && isCompoundV3ChainSupported(id);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
+  },
+  actions: [
+    {
+      id: "compound-v3.supply",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Supply base (earn/repay) or collateral to a Comet proxy",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.withdraw",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Withdraw collateral or base (withdraw of base while undercollateralized = borrow)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.repay",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Repay base debt by supplying base",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.claim-rewards",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Claim COMP / reward token from CometRewards",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    },
+    {
+      id: "compound-v3.bulker",
+      protocolId: COMPOUND_V3_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Combined Bulker.invoke (optional)",
+      commonParams: ["keyGen", "purposeText", "useCustomGas"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(compoundV3ProtocolModule);
 var skillsDir = path.join(path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('catalog.cjs', document.baseURI).href)))), "skills");
 var SKILL_PROTOCOL_IDS = [
   "aave-v4",
@@ -6348,7 +8994,10 @@ var SKILL_PROTOCOL_IDS = [
   "hyperliquid",
   "arcus",
   "morpho",
-  "circle-cctp"
+  "circle-cctp",
+  "aerodrome",
+  "continuum-dao",
+  "compound-v3"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -6414,6 +9063,41 @@ var EULER_V2_SUBGRAPH_CHAIN_IDS = [
 function advisor(protocolId, tokenFilter, impl) {
   return { protocolId, tokenFilter, ...impl };
 }
+function aerodromeAdvisorPriorityTokens() {
+  return [
+    {
+      address: "0x0000000000000000000000000000000000000000",
+      symbol: "ETH",
+      decimals: 18,
+      roles: ["native"]
+    },
+    {
+      address: AERODROME_WETH_BASE,
+      symbol: "WETH",
+      decimals: 18,
+      roles: ["native_wrapped"]
+    },
+    {
+      address: AERODROME_USDC_BASE,
+      symbol: "USDC",
+      decimals: 6,
+      roles: ["swappable", "listed"]
+    },
+    {
+      address: AERODROME_BASE_ADDRESSES_FALLBACK.aero,
+      symbol: "AERO",
+      decimals: 18,
+      roles: ["swappable"]
+    },
+    ...AERODROME_COINBASE_STOCK_TOKENS.map((t) => ({
+      address: t.address,
+      symbol: t.symbol,
+      name: t.name,
+      decimals: AERODROME_COINBASE_STOCK_DECIMALS,
+      roles: ["swappable", "listed", "coinbase_b20"]
+    }))
+  ];
+}
 var PROTOCOL_SUPPORT_ADVISORS = {
   "aave-v4": advisor("aave-v4", "api_underlyings", {
     async supportedChainIds() {
@@ -6680,6 +9364,21 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       };
     }
   }),
+  [AERODROME_PROTOCOL_ID]: advisor(AERODROME_PROTOCOL_ID, "pool_graph", {
+    async supportedChainIds() {
+      return [AERODROME_CHAIN_ID];
+    },
+    async supportedTokens(chainId) {
+      if (chainId !== AERODROME_CHAIN_ID) {
+        return { tokens: [], notes: "Aerodrome is Base-only (chainId 8453)." };
+      }
+      return {
+        tokens: aerodromeAdvisorPriorityTokens(),
+        nativeWrapped: AERODROME_WETH_BASE,
+        notes: "Slim directory: ETH, WETH, USDC, AERO, and Coinbase B20 stocks (AAPLc, \u2026). For a price call ctm_aerodrome_quote with tickers. To see pools for one token call ctm_aerodrome_discover_pools. Do not dump LpSugar."
+      };
+    }
+  }),
   [VENICE_PROTOCOL_ID]: advisor(VENICE_PROTOCOL_ID, "fixed_addresses", {
     async supportedChainIds() {
       return [VENICE_BASE_CHAIN_ID];
@@ -6702,6 +9401,70 @@ var PROTOCOL_SUPPORT_ADVISORS = {
       }
     }
   }),
+  [CONTINUUM_DAO_PROTOCOL_ID]: advisor(CONTINUUM_DAO_PROTOCOL_ID, "fixed_addresses", {
+    async supportedChainIds() {
+      return [1, 59144, 59141].filter((id) => isContinuumDaoSupportedChainId(id));
+    },
+    async supportedTokens(chainId) {
+      const tokens = [];
+      const ctm = ctmTokenAddressOnEvmChain(chainId);
+      if (ctm) tokens.push({ address: ctm, symbol: "CTM", roles: ["underlying"] });
+      const ve = votingEscrowAddressOnEvmChain(chainId);
+      if (ve) tokens.push({ address: ve, symbol: "veCTM", roles: ["position_nft"] });
+      return {
+        tokens,
+        notes: tokens.length === 0 ? "ContinuumDAO addresses are placeholders until redeploy. Lock/attach/governance stay Linea-only. Prefer live GET /protocol/dao. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals (not fetch_proposals). Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented." : `Default ContinuumDAO assets: ${listContinuumDaoDefaultAssets().filter((a) => a.chainId === chainId).map((a) => a.symbol).join(", ")}. Lock/attach/governance stay Linea-only. For \u201Cwhat proposals are live now?\u201D use ctm_continuum_dao_fetch_live_proposals. Propose requires getVotes >= live proposalThreshold() (max of 1000e18 ve power and 1% of total votes). Bravo empty actions insert a KeyGen no-op; Delta votes need nOptions+1 weights (last is NOTA). No billing legs. After propose is mined, ctm_continuum_dao_register_proposal. Queue is not implemented.`
+      };
+    }
+  }),
+  [COMPOUND_V3_PROTOCOL_ID]: advisor(COMPOUND_V3_PROTOCOL_ID, "api_underlyings", {
+    async supportedChainIds() {
+      return listCompoundV3SupportedChainIds();
+    },
+    async supportedTokens(chainId, ctx) {
+      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      const nativeWrapped = compoundV3WrappedNative(chainId);
+      const tokens = [];
+      if (nativeWrapped) {
+        tokens.push({
+          address: "0x0000000000000000000000000000000000000000",
+          symbol: "ETH",
+          decimals: 18,
+          roles: ["native"]
+        });
+        tokens.push({
+          address: nativeWrapped,
+          symbol: "WETH",
+          roles: ["native_wrapped"]
+        });
+      }
+      for (const [address, modes] of cache) {
+        if (nativeWrapped && address === nativeWrapped.toLowerCase()) continue;
+        tokens.push({
+          address,
+          roles: [...modes.base ? ["base"] : [], ...modes.collateral ? ["collateral"] : []]
+        });
+      }
+      return {
+        tokens,
+        nativeWrapped: nativeWrapped ?? void 0,
+        notes: "Compound III Comet base and collateral tokens. Native ETH uses wrapped native (automatic wrap/unwrap). Pass comet from ctm_compound_v3_fetch_markets."
+      };
+    },
+    async isTokenSupported(chainId, address, ctx) {
+      const cache = await ensureCompoundV3ChainAssetCache({ chainId, rpcUrl: ctx?.rpcUrl });
+      let normalized;
+      try {
+        normalized = viem.getAddress(address).toLowerCase();
+      } catch {
+        return false;
+      }
+      if (normalized === "0x0000000000000000000000000000000000000000") return true;
+      const wrapped = compoundV3WrappedNative(chainId);
+      if (wrapped && wrapped.toLowerCase() === normalized) return true;
+      return cache.has(normalized);
+    }
+  }),
   arcus: advisor("arcus", "api_underlyings", {
     async supportedChainIds() {
       return [...ARCUS_SUPPORTED_CHAIN_IDS];
@@ -6736,6 +9499,9 @@ registerProtocolModule(arcusProtocolModule);
 registerProtocolModule(morphoProtocolModule);
 registerProtocolModule(circleCctpProtocolModule);
 registerProtocolModule(veniceProtocolModule);
+registerProtocolModule(aerodromeProtocolModule);
+registerProtocolModule(continuumDaoProtocolModule);
+registerProtocolModule(compoundV3ProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -6758,6 +9524,9 @@ function getAgentCatalog() {
     morpho: morphoProtocolModule,
     circleCctp: circleCctpProtocolModule,
     venice: veniceProtocolModule,
+    aerodrome: aerodromeProtocolModule,
+    continuumDao: continuumDaoProtocolModule,
+    compoundV3: compoundV3ProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -6795,6 +9564,30 @@ exports.mcpAaveV4BorrowInputSchema = mcpAaveV4BorrowInputSchema;
 exports.mcpAaveV4DepositInputSchema = mcpAaveV4DepositInputSchema;
 exports.mcpAaveV4RepayInputSchema = mcpAaveV4RepayInputSchema;
 exports.mcpAaveV4WithdrawInputSchema = mcpAaveV4WithdrawInputSchema;
+exports.mcpAerodromeBuildAddLiquidityMultisignInputSchema = mcpAerodromeBuildAddLiquidityMultisignInputSchema;
+exports.mcpAerodromeBuildClBurnMultisignInputSchema = mcpAerodromeBuildClBurnMultisignInputSchema;
+exports.mcpAerodromeBuildClCollectFeesMultisignInputSchema = mcpAerodromeBuildClCollectFeesMultisignInputSchema;
+exports.mcpAerodromeBuildClDecreaseMultisignInputSchema = mcpAerodromeBuildClDecreaseMultisignInputSchema;
+exports.mcpAerodromeBuildClIncreaseMultisignInputSchema = mcpAerodromeBuildClIncreaseMultisignInputSchema;
+exports.mcpAerodromeBuildClMintMultisignInputSchema = mcpAerodromeBuildClMintMultisignInputSchema;
+exports.mcpAerodromeBuildClaimEmissionsMultisignInputSchema = mcpAerodromeBuildClaimEmissionsMultisignInputSchema;
+exports.mcpAerodromeBuildClaimFeesMultisignInputSchema = mcpAerodromeBuildClaimFeesMultisignInputSchema;
+exports.mcpAerodromeBuildGaugeStakeMultisignInputSchema = mcpAerodromeBuildGaugeStakeMultisignInputSchema;
+exports.mcpAerodromeBuildGaugeUnstakeMultisignInputSchema = mcpAerodromeBuildGaugeUnstakeMultisignInputSchema;
+exports.mcpAerodromeBuildRemoveLiquidityMultisignInputSchema = mcpAerodromeBuildRemoveLiquidityMultisignInputSchema;
+exports.mcpAerodromeBuildSwapMultisignInputSchema = mcpAerodromeBuildSwapMultisignInputSchema;
+exports.mcpAerodromeDiscoverPoolsInputSchema = mcpAerodromeDiscoverPoolsInputSchema;
+exports.mcpAerodromeDiscoverPoolsOutputSchema = mcpAerodromeDiscoverPoolsOutputSchema;
+exports.mcpAerodromeFetchPoolsInputSchema = mcpAerodromeFetchPoolsInputSchema;
+exports.mcpAerodromeFetchPoolsOutputSchema = mcpAerodromeFetchPoolsOutputSchema;
+exports.mcpAerodromeFetchPositionsInputSchema = mcpAerodromeFetchPositionsInputSchema;
+exports.mcpAerodromeFetchPositionsOutputSchema = mcpAerodromeFetchPositionsOutputSchema;
+exports.mcpAerodromeQuoteAddLiquidityInputSchema = mcpAerodromeQuoteAddLiquidityInputSchema;
+exports.mcpAerodromeQuoteAddLiquidityOutputSchema = mcpAerodromeQuoteAddLiquidityOutputSchema;
+exports.mcpAerodromeQuoteClDepositInputSchema = mcpAerodromeQuoteClDepositInputSchema;
+exports.mcpAerodromeQuoteClDepositOutputSchema = mcpAerodromeQuoteClDepositOutputSchema;
+exports.mcpAerodromeQuoteInputSchema = mcpAerodromeQuoteInputSchema;
+exports.mcpAerodromeQuoteOutputSchema = mcpAerodromeQuoteOutputSchema;
 exports.mcpArcusBuildCancelOrderMultisignInputSchema = mcpArcusBuildCancelOrderMultisignInputSchema;
 exports.mcpArcusBuildCloseMultisignInputSchema = mcpArcusBuildCloseMultisignInputSchema;
 exports.mcpArcusBuildCreateApiKeyMultisignInputSchema = mcpArcusBuildCreateApiKeyMultisignInputSchema;
@@ -6825,6 +9618,88 @@ exports.mcpArcusSpotFetchMarketsInputSchema = mcpArcusSpotFetchMarketsInputSchem
 exports.mcpArcusSpotFetchMarketsOutputSchema = mcpArcusSpotFetchMarketsOutputSchema;
 exports.mcpArcusSpotFetchOhlcvInputSchema = mcpArcusSpotFetchOhlcvInputSchema;
 exports.mcpArcusSpotFetchOhlcvOutputSchema = mcpArcusSpotFetchOhlcvOutputSchema;
+exports.mcpCompoundV3BulkerInputSchema = mcpCompoundV3BulkerInputSchema;
+exports.mcpCompoundV3ClaimRewardsInputSchema = mcpCompoundV3ClaimRewardsInputSchema;
+exports.mcpCompoundV3FetchAccountInputSchema = mcpCompoundV3FetchAccountInputSchema;
+exports.mcpCompoundV3FetchAccountOutputSchema = mcpCompoundV3FetchAccountOutputSchema;
+exports.mcpCompoundV3FetchMarketInputSchema = mcpCompoundV3FetchMarketInputSchema;
+exports.mcpCompoundV3FetchMarketOutputSchema = mcpCompoundV3FetchMarketOutputSchema;
+exports.mcpCompoundV3FetchMarketsInputSchema = mcpCompoundV3FetchMarketsInputSchema;
+exports.mcpCompoundV3FetchMarketsOutputSchema = mcpCompoundV3FetchMarketsOutputSchema;
+exports.mcpCompoundV3RepayInputSchema = mcpCompoundV3RepayInputSchema;
+exports.mcpCompoundV3SupplyInputSchema = mcpCompoundV3SupplyInputSchema;
+exports.mcpCompoundV3WithdrawInputSchema = mcpCompoundV3WithdrawInputSchema;
+exports.mcpContinuumDaoAttachInputSchema = mcpContinuumDaoAttachInputSchema;
+exports.mcpContinuumDaoCastVoteBravoInputSchema = mcpContinuumDaoCastVoteBravoInputSchema;
+exports.mcpContinuumDaoCastVoteDeltaInputSchema = mcpContinuumDaoCastVoteDeltaInputSchema;
+exports.mcpContinuumDaoCreateLockInputSchema = mcpContinuumDaoCreateLockInputSchema;
+exports.mcpContinuumDaoDelegateInputSchema = mcpContinuumDaoDelegateInputSchema;
+exports.mcpContinuumDaoExplainProposalInputSchema = mcpContinuumDaoExplainProposalInputSchema;
+exports.mcpContinuumDaoExplainProposalOutputSchema = mcpContinuumDaoExplainProposalOutputSchema;
+exports.mcpContinuumDaoFetchDelegatesInputSchema = mcpContinuumDaoFetchDelegatesInputSchema;
+exports.mcpContinuumDaoFetchDelegatesOutputSchema = mcpContinuumDaoFetchDelegatesOutputSchema;
+exports.mcpContinuumDaoFetchLiveProposalsInputSchema = mcpContinuumDaoFetchLiveProposalsInputSchema;
+exports.mcpContinuumDaoFetchLiveProposalsOutputSchema = mcpContinuumDaoFetchLiveProposalsOutputSchema;
+exports.mcpContinuumDaoFetchProposalInputSchema = mcpContinuumDaoFetchProposalInputSchema;
+exports.mcpContinuumDaoFetchProposalOutputSchema = mcpContinuumDaoFetchProposalOutputSchema;
+exports.mcpContinuumDaoFetchProposalStateInputSchema = mcpContinuumDaoFetchProposalStateInputSchema;
+exports.mcpContinuumDaoFetchProposalStateOutputSchema = mcpContinuumDaoFetchProposalStateOutputSchema;
+exports.mcpContinuumDaoFetchProposalsInputSchema = mcpContinuumDaoFetchProposalsInputSchema;
+exports.mcpContinuumDaoFetchProposalsOutputSchema = mcpContinuumDaoFetchProposalsOutputSchema;
+exports.mcpContinuumDaoFetchVotingPowerInputSchema = mcpContinuumDaoFetchVotingPowerInputSchema;
+exports.mcpContinuumDaoFetchVotingPowerOutputSchema = mcpContinuumDaoFetchVotingPowerOutputSchema;
+exports.mcpContinuumDaoForumCreateIdeaInputSchema = mcpContinuumDaoForumCreateIdeaInputSchema;
+exports.mcpContinuumDaoForumCreateIdeaOutputSchema = mcpContinuumDaoForumCreateIdeaOutputSchema;
+exports.mcpContinuumDaoForumCreateTopicInputSchema = mcpContinuumDaoForumCreateTopicInputSchema;
+exports.mcpContinuumDaoForumCreateTopicOutputSchema = mcpContinuumDaoForumCreateTopicOutputSchema;
+exports.mcpContinuumDaoForumDeleteInputSchema = mcpContinuumDaoForumDeleteInputSchema;
+exports.mcpContinuumDaoForumDeleteOutputSchema = mcpContinuumDaoForumDeleteOutputSchema;
+exports.mcpContinuumDaoForumFetchPostInputSchema = mcpContinuumDaoForumFetchPostInputSchema;
+exports.mcpContinuumDaoForumFetchPostOutputSchema = mcpContinuumDaoForumFetchPostOutputSchema;
+exports.mcpContinuumDaoForumFetchThreadInputSchema = mcpContinuumDaoForumFetchThreadInputSchema;
+exports.mcpContinuumDaoForumFetchThreadOutputSchema = mcpContinuumDaoForumFetchThreadOutputSchema;
+exports.mcpContinuumDaoForumMarkReadInputSchema = mcpContinuumDaoForumMarkReadInputSchema;
+exports.mcpContinuumDaoForumMarkReadOutputSchema = mcpContinuumDaoForumMarkReadOutputSchema;
+exports.mcpContinuumDaoForumMarkUnreadInputSchema = mcpContinuumDaoForumMarkUnreadInputSchema;
+exports.mcpContinuumDaoForumMarkUnreadOutputSchema = mcpContinuumDaoForumMarkUnreadOutputSchema;
+exports.mcpContinuumDaoForumMeInputSchema = mcpContinuumDaoForumMeInputSchema;
+exports.mcpContinuumDaoForumMeOutputSchema = mcpContinuumDaoForumMeOutputSchema;
+exports.mcpContinuumDaoForumReactInputSchema = mcpContinuumDaoForumReactInputSchema;
+exports.mcpContinuumDaoForumReactOutputSchema = mcpContinuumDaoForumReactOutputSchema;
+exports.mcpContinuumDaoForumRecentInputSchema = mcpContinuumDaoForumRecentInputSchema;
+exports.mcpContinuumDaoForumRecentOutputSchema = mcpContinuumDaoForumRecentOutputSchema;
+exports.mcpContinuumDaoForumReplyCountInputSchema = mcpContinuumDaoForumReplyCountInputSchema;
+exports.mcpContinuumDaoForumReplyCountOutputSchema = mcpContinuumDaoForumReplyCountOutputSchema;
+exports.mcpContinuumDaoForumReplyInputSchema = mcpContinuumDaoForumReplyInputSchema;
+exports.mcpContinuumDaoForumReplyOutputSchema = mcpContinuumDaoForumReplyOutputSchema;
+exports.mcpContinuumDaoForumResolveInputSchema = mcpContinuumDaoForumResolveInputSchema;
+exports.mcpContinuumDaoForumResolveOutputSchema = mcpContinuumDaoForumResolveOutputSchema;
+exports.mcpContinuumDaoForumSearchInputSchema = mcpContinuumDaoForumSearchInputSchema;
+exports.mcpContinuumDaoForumSearchOutputSchema = mcpContinuumDaoForumSearchOutputSchema;
+exports.mcpContinuumDaoForumSectionsInputSchema = mcpContinuumDaoForumSectionsInputSchema;
+exports.mcpContinuumDaoForumSectionsOutputSchema = mcpContinuumDaoForumSectionsOutputSchema;
+exports.mcpContinuumDaoForumSignInEligibleInputSchema = mcpContinuumDaoForumSignInEligibleInputSchema;
+exports.mcpContinuumDaoForumSignInEligibleOutputSchema = mcpContinuumDaoForumSignInEligibleOutputSchema;
+exports.mcpContinuumDaoForumSignInInputSchema = mcpContinuumDaoForumSignInInputSchema;
+exports.mcpContinuumDaoForumSignOutInputSchema = mcpContinuumDaoForumSignOutInputSchema;
+exports.mcpContinuumDaoForumSignOutOutputSchema = mcpContinuumDaoForumSignOutOutputSchema;
+exports.mcpContinuumDaoForumUnreadInputSchema = mcpContinuumDaoForumUnreadInputSchema;
+exports.mcpContinuumDaoForumUnreadOutputSchema = mcpContinuumDaoForumUnreadOutputSchema;
+exports.mcpContinuumDaoForumUserPostIdsInputSchema = mcpContinuumDaoForumUserPostIdsInputSchema;
+exports.mcpContinuumDaoForumUserPostIdsOutputSchema = mcpContinuumDaoForumUserPostIdsOutputSchema;
+exports.mcpContinuumDaoIncreaseAmountInputSchema = mcpContinuumDaoIncreaseAmountInputSchema;
+exports.mcpContinuumDaoIncreaseUnlockTimeInputSchema = mcpContinuumDaoIncreaseUnlockTimeInputSchema;
+exports.mcpContinuumDaoMergeInputSchema = mcpContinuumDaoMergeInputSchema;
+exports.mcpContinuumDaoProposalIdInputSchema = mcpContinuumDaoProposalIdInputSchema;
+exports.mcpContinuumDaoProposeBravoInputSchema = mcpContinuumDaoProposeBravoInputSchema;
+exports.mcpContinuumDaoProposeDeltaInputSchema = mcpContinuumDaoProposeDeltaInputSchema;
+exports.mcpContinuumDaoRegisterProposalInputSchema = mcpContinuumDaoRegisterProposalInputSchema;
+exports.mcpContinuumDaoRegisterProposalOutputSchema = mcpContinuumDaoRegisterProposalOutputSchema;
+exports.mcpContinuumDaoRequestDetachInputSchema = mcpContinuumDaoRequestDetachInputSchema;
+exports.mcpContinuumDaoSplitInputSchema = mcpContinuumDaoSplitInputSchema;
+exports.mcpContinuumDaoTokenIdInputSchema = mcpContinuumDaoTokenIdInputSchema;
+exports.mcpContinuumDaoTransferInputSchema = mcpContinuumDaoTransferInputSchema;
+exports.mcpContinuumDaoUndelegateInputSchema = mcpContinuumDaoUndelegateInputSchema;
 exports.mcpCurveDaoBuildSwapMultisignInputSchema = mcpCurveDaoBuildSwapMultisignInputSchema;
 exports.mcpCurveDaoQuoteInputSchema = mcpCurveDaoQuoteInputSchema;
 exports.mcpCurveDaoQuoteOutputSchema = mcpCurveDaoQuoteOutputSchema;
@@ -6918,13 +9793,17 @@ exports.mcpMorphoFetchEarnVaultsInputSchema = mcpMorphoFetchEarnVaultsInputSchem
 exports.mcpMorphoFetchEarnVaultsOutputSchema = mcpMorphoFetchEarnVaultsOutputSchema;
 exports.mcpMorphoFetchMidnightBooksInputSchema = mcpMorphoFetchMidnightBooksInputSchema;
 exports.mcpMorphoFetchMidnightBooksOutputSchema = mcpMorphoFetchMidnightBooksOutputSchema;
+exports.mcpMorphoFetchMidnightOffersInputSchema = mcpMorphoFetchMidnightOffersInputSchema;
+exports.mcpMorphoFetchMidnightOffersOutputSchema = mcpMorphoFetchMidnightOffersOutputSchema;
 exports.mcpMorphoFetchMidnightPositionsInputSchema = mcpMorphoFetchMidnightPositionsInputSchema;
 exports.mcpMorphoFetchMidnightPositionsOutputSchema = mcpMorphoFetchMidnightPositionsOutputSchema;
 exports.mcpMorphoFetchMidnightQuoteInputSchema = mcpMorphoFetchMidnightQuoteInputSchema;
 exports.mcpMorphoFetchMidnightQuoteOutputSchema = mcpMorphoFetchMidnightQuoteOutputSchema;
 exports.mcpMorphoMerklClaimInputSchema = mcpMorphoMerklClaimInputSchema;
 exports.mcpMorphoMidnightBorrowInputSchema = mcpMorphoMidnightBorrowInputSchema;
+exports.mcpMorphoMidnightCancelLendOfferInputSchema = mcpMorphoMidnightCancelLendOfferInputSchema;
 exports.mcpMorphoMidnightLendInputSchema = mcpMorphoMidnightLendInputSchema;
+exports.mcpMorphoMidnightLendOfferInputSchema = mcpMorphoMidnightLendOfferInputSchema;
 exports.mcpMorphoMidnightRepayInputSchema = mcpMorphoMidnightRepayInputSchema;
 exports.mcpMorphoVaultDepositInputSchema = mcpMorphoVaultDepositInputSchema;
 exports.mcpMorphoVaultWithdrawInputSchema = mcpMorphoVaultWithdrawInputSchema;