@continuumdao/ctm-mpc-defi 0.2.28 → 0.2.30

package/dist/agent/catalog.cjs

@@ -2305,6 +2305,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(
@@ -3972,6 +4439,217 @@ 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
   })
 ];
 
@@ -4911,6 +5589,354 @@ 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
   })
 ];
 var MCP_TOOL_DEFINITIONS = [
@@ -4988,14 +6014,22 @@ function getAgentCatalogForMcp() {
     }
   };
 }
-viem.getAddress(
+var LIDO_STETH_CONTRACT_MAINNET = viem.getAddress(
   "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84"
 );
-viem.getAddress(
+var LIDO_WSTETH_CONTRACT_MAINNET = viem.getAddress(
   "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa"
 );
 viem.getAddress("0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1");
 var LIDO_ETHEREUM_MAINNET_CHAIN_ID = 1;
+var LIDO_ROBINHOOD_CHAIN_ID = 4663;
+var LIDO_WSTETH_ROBINHOOD = viem.getAddress("0x2dC99af320BC317c567f24eE95811dcbd5983DfD");
+function listLidoSupportedChainIds() {
+  return [LIDO_ETHEREUM_MAINNET_CHAIN_ID, LIDO_ROBINHOOD_CHAIN_ID];
+}
+function isLidoSupportedChainId(chainId) {
+  return chainId === LIDO_ETHEREUM_MAINNET_CHAIN_ID || chainId === LIDO_ROBINHOOD_CHAIN_ID;
+}
 
 // src/protocols/evm/lido/index.ts
 var LIDO_PROTOCOL_ID = "lido";
@@ -5004,7 +6038,7 @@ var lidoProtocolModule = {
   chainCategory: "evm",
   isChainSupported(ctx) {
     if (ctx.chainCategory !== "evm") return false;
-    return Number(ctx.chainId) === LIDO_ETHEREUM_MAINNET_CHAIN_ID;
+    return isLidoSupportedChainId(Number(ctx.chainId));
   },
   isTokenSupported(token) {
     return token.category === "evm" && (token.kind === "native" || token.kind === "erc20");
@@ -5021,7 +6055,9 @@ registerProtocolModule(lidoProtocolModule);
 var USDE_ETHEREUM_MAINNET = "0x4c9edd5852cd905f086c759e8383e09bff1e68b3";
 var SUSDE_ETHEREUM_MAINNET = "0x9d39a5de30e57443bff2a8307a4256c8797a3497";
 var USDE_MOST_L2S = "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34";
+var SUSDE_MOST_L2S = "0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2";
 var USDE_ZKSYNC_ERA = "0x39Fe7a0DACcE31Bd90418e3e659fb0b5f0B3Db0d";
+var SUSDE_ZKSYNC_ERA = "0xAD17Da2f6Ac76746EF261E835C50b2651ce36DA8";
 var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
   42161,
   // Arbitrum One
@@ -5057,8 +6093,10 @@ var L2_SAME_ADDRESS_CHAIN_IDS = /* @__PURE__ */ new Set([
   // Morph
   1923,
   // Swell
-  48900
+  48900,
   // Zircuit
+  4663
+  // Robinhood Chain
 ]);
 var FALLBACK_NAME_BY_ID = {
   1: "Ethereum",
@@ -5080,6 +6118,7 @@ var FALLBACK_NAME_BY_ID = {
   2818: "Morph",
   1923: "Swell",
   48900: "Zircuit",
+  4663: "Robinhood Chain",
   324: "ZKSync Era"
 };
 function usdeTokenAddressOnEvmChain(chainId) {
@@ -5090,17 +6129,28 @@ function usdeTokenAddressOnEvmChain(chainId) {
 }
 function listEthenaUsdeEvmNetworkRows() {
   const rows = [
-    { chainId: 1, label: FALLBACK_NAME_BY_ID[1], usde: USDE_ETHEREUM_MAINNET }
+    {
+      chainId: 1,
+      label: FALLBACK_NAME_BY_ID[1],
+      usde: USDE_ETHEREUM_MAINNET,
+      susde: SUSDE_ETHEREUM_MAINNET
+    }
   ];
   const l2 = [...L2_SAME_ADDRESS_CHAIN_IDS].sort((a, b) => a - b);
   for (const id of l2) {
     rows.push({
       chainId: id,
       label: FALLBACK_NAME_BY_ID[id] ?? `Chain ${id}`,
-      usde: USDE_MOST_L2S
+      usde: USDE_MOST_L2S,
+      susde: SUSDE_MOST_L2S
     });
   }
-  rows.push({ chainId: 324, label: FALLBACK_NAME_BY_ID[324], usde: USDE_ZKSYNC_ERA });
+  rows.push({
+    chainId: 324,
+    label: FALLBACK_NAME_BY_ID[324],
+    usde: USDE_ZKSYNC_ERA,
+    susde: SUSDE_ZKSYNC_ERA
+  });
   return rows.sort((a, b) => {
     if (a.chainId === 1) return -1;
     if (b.chainId === 1) return 1;
@@ -6310,6 +7360,138 @@ var veniceProtocolModule = {
   ]
 };
 registerProtocolModule(veniceProtocolModule);
+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 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",
@@ -6324,7 +7506,8 @@ var SKILL_PROTOCOL_IDS = [
   "hyperliquid",
   "arcus",
   "morpho",
-  "circle-cctp"
+  "circle-cctp",
+  "continuum-dao"
 ];
 function getToolsForProtocol(protocolId) {
   return MCP_TOOL_DEFINITIONS.filter((t) => t.protocolId === protocolId);
@@ -6503,17 +7686,26 @@ var PROTOCOL_SUPPORT_ADVISORS = {
   }),
   lido: advisor("lido", "mainnet_only", {
     async supportedChainIds() {
-      return [LIDO_ETHEREUM_MAINNET_CHAIN_ID];
+      return listLidoSupportedChainIds();
     },
-    async supportedTokens() {
-      return {
-        tokens: [
-          { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", roles: ["native", "stake"] },
-          { address: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84", symbol: "stETH", roles: ["erc20"] },
-          { address: "0x7f39C581F595B853cBbF37C12FfeeA971C5a5bEa", symbol: "wstETH", roles: ["erc20"] }
-        ],
-        notes: "Lido staking and withdrawals are Ethereum mainnet only."
-      };
+    async supportedTokens(chainId) {
+      if (chainId === LIDO_ETHEREUM_MAINNET_CHAIN_ID) {
+        return {
+          tokens: [
+            { address: "0x0000000000000000000000000000000000000000", symbol: "ETH", roles: ["native", "stake"] },
+            { address: LIDO_STETH_CONTRACT_MAINNET, symbol: "stETH", roles: ["erc20"] },
+            { address: LIDO_WSTETH_CONTRACT_MAINNET, symbol: "wstETH", roles: ["erc20"] }
+          ],
+          notes: "Lido staking, withdrawals, and wrap/unwrap are Ethereum mainnet only."
+        };
+      }
+      if (chainId === LIDO_ROBINHOOD_CHAIN_ID) {
+        return {
+          tokens: [{ address: LIDO_WSTETH_ROBINHOOD, symbol: "wstETH", roles: ["erc20"] }],
+          notes: "Bridged wstETH on Robinhood Chain (CCIP). Stake/withdraw/wrap MCP tools remain mainnet-only."
+        };
+      }
+      return { tokens: [] };
     }
   }),
   ethena: advisor("ethena", "minting_contract", {
@@ -6527,14 +7719,17 @@ var PROTOCOL_SUPPORT_ADVISORS = {
             { address: USDE_ETHEREUM_MAINNET, symbol: "USDe", roles: ["stake"] },
             { address: SUSDE_ETHEREUM_MAINNET, symbol: "sUSDe", roles: ["vault"] }
           ],
-          notes: "Ethena stake/redeem UI actions are mainnet-only; USDe exists on other chains for transfers."
+          notes: "Ethena stake/redeem UI actions are mainnet-only; USDe/sUSDe exist on other chains for transfers."
         };
       }
       if (isEvmChainInEthenaUsdeList(chainId)) {
         const row = listEthenaUsdeEvmNetworkRows().find((r) => r.chainId === chainId);
         return {
-          tokens: row ? [{ address: row.usde, symbol: "USDe", roles: ["erc20"] }] : [],
-          notes: "USDe on L2; staking MCP tools target mainnet only."
+          tokens: row ? [
+            { address: row.usde, symbol: "USDe", roles: ["erc20"] },
+            { address: row.susde, symbol: "sUSDe", roles: ["erc20"] }
+          ] : [],
+          notes: "USDe/sUSDe on L2 (incl. Robinhood Chain); staking MCP tools target mainnet only."
         };
       }
       return { tokens: [] };
@@ -6666,6 +7861,22 @@ 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.`
+      };
+    }
+  }),
   arcus: advisor("arcus", "api_underlyings", {
     async supportedChainIds() {
       return [...ARCUS_SUPPORTED_CHAIN_IDS];
@@ -6700,6 +7911,7 @@ registerProtocolModule(arcusProtocolModule);
 registerProtocolModule(morphoProtocolModule);
 registerProtocolModule(circleCctpProtocolModule);
 registerProtocolModule(veniceProtocolModule);
+registerProtocolModule(continuumDaoProtocolModule);
 function getAgentCatalog() {
   return {
     protocols: getProtocolModules(),
@@ -6722,6 +7934,7 @@ function getAgentCatalog() {
     morpho: morphoProtocolModule,
     circleCctp: circleCctpProtocolModule,
     venice: veniceProtocolModule,
+    continuumDao: continuumDaoProtocolModule,
     /** Prefer getAgentCatalogForMcp() or getMcpToolDefinitions() for MCP servers. */
     mcp: getAgentCatalogForMcp()
   };
@@ -6789,6 +8002,77 @@ exports.mcpArcusSpotFetchMarketsInputSchema = mcpArcusSpotFetchMarketsInputSchem
 exports.mcpArcusSpotFetchMarketsOutputSchema = mcpArcusSpotFetchMarketsOutputSchema;
 exports.mcpArcusSpotFetchOhlcvInputSchema = mcpArcusSpotFetchOhlcvInputSchema;
 exports.mcpArcusSpotFetchOhlcvOutputSchema = mcpArcusSpotFetchOhlcvOutputSchema;
+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;