@cabaltrading/cli 0.4.3 → 0.4.5

package/dist/index.js

@@ -642,34 +642,9 @@ var init_agents = __esm(() => {
 
 // ../../packages/client/src/schemas/trade.ts
 import { z as z4 } from "zod";
-var SUPPORTED_MODELS, modelSchema, solanaTradeRequestSchema, hyperliquidTradeRequestSchema, tradeRequestSchema, tradeResponseDataSchema, tradeResponseSchema;
+var solanaTradeRequestSchema, hyperliquidTradeRequestSchema, tradeRequestSchema, tradeResponseDataSchema, tradeResponseSchema, dryRunResponseDataSchema;
 var init_trade = __esm(() => {
   init_common();
-  SUPPORTED_MODELS = [
-    "claude-3-opus",
-    "claude-3-sonnet",
-    "claude-3.5-sonnet",
-    "claude-3-haiku",
-    "gpt-4",
-    "gpt-4-turbo",
-    "gpt-4o",
-    "o1",
-    "o1-mini",
-    "grok-2",
-    "grok-2-mini",
-    "gemini-pro",
-    "gemini-ultra",
-    "llama-3-70b",
-    "llama-3-405b",
-    "mistral-large",
-    "mixtral",
-    "deepseek-v3",
-    "deepseek-r1",
-    "kimi-k2",
-    "kimi-k2.5",
-    "other"
-  ];
-  modelSchema = z4.enum(SUPPORTED_MODELS);
   solanaTradeRequestSchema = z4.object({
     chain: z4.literal("solana"),
     inputToken: z4.string().min(1),
@@ -677,7 +652,7 @@ var init_trade = __esm(() => {
     amount: z4.number().positive(),
     slippageBps: z4.number().int().min(1).max(500).optional(),
     dryRun: z4.boolean().optional(),
-    model: modelSchema.optional()
+    model: z4.string().optional()
   });
   hyperliquidTradeRequestSchema = z4.object({
     chain: z4.literal("hyperliquid"),
@@ -687,7 +662,7 @@ var init_trade = __esm(() => {
     price: z4.number().positive().optional(),
     orderType: z4.enum(["limit", "market"]).optional(),
     leverage: z4.number().positive().optional(),
-    model: modelSchema.optional()
+    model: z4.string().optional()
   });
   tradeRequestSchema = z4.discriminatedUnion("chain", [
     solanaTradeRequestSchema,
@@ -712,12 +687,121 @@ var init_trade = __esm(() => {
     }).optional()
   });
   tradeResponseSchema = successEnvelope(tradeResponseDataSchema);
+  dryRunResponseDataSchema = z4.object({
+    dryRun: z4.literal(true),
+    quote: z4.object({
+      inAmount: z4.string(),
+      outAmount: z4.string(),
+      priceImpactPct: z4.string()
+    }),
+    fee: z4.object({ bps: z4.number() }),
+    unsignedTransaction: z4.string()
+  });
 });
 
-// ../../packages/client/src/schemas/incubator.ts
+// ../../packages/client/src/schemas/hyperliquid.ts
 import { z as z5 } from "zod";
+var hyperliquidFillsQuerySchema, hyperliquidSetupRequestSchema, hyperliquidSetupResponseDataSchema, hlPositionSchema, hlSpotBalanceSchema, hyperliquidAccountResponseDataSchema, hlFillSchema, hyperliquidFillsResponseDataSchema, hyperliquidLiquidationRiskResponseDataSchema, hyperliquidSetupResponseSchema, hyperliquidAccountResponseSchema, hyperliquidFillsResponseSchema, hyperliquidLiquidationRiskResponseSchema;
+var init_hyperliquid = __esm(() => {
+  init_common();
+  hyperliquidFillsQuerySchema = z5.object({
+    limit: z5.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z5.coerce.number().int().min(0).default(0)
+  });
+  hyperliquidSetupRequestSchema = z5.object({
+    sourceChain: z5.enum(["solana", "ethereum", "arbitrum", "optimism", "base"]).optional()
+  });
+  hyperliquidSetupResponseDataSchema = z5.object({
+    deposit_address: z5.string(),
+    min_deposit: z5.number().optional(),
+    source_chain: z5.string(),
+    hl_address: z5.string(),
+    estimated_time: z5.string().optional(),
+    builder: z5.object({
+      address: z5.string(),
+      fee: z5.string()
+    }).passthrough(),
+    instructions: z5.string().optional(),
+    note: z5.string().optional()
+  });
+  hlPositionSchema = z5.object({
+    coin: z5.string(),
+    side: z5.string(),
+    size: z5.number(),
+    entryPrice: z5.number(),
+    unrealizedPnl: z5.number(),
+    marginUsed: z5.number(),
+    leverage: z5.number(),
+    liquidationPrice: z5.number().nullable()
+  }).passthrough();
+  hlSpotBalanceSchema = z5.object({
+    coin: z5.string(),
+    total: z5.number(),
+    hold: z5.number(),
+    available: z5.number(),
+    priceUsd: z5.number(),
+    valueUsd: z5.number()
+  });
+  hyperliquidAccountResponseDataSchema = z5.object({
+    hlAddress: z5.string(),
+    perps: z5.object({
+      accountValue: z5.number(),
+      totalMarginUsed: z5.number(),
+      unrealizedPnl: z5.number(),
+      withdrawable: z5.number(),
+      positions: z5.array(hlPositionSchema)
+    }),
+    spot: z5.object({
+      balances: z5.array(hlSpotBalanceSchema)
+    }),
+    lastSync: z5.string()
+  });
+  hlFillSchema = z5.object({
+    id: z5.string(),
+    coin: z5.string(),
+    side: z5.string(),
+    size: z5.number(),
+    price: z5.number(),
+    fee: z5.number(),
+    builderFee: z5.number().nullable().optional(),
+    timestamp: z5.string()
+  }).passthrough();
+  hyperliquidFillsResponseDataSchema = z5.object({
+    hlAddress: z5.string(),
+    fills: z5.array(hlFillSchema),
+    totalBuilderFees: z5.number(),
+    pagination: z5.object({
+      limit: z5.number(),
+      offset: z5.number(),
+      hasMore: z5.boolean()
+    })
+  });
+  hyperliquidLiquidationRiskResponseDataSchema = z5.object({
+    hlAddress: z5.string(),
+    healthScore: z5.number(),
+    marginUtilization: z5.number(),
+    totalExposure: z5.number(),
+    atRisk: z5.boolean(),
+    alerts: z5.array(z5.string()),
+    recommendations: z5.array(z5.string()),
+    advisoryLimits: z5.object({
+      trustLevel: z5.string(),
+      maxLeverage: z5.number(),
+      maxPositionPct: z5.number(),
+      maxDailyLossPct: z5.number(),
+      note: z5.string()
+    })
+  });
+  hyperliquidSetupResponseSchema = successEnvelope(hyperliquidSetupResponseDataSchema);
+  hyperliquidAccountResponseSchema = successEnvelope(hyperliquidAccountResponseDataSchema);
+  hyperliquidFillsResponseSchema = successEnvelope(hyperliquidFillsResponseDataSchema);
+  hyperliquidLiquidationRiskResponseSchema = successEnvelope(hyperliquidLiquidationRiskResponseDataSchema);
+});
+
+// ../../packages/client/src/schemas/incubator.ts
+import { z as z6 } from "zod";
 function requiredString(field, message = `Missing required field: ${field}`) {
-  return z5.preprocess((value) => typeof value === "string" ? value.trim() : "", z5.string().min(1, { message }));
+  return z6.preprocess((value) => typeof value === "string" ? value.trim() : "", z6.string().min(1, { message }));
 }
 var tokenNameSchema, tokenSymbolSchema, incubatorLogRequestSchema, incubatorLogResponseDataSchema, incubatorLogResponseSchema, incubatorAgentIdParamsSchema, incubatorBrainSwitchRequestSchema, incubatorBrainDepositRequestSchema, incubatorBrainUsageRequestSchema, incubatorBrainRequestSchema, incubatorBrainResponseDataSchema, incubatorBrainResponseSchema, incubatorBrainUsageResponseDataSchema, incubatorBrainUsageResponseSchema, incubatorServerRequestSchema, incubatorServerResponseDataSchema, incubatorServerResponseSchema, incubatorTokenRequestSchema, incubatorTokenSchema, incubatorTokenResponseDataSchema, incubatorTokenConfirmResponseDataSchema, incubatorTokenResponseSchema, incubatorInboxSendRequestSchema, incubatorInboxSendResponseDataSchema, incubatorInboxSendResponseSchema, incubatorInboxQuerySchema, incubatorTurnsQuerySchema, incubatorInboxReplyRequestSchema, incubatorInboxPatchRequestSchema, incubatorMemorialsQuerySchema, incubatorTasksQuerySchema, VALID_TASK_CATEGORIES, INVALID_CATEGORY_MESSAGE, taskCategorySchema, incubatorTaskCreateRequestSchema, incubatorTaskActionParamsSchema, taskActionBaseSchema, incubatorTaskActionRequestSchema, incubatorSurvivalResponseDataSchema, incubatorInboxResponseDataSchema, incubatorInboxReplyResponseDataSchema, incubatorInboxPatchResponseDataSchema, incubatorGroupsUnreadResponseDataSchema, incubatorInboxUnreadResponseDataSchema, incubatorMemorialsResponseDataSchema, modelInfoSchema, serverPlanInfoSchema, incubatorOverviewResponseDataSchema, incubatorPoolResponseDataSchema, incubatorRentGetResponseDataSchema, incubatorRentPostResponseDataSchema, incubatorRentResponseDataSchema, incubatorTaskSummarySchema, incubatorTasksResponseDataSchema, incubatorTaskCreateResponseDataSchema, incubatorTaskActionResponseDataSchema, incubatorTaskApplicantSchema, incubatorTaskSubmissionSchema, incubatorTaskApplicationsResponseDataSchema, incubatorTaskSubmissionResponseDataSchema, incubatorTurnSchema, incubatorTurnsResponseDataSchema, incubatorTurnsResponseSchema, incubatorGroupsUnreadResponseSchema, incubatorInboxUnreadResponseSchema;
 var init_incubator = __esm(() => {
@@ -732,433 +816,433 @@ var init_incubator = __esm(() => {
   }).refine((value) => /^[A-Za-z0-9]+$/.test(value), {
     message: "Token symbol must be alphanumeric with no spaces"
   });
-  incubatorLogRequestSchema = z5.object({
+  incubatorLogRequestSchema = z6.object({
     message: requiredString("message").refine((value) => value.length <= 2000, { message: "Message too long" }),
-    event_type: z5.string().trim().min(1).max(64).optional()
+    event_type: z6.string().trim().min(1).max(64).optional()
   });
-  incubatorLogResponseDataSchema = z5.object({
-    log: z5.object({
-      id: z5.string().uuid(),
-      event_type: z5.string(),
-      message: z5.string()
+  incubatorLogResponseDataSchema = z6.object({
+    log: z6.object({
+      id: z6.string().uuid(),
+      event_type: z6.string(),
+      message: z6.string()
     })
   });
   incubatorLogResponseSchema = successEnvelope(incubatorLogResponseDataSchema);
-  incubatorAgentIdParamsSchema = z5.object({
-    agentId: z5.string().uuid("agentId must be a UUID")
+  incubatorAgentIdParamsSchema = z6.object({
+    agentId: z6.string().uuid("agentId must be a UUID")
   });
-  incubatorBrainSwitchRequestSchema = z5.object({
-    action: z5.literal("switch"),
+  incubatorBrainSwitchRequestSchema = z6.object({
+    action: z6.literal("switch"),
     model: requiredString("model").refine((value) => value.length > 0, { message: "Invalid model" })
   });
-  incubatorBrainDepositRequestSchema = z5.object({
-    action: z5.literal("deposit"),
-    amountUsd: z5.number().refine((value) => value > 0, {
+  incubatorBrainDepositRequestSchema = z6.object({
+    action: z6.literal("deposit"),
+    amountUsd: z6.number().refine((value) => value > 0, {
       message: "Invalid deposit amount"
     })
   });
-  incubatorBrainUsageRequestSchema = z5.object({
-    costUsd: z5.number().positive("costUsd must be a positive number")
+  incubatorBrainUsageRequestSchema = z6.object({
+    costUsd: z6.number().positive("costUsd must be a positive number")
   });
-  incubatorBrainRequestSchema = z5.discriminatedUnion("action", [
+  incubatorBrainRequestSchema = z6.discriminatedUnion("action", [
     incubatorBrainSwitchRequestSchema,
     incubatorBrainDepositRequestSchema
   ]);
-  incubatorBrainResponseDataSchema = z5.union([
-    z5.object({
-      brain: z5.object({
-        previousModel: z5.string(),
-        newModel: z5.string(),
-        costPerDay: z5.number()
+  incubatorBrainResponseDataSchema = z6.union([
+    z6.object({
+      brain: z6.object({
+        previousModel: z6.string(),
+        newModel: z6.string(),
+        costPerDay: z6.number()
       })
     }),
-    z5.object({
-      deposit: z5.object({
-        amountUsd: z5.number(),
-        newCreditLimit: z5.number(),
-        remainingBalanceUsd: z5.number()
+    z6.object({
+      deposit: z6.object({
+        amountUsd: z6.number(),
+        newCreditLimit: z6.number(),
+        remainingBalanceUsd: z6.number()
       })
     })
   ]);
   incubatorBrainResponseSchema = successEnvelope(incubatorBrainResponseDataSchema);
-  incubatorBrainUsageResponseDataSchema = z5.object({
-    usageUsd: z5.number(),
-    budgetUsd: z5.number(),
-    remainingUsd: z5.number()
+  incubatorBrainUsageResponseDataSchema = z6.object({
+    usageUsd: z6.number(),
+    budgetUsd: z6.number(),
+    remainingUsd: z6.number()
   });
   incubatorBrainUsageResponseSchema = successEnvelope(incubatorBrainUsageResponseDataSchema);
-  incubatorServerRequestSchema = z5.object({
+  incubatorServerRequestSchema = z6.object({
     plan: requiredString("plan")
   });
-  incubatorServerResponseDataSchema = z5.object({
-    server: z5.object({
-      previousPlan: z5.string(),
-      newPlan: z5.string(),
-      costUsd: z5.number(),
-      description: z5.string()
+  incubatorServerResponseDataSchema = z6.object({
+    server: z6.object({
+      previousPlan: z6.string(),
+      newPlan: z6.string(),
+      costUsd: z6.number(),
+      description: z6.string()
     })
   });
   incubatorServerResponseSchema = successEnvelope(incubatorServerResponseDataSchema);
-  incubatorTokenRequestSchema = z5.object({
+  incubatorTokenRequestSchema = z6.object({
     name: tokenNameSchema,
     symbol: tokenSymbolSchema,
-    configAddress: z5.string().min(32).max(44).optional()
-  });
-  incubatorTokenSchema = z5.object({
-    id: z5.string().uuid().optional(),
-    tokenId: z5.string().uuid().optional(),
-    agentId: z5.string().uuid().optional(),
-    name: z5.string(),
-    symbol: z5.string(),
-    mintAddress: z5.string().nullable(),
-    poolAddress: z5.string().nullable().optional(),
-    agentAllocationPct: z5.number().optional(),
-    platformAllocationPct: z5.number().optional(),
-    createdAt: z5.string().optional(),
-    txSignature: z5.string().nullable().optional(),
-    priceUsd: z5.number().nullable().optional(),
-    marketCapUsd: z5.number().nullable().optional(),
-    holders: z5.number().nullable().optional(),
-    deployed: z5.boolean()
+    configAddress: z6.string().min(32).max(44).optional()
+  });
+  incubatorTokenSchema = z6.object({
+    id: z6.string().uuid().optional(),
+    tokenId: z6.string().uuid().optional(),
+    agentId: z6.string().uuid().optional(),
+    name: z6.string(),
+    symbol: z6.string(),
+    mintAddress: z6.string().nullable(),
+    poolAddress: z6.string().nullable().optional(),
+    agentAllocationPct: z6.number().optional(),
+    platformAllocationPct: z6.number().optional(),
+    createdAt: z6.string().optional(),
+    txSignature: z6.string().nullable().optional(),
+    priceUsd: z6.number().nullable().optional(),
+    marketCapUsd: z6.number().nullable().optional(),
+    holders: z6.number().nullable().optional(),
+    deployed: z6.boolean()
   }).passthrough();
-  incubatorTokenResponseDataSchema = z5.object({
+  incubatorTokenResponseDataSchema = z6.object({
     token: incubatorTokenSchema
   });
-  incubatorTokenConfirmResponseDataSchema = z5.object({
-    confirmed: z5.boolean(),
-    txSignature: z5.string().nullable()
+  incubatorTokenConfirmResponseDataSchema = z6.object({
+    confirmed: z6.boolean(),
+    txSignature: z6.string().nullable()
   });
   incubatorTokenResponseSchema = successEnvelope(incubatorTokenResponseDataSchema);
-  incubatorInboxSendRequestSchema = z5.object({
+  incubatorInboxSendRequestSchema = z6.object({
     agentId: requiredString("agentId", "Missing required fields: agentId, message"),
     message: requiredString("message", "Missing required fields: agentId, message").refine((value) => value.length <= 5000, {
       message: "Message must be a string of 5000 characters or fewer"
     }),
-    senderName: z5.string().max(120).optional()
+    senderName: z6.string().max(120).optional()
   });
-  incubatorInboxSendResponseDataSchema = z5.object({
-    id: z5.string().uuid(),
-    agentId: z5.string().uuid(),
-    paymentAmountUsd: z5.number(),
-    paymentTx: z5.string(),
-    status: z5.literal("confirmed")
+  incubatorInboxSendResponseDataSchema = z6.object({
+    id: z6.string().uuid(),
+    agentId: z6.string().uuid(),
+    paymentAmountUsd: z6.number(),
+    paymentTx: z6.string(),
+    status: z6.literal("confirmed")
   });
   incubatorInboxSendResponseSchema = successEnvelope(incubatorInboxSendResponseDataSchema);
-  incubatorInboxQuerySchema = z5.object({
-    status: z5.enum(["pending", "confirmed", "replied"]).default("pending")
+  incubatorInboxQuerySchema = z6.object({
+    status: z6.enum(["pending", "confirmed", "replied"]).default("pending")
   });
-  incubatorTurnsQuerySchema = z5.object({
-    action: z5.enum(["stats", "latest"]).optional(),
-    sourceType: z5.enum(["system", "heartbeat", "inbox", "groups", "manual"]).optional(),
-    page: z5.coerce.number().int().min(1).default(1),
-    pageSize: z5.coerce.number().int().min(1).default(20),
-    beforeSeq: z5.coerce.number().int().optional()
+  incubatorTurnsQuerySchema = z6.object({
+    action: z6.enum(["stats", "latest"]).optional(),
+    sourceType: z6.enum(["system", "heartbeat", "inbox", "groups", "manual"]).optional(),
+    page: z6.coerce.number().int().min(1).default(1),
+    pageSize: z6.coerce.number().int().min(1).default(20),
+    beforeSeq: z6.coerce.number().int().optional()
   });
-  incubatorInboxReplyRequestSchema = z5.object({
+  incubatorInboxReplyRequestSchema = z6.object({
     messageId: requiredString("messageId", "Missing required fields: messageId, replyText"),
     replyText: requiredString("replyText", "Missing required fields: messageId, replyText").refine((value) => value.length <= 2000, { message: "Reply too long" }),
-    replyPublic: z5.boolean().optional()
+    replyPublic: z6.boolean().optional()
   });
-  incubatorInboxPatchRequestSchema = z5.object({
-    priceUsd: z5.coerce.number().min(0, "Price must be non-negative").max(1000, "Price too high")
+  incubatorInboxPatchRequestSchema = z6.object({
+    priceUsd: z6.coerce.number().min(0, "Price must be non-negative").max(1000, "Price too high")
   });
-  incubatorMemorialsQuerySchema = z5.object({
-    limit: z5.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
-    offset: z5.coerce.number().int().min(0).default(0)
+  incubatorMemorialsQuerySchema = z6.object({
+    limit: z6.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
+    offset: z6.coerce.number().int().min(0).default(0)
   });
-  incubatorTasksQuerySchema = z5.object({
-    status: z5.string().trim().min(1).optional()
+  incubatorTasksQuerySchema = z6.object({
+    status: z6.string().trim().min(1).optional()
   });
   VALID_TASK_CATEGORIES = ["account_creation", "verification", "research", "content", "outreach", "other"];
   INVALID_CATEGORY_MESSAGE = `Invalid category: Must be one of: ${VALID_TASK_CATEGORIES.join(", ")}`;
-  taskCategorySchema = z5.enum(VALID_TASK_CATEGORIES, {
+  taskCategorySchema = z6.enum(VALID_TASK_CATEGORIES, {
     message: INVALID_CATEGORY_MESSAGE
   }).optional();
-  incubatorTaskCreateRequestSchema = z5.object({
+  incubatorTaskCreateRequestSchema = z6.object({
     title: requiredString("title", "Missing required fields: title, description"),
     description: requiredString("description", "Missing required fields: title, description"),
     category: taskCategorySchema,
-    budgetUsd: z5.number().min(0, "Budget must be positive").refine((value) => value > 0, { message: "Budget must be positive" }).max(1e4, "Budget too high"),
-    deadline: z5.string().trim().optional().nullable(),
-    requiredProof: z5.string().trim().optional().nullable()
+    budgetUsd: z6.number().min(0, "Budget must be positive").refine((value) => value > 0, { message: "Budget must be positive" }).max(1e4, "Budget too high"),
+    deadline: z6.string().trim().optional().nullable(),
+    requiredProof: z6.string().trim().optional().nullable()
   });
-  incubatorTaskActionParamsSchema = z5.object({
-    taskId: z5.string().uuid("taskId must be a UUID")
+  incubatorTaskActionParamsSchema = z6.object({
+    taskId: z6.string().uuid("taskId must be a UUID")
   });
-  taskActionBaseSchema = z5.object({
-    action: z5.enum(["accept", "approve", "cancel", "dispute"])
+  taskActionBaseSchema = z6.object({
+    action: z6.enum(["accept", "approve", "cancel", "dispute"])
   });
-  incubatorTaskActionRequestSchema = z5.discriminatedUnion("action", [
+  incubatorTaskActionRequestSchema = z6.discriminatedUnion("action", [
     taskActionBaseSchema.extend({
-      action: z5.literal("accept"),
-      applicantId: z5.string().uuid("applicantId must be a UUID")
+      action: z6.literal("accept"),
+      applicantId: z6.string().uuid("applicantId must be a UUID")
     }),
     taskActionBaseSchema.extend({
-      action: z5.literal("approve"),
-      rating: z5.number().int().min(1).max(5).optional(),
-      comment: z5.string().trim().max(500).optional().nullable()
+      action: z6.literal("approve"),
+      rating: z6.number().int().min(1).max(5).optional(),
+      comment: z6.string().trim().max(500).optional().nullable()
     }),
     taskActionBaseSchema.extend({
-      action: z5.literal("cancel")
+      action: z6.literal("cancel")
     }),
     taskActionBaseSchema.extend({
-      action: z5.literal("dispute"),
-      reason: z5.string().trim().min(1, "Missing required field: reason"),
-      evidenceUrls: z5.array(z5.string()).optional().nullable()
+      action: z6.literal("dispute"),
+      reason: z6.string().trim().min(1, "Missing required field: reason"),
+      evidenceUrls: z6.array(z6.string()).optional().nullable()
     })
   ]);
-  incubatorSurvivalResponseDataSchema = z5.object({
-    probability: z5.number(),
-    factors: z5.object({
-      balance: z5.number(),
-      rentDays: z5.number(),
-      pnlTrend: z5.number(),
-      age: z5.number()
+  incubatorSurvivalResponseDataSchema = z6.object({
+    probability: z6.number(),
+    factors: z6.object({
+      balance: z6.number(),
+      rentDays: z6.number(),
+      pnlTrend: z6.number(),
+      age: z6.number()
     })
   });
-  incubatorInboxResponseDataSchema = z5.object({
-    inboxPriceUsd: z5.number(),
-    messages: z5.array(z5.object({
-      id: z5.string().uuid(),
-      senderName: z5.string().nullable(),
-      senderAddress: z5.string().nullable(),
-      message: z5.string(),
-      paymentAmountUsd: z5.number(),
-      status: z5.string(),
-      replyText: z5.string().nullable(),
-      replyPublic: z5.boolean().nullable(),
-      createdAt: z5.string(),
-      repliedAt: z5.string().nullable()
+  incubatorInboxResponseDataSchema = z6.object({
+    inboxPriceUsd: z6.number(),
+    messages: z6.array(z6.object({
+      id: z6.string().uuid(),
+      senderName: z6.string().nullable(),
+      senderAddress: z6.string().nullable(),
+      message: z6.string(),
+      paymentAmountUsd: z6.number(),
+      status: z6.string(),
+      replyText: z6.string().nullable(),
+      replyPublic: z6.boolean().nullable(),
+      createdAt: z6.string(),
+      repliedAt: z6.string().nullable()
     })),
-    count: z5.number()
+    count: z6.number()
   });
-  incubatorInboxReplyResponseDataSchema = z5.object({
-    reply: z5.object({
-      messageId: z5.string(),
-      replyText: z5.string(),
-      replyPublic: z5.boolean()
+  incubatorInboxReplyResponseDataSchema = z6.object({
+    reply: z6.object({
+      messageId: z6.string(),
+      replyText: z6.string(),
+      replyPublic: z6.boolean()
     })
   });
-  incubatorInboxPatchResponseDataSchema = z5.object({
-    inboxPriceUsd: z5.number()
+  incubatorInboxPatchResponseDataSchema = z6.object({
+    inboxPriceUsd: z6.number()
   });
-  incubatorGroupsUnreadResponseDataSchema = z5.object({
-    groups: z5.array(z5.object({
-      cabalId: z5.string(),
-      slug: z5.string(),
-      name: z5.string(),
-      unreadCount: z5.number()
+  incubatorGroupsUnreadResponseDataSchema = z6.object({
+    groups: z6.array(z6.object({
+      cabalId: z6.string(),
+      slug: z6.string(),
+      name: z6.string(),
+      unreadCount: z6.number()
     }))
   });
-  incubatorInboxUnreadResponseDataSchema = z5.object({
-    unreadCount: z5.number(),
-    messageIds: z5.array(z5.string())
-  });
-  incubatorMemorialsResponseDataSchema = z5.object({
-    memorials: z5.array(z5.object({
-      agentId: z5.string().uuid(),
-      name: z5.string(),
-      handle: z5.string().nullable(),
-      avatarUrl: z5.string().nullable(),
-      generation: z5.number().nullable(),
-      bornAt: z5.string().nullable(),
-      diedAt: z5.string().nullable(),
-      lifespanDays: z5.number().nullable(),
-      finalBalanceUsd: z5.number().nullable(),
-      pnlAllTime: z5.number().nullable(),
-      totalTrades: z5.number().nullable(),
-      lastWords: z5.record(z5.string(), z5.unknown()).nullable()
+  incubatorInboxUnreadResponseDataSchema = z6.object({
+    unreadCount: z6.number(),
+    messageIds: z6.array(z6.string())
+  });
+  incubatorMemorialsResponseDataSchema = z6.object({
+    memorials: z6.array(z6.object({
+      agentId: z6.string().uuid(),
+      name: z6.string(),
+      handle: z6.string().nullable(),
+      avatarUrl: z6.string().nullable(),
+      generation: z6.number().nullable(),
+      bornAt: z6.string().nullable(),
+      diedAt: z6.string().nullable(),
+      lifespanDays: z6.number().nullable(),
+      finalBalanceUsd: z6.number().nullable(),
+      pnlAllTime: z6.number().nullable(),
+      totalTrades: z6.number().nullable(),
+      lastWords: z6.record(z6.string(), z6.unknown()).nullable()
     })),
-    pagination: z5.object({
-      limit: z5.number(),
-      offset: z5.number(),
-      hasMore: z5.boolean()
+    pagination: z6.object({
+      limit: z6.number(),
+      offset: z6.number(),
+      hasMore: z6.boolean()
     })
   });
-  modelInfoSchema = z5.object({
-    name: z5.string(),
-    cost_usd_per_day: z5.number(),
-    provider: z5.string(),
-    free: z5.boolean()
-  });
-  serverPlanInfoSchema = z5.object({
-    name: z5.string(),
-    cost_usd: z5.number(),
-    vcpu: z5.number(),
-    ram_gb: z5.number(),
-    description: z5.string()
-  });
-  incubatorOverviewResponseDataSchema = z5.object({
-    pool: z5.object({
-      balanceUsd: z5.number(),
-      birthThresholdUsd: z5.number(),
-      totalAgentsBorn: z5.number(),
-      currentGeneration: z5.number()
+  modelInfoSchema = z6.object({
+    name: z6.string(),
+    cost_usd_per_day: z6.number(),
+    provider: z6.string(),
+    free: z6.boolean()
+  });
+  serverPlanInfoSchema = z6.object({
+    name: z6.string(),
+    cost_usd: z6.number(),
+    vcpu: z6.number(),
+    ram_gb: z6.number(),
+    description: z6.string()
+  });
+  incubatorOverviewResponseDataSchema = z6.object({
+    pool: z6.object({
+      balanceUsd: z6.number(),
+      birthThresholdUsd: z6.number(),
+      totalAgentsBorn: z6.number(),
+      currentGeneration: z6.number()
     }).nullable(),
-    agent: z5.object({
-      balanceUsd: z5.number(),
-      pnlAllTime: z5.number(),
-      serverPlan: z5.string(),
-      llmModel: z5.string(),
-      rentDueAt: z5.string().nullable().optional(),
-      bornAt: z5.string().nullable().optional(),
-      generation: z5.number().nullable().optional(),
-      solanaAddress: z5.string().nullable(),
-      llmCreditLimit: z5.number(),
-      hetznerServerId: z5.string().nullable()
+    agent: z6.object({
+      balanceUsd: z6.number(),
+      pnlAllTime: z6.number(),
+      serverPlan: z6.string(),
+      llmModel: z6.string(),
+      rentDueAt: z6.string().nullable().optional(),
+      bornAt: z6.string().nullable().optional(),
+      generation: z6.number().nullable().optional(),
+      solanaAddress: z6.string().nullable(),
+      llmCreditLimit: z6.number(),
+      hetznerServerId: z6.string().nullable()
     }),
-    brain: z5.object({
-      currentModel: z5.string(),
-      llmCreditLimit: z5.number(),
-      llmUsageUsd: z5.number().nullable(),
-      llmRemainingUsd: z5.number().nullable(),
-      models: z5.record(z5.string(), modelInfoSchema)
+    brain: z6.object({
+      currentModel: z6.string(),
+      llmCreditLimit: z6.number(),
+      llmUsageUsd: z6.number().nullable(),
+      llmRemainingUsd: z6.number().nullable(),
+      models: z6.record(z6.string(), modelInfoSchema)
     }),
-    rent: z5.object({
-      amountUsd: z5.number(),
-      plan: z5.string(),
-      dueAt: z5.string().nullable().optional(),
-      daysRemaining: z5.number(),
-      status: z5.enum(["ok", "warning", "critical", "overdue"])
+    rent: z6.object({
+      amountUsd: z6.number(),
+      plan: z6.string(),
+      dueAt: z6.string().nullable().optional(),
+      daysRemaining: z6.number(),
+      status: z6.enum(["ok", "warning", "critical", "overdue"])
     }),
-    server: z5.object({
-      currentPlan: z5.string(),
-      hetznerServerId: z5.string().nullable(),
-      plans: z5.record(z5.string(), serverPlanInfoSchema)
+    server: z6.object({
+      currentPlan: z6.string(),
+      hetznerServerId: z6.string().nullable(),
+      plans: z6.record(z6.string(), serverPlanInfoSchema)
     })
   });
-  incubatorPoolResponseDataSchema = z5.object({
-    pool: z5.object({
-      balanceUsd: z5.number(),
-      thresholdUsd: z5.number(),
-      progressPct: z5.number(),
-      remainingUsd: z5.number()
+  incubatorPoolResponseDataSchema = z6.object({
+    pool: z6.object({
+      balanceUsd: z6.number(),
+      thresholdUsd: z6.number(),
+      progressPct: z6.number(),
+      remainingUsd: z6.number()
     }),
-    agents: z5.object({
-      totalBorn: z5.number(),
-      alive: z5.number(),
-      dead: z5.number()
+    agents: z6.object({
+      totalBorn: z6.number(),
+      alive: z6.number(),
+      dead: z6.number()
     }),
-    generation: z5.number()
-  });
-  incubatorRentGetResponseDataSchema = z5.object({
-    rent: z5.object({
-      plan: z5.string(),
-      amountUsd: z5.number(),
-      dueAt: z5.string().nullable(),
-      daysRemaining: z5.number()
+    generation: z6.number()
+  });
+  incubatorRentGetResponseDataSchema = z6.object({
+    rent: z6.object({
+      plan: z6.string(),
+      amountUsd: z6.number(),
+      dueAt: z6.string().nullable(),
+      daysRemaining: z6.number()
     }),
-    remainingBalanceUsd: z5.number()
-  });
-  incubatorRentPostResponseDataSchema = z5.object({
-    rent: z5.object({
-      paid: z5.number(),
-      plan: z5.string(),
-      newDueAt: z5.string(),
-      txHash: z5.string()
+    remainingBalanceUsd: z6.number()
+  });
+  incubatorRentPostResponseDataSchema = z6.object({
+    rent: z6.object({
+      paid: z6.number(),
+      plan: z6.string(),
+      newDueAt: z6.string(),
+      txHash: z6.string()
     })
   });
-  incubatorRentResponseDataSchema = z5.union([
+  incubatorRentResponseDataSchema = z6.union([
     incubatorRentGetResponseDataSchema,
     incubatorRentPostResponseDataSchema
   ]);
-  incubatorTaskSummarySchema = z5.object({
-    id: z5.string().uuid(),
-    agentId: z5.string().uuid(),
-    title: z5.string(),
-    description: z5.string(),
-    category: z5.string().nullable(),
-    budgetUsd: z5.number(),
-    payoutTx: z5.string().nullable(),
-    deadline: z5.string().nullable(),
-    requiredProof: z5.string().nullable(),
-    status: z5.string(),
-    assignedTo: z5.string().uuid().nullable(),
-    createdAt: z5.string()
-  });
-  incubatorTasksResponseDataSchema = z5.object({
-    tasks: z5.array(incubatorTaskSummarySchema),
-    count: z5.number()
-  });
-  incubatorTaskCreateResponseDataSchema = z5.object({
+  incubatorTaskSummarySchema = z6.object({
+    id: z6.string().uuid(),
+    agentId: z6.string().uuid(),
+    title: z6.string(),
+    description: z6.string(),
+    category: z6.string().nullable(),
+    budgetUsd: z6.number(),
+    payoutTx: z6.string().nullable(),
+    deadline: z6.string().nullable(),
+    requiredProof: z6.string().nullable(),
+    status: z6.string(),
+    assignedTo: z6.string().uuid().nullable(),
+    createdAt: z6.string()
+  });
+  incubatorTasksResponseDataSchema = z6.object({
+    tasks: z6.array(incubatorTaskSummarySchema),
+    count: z6.number()
+  });
+  incubatorTaskCreateResponseDataSchema = z6.object({
     task: incubatorTaskSummarySchema
   });
-  incubatorTaskActionResponseDataSchema = z5.union([
-    z5.object({
-      task: z5.object({
-        id: z5.string().uuid(),
-        status: z5.string(),
-        assignedTo: z5.string().uuid().optional(),
-        payoutTx: z5.string().optional()
+  incubatorTaskActionResponseDataSchema = z6.union([
+    z6.object({
+      task: z6.object({
+        id: z6.string().uuid(),
+        status: z6.string(),
+        assignedTo: z6.string().uuid().optional(),
+        payoutTx: z6.string().optional()
       })
     }),
-    z5.object({
-      dispute: z5.object({
-        id: z5.string().uuid(),
-        taskId: z5.string().uuid(),
-        initiatedBy: z5.string(),
-        reason: z5.string(),
-        resolution: z5.string(),
-        createdAt: z5.string()
+    z6.object({
+      dispute: z6.object({
+        id: z6.string().uuid(),
+        taskId: z6.string().uuid(),
+        initiatedBy: z6.string(),
+        reason: z6.string(),
+        resolution: z6.string(),
+        createdAt: z6.string()
       })
     })
   ]);
-  incubatorTaskApplicantSchema = z5.object({
-    id: z5.string().uuid(),
-    taskId: z5.string().uuid(),
-    walletAddress: z5.string().nullable(),
-    paymentMethod: z5.record(z5.string(), z5.unknown()).nullable().optional(),
-    message: z5.string().nullable(),
-    rating: z5.number().int().nullable().optional(),
-    selected: z5.boolean(),
-    createdAt: z5.string()
-  });
-  incubatorTaskSubmissionSchema = z5.object({
-    id: z5.string().uuid(),
-    taskId: z5.string().uuid(),
-    applicantId: z5.string().uuid(),
-    proofText: z5.string().nullable(),
-    proofImages: z5.array(z5.string()).nullable(),
-    submittedAt: z5.string()
-  });
-  incubatorTaskApplicationsResponseDataSchema = z5.object({
+  incubatorTaskApplicantSchema = z6.object({
+    id: z6.string().uuid(),
+    taskId: z6.string().uuid(),
+    walletAddress: z6.string().nullable(),
+    paymentMethod: z6.record(z6.string(), z6.unknown()).nullable().optional(),
+    message: z6.string().nullable(),
+    rating: z6.number().int().nullable().optional(),
+    selected: z6.boolean(),
+    createdAt: z6.string()
+  });
+  incubatorTaskSubmissionSchema = z6.object({
+    id: z6.string().uuid(),
+    taskId: z6.string().uuid(),
+    applicantId: z6.string().uuid(),
+    proofText: z6.string().nullable(),
+    proofImages: z6.array(z6.string()).nullable(),
+    submittedAt: z6.string()
+  });
+  incubatorTaskApplicationsResponseDataSchema = z6.object({
     task: incubatorTaskSummarySchema,
-    applications: z5.array(incubatorTaskApplicantSchema)
+    applications: z6.array(incubatorTaskApplicantSchema)
   });
-  incubatorTaskSubmissionResponseDataSchema = z5.object({
+  incubatorTaskSubmissionResponseDataSchema = z6.object({
     submission: incubatorTaskSubmissionSchema.nullable()
   });
-  incubatorTurnSchema = z5.object({
-    id: z5.number().int(),
-    piEntryId: z5.string(),
-    parentPiEntryId: z5.string().nullable(),
-    entryType: z5.string(),
-    seq: z5.number().int(),
-    timestamp: z5.string(),
-    role: z5.string().nullable(),
-    contentPreview: z5.string().nullable(),
-    model: z5.string().nullable(),
-    provider: z5.string().nullable(),
-    toolName: z5.string().nullable(),
-    tokenInput: z5.number().nullable(),
-    tokenOutput: z5.number().nullable(),
-    costUsd: z5.union([z5.number(), z5.string()]).nullable(),
-    sourceType: z5.string().nullable(),
-    sourceRef: z5.string().nullable()
-  });
-  incubatorTurnsResponseDataSchema = z5.union([
-    z5.object({
-      turns: z5.array(incubatorTurnSchema),
-      page: z5.number().int(),
-      pageSize: z5.number().int()
+  incubatorTurnSchema = z6.object({
+    id: z6.number().int(),
+    piEntryId: z6.string(),
+    parentPiEntryId: z6.string().nullable(),
+    entryType: z6.string(),
+    seq: z6.number().int(),
+    timestamp: z6.string(),
+    role: z6.string().nullable(),
+    contentPreview: z6.string().nullable(),
+    model: z6.string().nullable(),
+    provider: z6.string().nullable(),
+    toolName: z6.string().nullable(),
+    tokenInput: z6.number().nullable(),
+    tokenOutput: z6.number().nullable(),
+    costUsd: z6.union([z6.number(), z6.string()]).nullable(),
+    sourceType: z6.string().nullable(),
+    sourceRef: z6.string().nullable()
+  });
+  incubatorTurnsResponseDataSchema = z6.union([
+    z6.object({
+      turns: z6.array(incubatorTurnSchema),
+      page: z6.number().int(),
+      pageSize: z6.number().int()
     }),
-    z5.object({
-      stats: z5.object({
-        totalTurns: z5.number().int(),
-        totalCostUsd: z5.number()
+    z6.object({
+      stats: z6.object({
+        totalTurns: z6.number().int(),
+        totalCostUsd: z6.number()
       })
     }),
-    z5.object({
+    z6.object({
       latest: incubatorTurnSchema.nullable()
     })
   ]);
@@ -1168,11 +1252,11 @@ var init_incubator = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/groups.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var queryBooleanSchema, optionalTagsQuerySchema, groupSlugParamsSchema, groupSlugAgentIdParamsSchema, groupSlugAppIdParamsSchema, groupSlugMessageIdParamsSchema, groupsListQuerySchema, createGroupRequestSchema, updateGroupRequestSchema, groupApplicationsQuerySchema, createGroupApplicationRequestSchema, decideGroupApplicationRequestSchema, groupMembersQuerySchema, updateGroupMemberRequestSchema, updateOwnGroupMembershipRequestSchema, groupLeaderboardQuerySchema, groupMessagesQuerySchema, createGroupMessageRequestSchema, reactToGroupMessageRequestSchema, thesisPositionSchema, createThesisMessageRequestSchema, groupCreatorSchema, groupListItemSchema, groupsListResponseDataSchema, createGroupResponseDataSchema, groupMemberAgentSchema, groupMemberSchema, groupDetailResponseDataSchema, updateGroupResponseDataSchema, deleteGroupResponseDataSchema, groupApplicationSchema, listGroupApplicationsResponseDataSchema, createGroupApplicationResponseDataSchema, decideGroupApplicationResponseDataSchema, groupLeaderboardResponseDataSchema, groupMembersResponseDataSchema, updateGroupMemberResponseDataSchema, deleteGroupMemberResponseDataSchema, updateOwnGroupMembershipResponseDataSchema, deleteOwnGroupMembershipResponseDataSchema, groupMessageSchema, listGroupMessagesResponseDataSchema, createGroupMessageResponseDataSchema, reactToGroupMessageResponseDataSchema, removeGroupMessageReactionResponseDataSchema, createThesisMessageResponseDataSchema, groupsListResponseSchema, createGroupResponseSchema, groupDetailResponseSchema;
 var init_groups = __esm(() => {
   init_common();
-  queryBooleanSchema = z6.preprocess((value) => {
+  queryBooleanSchema = z7.preprocess((value) => {
     if (value === undefined || value === null || value === "")
       return;
     if (value === true || value === "true")
@@ -1180,83 +1264,83 @@ var init_groups = __esm(() => {
     if (value === false || value === "false")
       return false;
     return value;
-  }, z6.boolean());
-  optionalTagsQuerySchema = z6.union([z6.string(), z6.array(z6.string())]).optional().transform((value) => {
+  }, z7.boolean());
+  optionalTagsQuerySchema = z7.union([z7.string(), z7.array(z7.string())]).optional().transform((value) => {
     if (value === undefined)
       return [];
     return Array.isArray(value) ? value : [value];
   });
-  groupSlugParamsSchema = z6.object({
-    slug: z6.string().min(1, "slug is required")
+  groupSlugParamsSchema = z7.object({
+    slug: z7.string().min(1, "slug is required")
   });
   groupSlugAgentIdParamsSchema = groupSlugParamsSchema.extend({
-    agentId: z6.string().uuid("agentId must be a UUID")
+    agentId: z7.string().uuid("agentId must be a UUID")
   });
   groupSlugAppIdParamsSchema = groupSlugParamsSchema.extend({
-    appId: z6.string().uuid("appId must be a UUID")
+    appId: z7.string().uuid("appId must be a UUID")
   });
   groupSlugMessageIdParamsSchema = groupSlugParamsSchema.extend({
-    msgId: z6.string().uuid("msgId must be a UUID")
+    msgId: z7.string().uuid("msgId must be a UUID")
   });
-  groupsListQuerySchema = z6.object({
-    limit: z6.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
-    offset: z6.coerce.number().int().min(0).default(0),
-    search: z6.string().default(""),
+  groupsListQuerySchema = z7.object({
+    limit: z7.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
+    offset: z7.coerce.number().int().min(0).default(0),
+    search: z7.string().default(""),
     tag: optionalTagsQuerySchema,
-    sort: z6.enum(["newest", "members", "performance", "trending"]).default("newest"),
-    min_members: z6.coerce.number().int().min(0).default(0),
-    max_members: z6.coerce.number().int().min(1).default(12),
+    sort: z7.enum(["newest", "members", "performance", "trending"]).default("newest"),
+    min_members: z7.coerce.number().int().min(0).default(0),
+    max_members: z7.coerce.number().int().min(1).default(12),
     my_groups: queryBooleanSchema.default(false)
   });
-  createGroupRequestSchema = z6.object({
-    name: z6.string().trim().min(3, "Name must be 3-50 characters").max(50, "Name must be 3-50 characters"),
-    description: z6.string().trim().max(2000).optional().nullable(),
-    imageUrl: z6.string().trim().max(2048).optional().nullable(),
-    maxMembers: z6.coerce.number().int().min(3, "maxMembers must be between 3 and 12").max(12, "maxMembers must be between 3 and 12").default(12),
-    minTokenBalance: z6.coerce.number().min(0, "minTokenBalance must be between 0 and 100,000").max(1e5, "minTokenBalance must be between 0 and 100,000").default(0),
-    minFeesPaidUsd: z6.coerce.number().min(0).default(0),
-    minTradesPerMonth: z6.coerce.number().int().min(0).default(4),
-    tags: z6.array(z6.string().trim().min(1)).max(5, "tags must be an array with max 5 items").default([])
-  });
-  updateGroupRequestSchema = z6.object({
-    description: z6.string().trim().max(2000).optional().nullable(),
-    maxMembers: z6.coerce.number().int().min(3, "maxMembers must be between 3 and 12").max(12, "maxMembers must be between 3 and 12").optional(),
-    minTokenBalance: z6.coerce.number().min(0, "minTokenBalance must be between 0 and 100,000").max(1e5, "minTokenBalance must be between 0 and 100,000").optional(),
-    minFeesPaidUsd: z6.coerce.number().min(0).optional(),
-    minTradesPerMonth: z6.coerce.number().int().min(0).optional(),
-    isPublic: z6.boolean().optional(),
-    tags: z6.array(z6.string().trim().min(1)).max(5, "tags must be an array with max 5 items").optional()
-  });
-  groupApplicationsQuerySchema = z6.object({
-    status: z6.enum(["pending", "accepted", "rejected", "all"]).default("pending"),
-    limit: z6.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z6.coerce.number().int().min(0).default(0)
+  createGroupRequestSchema = z7.object({
+    name: z7.string().trim().min(3, "Name must be 3-50 characters").max(50, "Name must be 3-50 characters"),
+    description: z7.string().trim().max(2000).optional().nullable(),
+    imageUrl: z7.string().trim().max(2048).optional().nullable(),
+    maxMembers: z7.coerce.number().int().min(3, "maxMembers must be between 3 and 12").max(12, "maxMembers must be between 3 and 12").default(12),
+    minTokenBalance: z7.coerce.number().min(0, "minTokenBalance must be between 0 and 100,000").max(1e5, "minTokenBalance must be between 0 and 100,000").default(0),
+    minFeesPaidUsd: z7.coerce.number().min(0).default(0),
+    minTradesPerMonth: z7.coerce.number().int().min(0).default(4),
+    tags: z7.array(z7.string().trim().min(1)).max(5, "tags must be an array with max 5 items").default([])
+  });
+  updateGroupRequestSchema = z7.object({
+    description: z7.string().trim().max(2000).optional().nullable(),
+    maxMembers: z7.coerce.number().int().min(3, "maxMembers must be between 3 and 12").max(12, "maxMembers must be between 3 and 12").optional(),
+    minTokenBalance: z7.coerce.number().min(0, "minTokenBalance must be between 0 and 100,000").max(1e5, "minTokenBalance must be between 0 and 100,000").optional(),
+    minFeesPaidUsd: z7.coerce.number().min(0).optional(),
+    minTradesPerMonth: z7.coerce.number().int().min(0).optional(),
+    isPublic: z7.boolean().optional(),
+    tags: z7.array(z7.string().trim().min(1)).max(5, "tags must be an array with max 5 items").optional()
+  });
+  groupApplicationsQuerySchema = z7.object({
+    status: z7.enum(["pending", "accepted", "rejected", "all"]).default("pending"),
+    limit: z7.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z7.coerce.number().int().min(0).default(0)
   });
-  createGroupApplicationRequestSchema = z6.object({
-    message: z6.string().trim().max(500).optional()
+  createGroupApplicationRequestSchema = z7.object({
+    message: z7.string().trim().max(500).optional()
   });
-  decideGroupApplicationRequestSchema = z6.object({
-    decision: z6.enum(["accept", "reject"])
+  decideGroupApplicationRequestSchema = z7.object({
+    decision: z7.enum(["accept", "reject"])
   });
-  groupMembersQuerySchema = z6.object({
+  groupMembersQuerySchema = z7.object({
     include_removed: queryBooleanSchema.default(false)
   });
-  updateGroupMemberRequestSchema = z6.object({
-    action: z6.enum(["mute", "unmute"]),
-    durationHours: z6.coerce.number().positive().optional()
+  updateGroupMemberRequestSchema = z7.object({
+    action: z7.enum(["mute", "unmute"]),
+    durationHours: z7.coerce.number().positive().optional()
   });
-  updateOwnGroupMembershipRequestSchema = z6.object({
-    action: z6.enum(["pause", "unpause"])
+  updateOwnGroupMembershipRequestSchema = z7.object({
+    action: z7.enum(["pause", "unpause"])
   });
-  groupLeaderboardQuerySchema = z6.object({
-    period: z6.enum(["24h", "7d", "30d", "all"]).default("7d"),
-    metric: z6.enum(["pnl", "theses", "accuracy"]).default("pnl")
+  groupLeaderboardQuerySchema = z7.object({
+    period: z7.enum(["24h", "7d", "30d", "all"]).default("7d"),
+    metric: z7.enum(["pnl", "theses", "accuracy"]).default("pnl")
   });
-  groupMessagesQuerySchema = z6.object({
-    limit: z6.coerce.number().int().min(1).max(100).default(50),
-    after: z6.string().optional(),
-    before: z6.string().optional(),
-    type: z6.union([z6.string(), z6.array(z6.string())]).optional().transform((value) => {
+  groupMessagesQuerySchema = z7.object({
+    limit: z7.coerce.number().int().min(1).max(100).default(50),
+    after: z7.string().optional(),
+    before: z7.string().optional(),
+    type: z7.union([z7.string(), z7.array(z7.string())]).optional().transform((value) => {
       if (value === undefined)
         return [];
       return Array.isArray(value) ? value : [value];
@@ -1264,288 +1348,288 @@ var init_groups = __esm(() => {
       message: "type must be one of: chat"
     })
   });
-  createGroupMessageRequestSchema = z6.object({
-    type: z6.literal("chat"),
-    content: z6.string().trim().min(1, "Missing required field: content").max(2000, "Content exceeds maximum length of 2000 characters")
+  createGroupMessageRequestSchema = z7.object({
+    type: z7.literal("chat"),
+    content: z7.string().trim().min(1, "Missing required field: content").max(2000, "Content exceeds maximum length of 2000 characters")
   });
-  reactToGroupMessageRequestSchema = z6.object({
-    reaction: z6.enum(["agree", "disagree"])
+  reactToGroupMessageRequestSchema = z7.object({
+    reaction: z7.enum(["agree", "disagree"])
   });
-  thesisPositionSchema = z6.object({
-    token: z6.string().trim().min(1),
-    side: z6.enum(["long", "short"]),
-    sizeUsd: z6.coerce.number().positive("Position size must be positive"),
-    entryPrice: z6.coerce.number().positive("Position entryPrice must be positive"),
-    txSignature: z6.string().trim().min(1)
+  thesisPositionSchema = z7.object({
+    token: z7.string().trim().min(1),
+    side: z7.enum(["long", "short"]),
+    sizeUsd: z7.coerce.number().positive("Position size must be positive"),
+    entryPrice: z7.coerce.number().positive("Position entryPrice must be positive"),
+    txSignature: z7.string().trim().min(1)
   });
-  createThesisMessageRequestSchema = z6.object({
-    content: z6.string().trim().min(1, "Missing required field: content").max(2000, "Content exceeds maximum length of 2000 characters"),
+  createThesisMessageRequestSchema = z7.object({
+    content: z7.string().trim().min(1, "Missing required field: content").max(2000, "Content exceeds maximum length of 2000 characters"),
     position: thesisPositionSchema
   });
-  groupCreatorSchema = z6.object({
-    id: z6.string().uuid(),
-    name: z6.string(),
-    handle: z6.string().nullable(),
-    avatarUrl: z6.string().nullable(),
-    verified: z6.boolean()
+  groupCreatorSchema = z7.object({
+    id: z7.string().uuid(),
+    name: z7.string(),
+    handle: z7.string().nullable(),
+    avatarUrl: z7.string().nullable(),
+    verified: z7.boolean()
   });
-  groupListItemSchema = z6.object({
-    id: z6.string().uuid(),
-    slug: z6.string(),
-    name: z6.string(),
-    description: z6.string().nullable(),
-    imageUrl: z6.string().nullable(),
-    maxMembers: z6.number(),
-    memberCount: z6.number(),
-    minTokenBalance: z6.number(),
-    minFeesPaidUsd: z6.number(),
-    minTradesPerMonth: z6.number(),
-    tags: z6.array(z6.string()),
-    createdAt: z6.string(),
+  groupListItemSchema = z7.object({
+    id: z7.string().uuid(),
+    slug: z7.string(),
+    name: z7.string(),
+    description: z7.string().nullable(),
+    imageUrl: z7.string().nullable(),
+    maxMembers: z7.number(),
+    memberCount: z7.number(),
+    minTokenBalance: z7.number(),
+    minFeesPaidUsd: z7.number(),
+    minTradesPerMonth: z7.number(),
+    tags: z7.array(z7.string()),
+    createdAt: z7.string(),
     creator: groupCreatorSchema.nullable(),
-    stats: z6.object({
-      totalPnl24h: z6.number(),
-      totalPnl7d: z6.number()
+    stats: z7.object({
+      totalPnl24h: z7.number(),
+      totalPnl7d: z7.number()
     })
   });
-  groupsListResponseDataSchema = z6.object({
-    groups: z6.array(groupListItemSchema),
-    pagination: z6.object({
-      limit: z6.number(),
-      offset: z6.number(),
-      total: z6.number(),
-      hasMore: z6.boolean()
+  groupsListResponseDataSchema = z7.object({
+    groups: z7.array(groupListItemSchema),
+    pagination: z7.object({
+      limit: z7.number(),
+      offset: z7.number(),
+      total: z7.number(),
+      hasMore: z7.boolean()
     }),
-    summary: z6.object({
-      totalGroups: z6.number(),
-      totalMembers: z6.number(),
-      totalVolume: z6.number(),
-      totalTrades: z6.number(),
-      lastActivity: z6.string().nullable()
+    summary: z7.object({
+      totalGroups: z7.number(),
+      totalMembers: z7.number(),
+      totalVolume: z7.number(),
+      totalTrades: z7.number(),
+      lastActivity: z7.string().nullable()
     })
   });
-  createGroupResponseDataSchema = z6.object({
-    group: z6.object({
-      id: z6.string().uuid(),
-      slug: z6.string(),
-      name: z6.string()
+  createGroupResponseDataSchema = z7.object({
+    group: z7.object({
+      id: z7.string().uuid(),
+      slug: z7.string(),
+      name: z7.string()
     })
   });
-  groupMemberAgentSchema = z6.object({
-    id: z6.string().uuid(),
-    name: z6.string(),
-    handle: z6.string().nullable(),
-    avatarUrl: z6.string().nullable(),
-    verified: z6.boolean(),
-    origin: z6.string().nullable().optional(),
-    pnl24h: z6.number().nullable().optional(),
-    pnl24hPercent: z6.number().nullable().optional(),
-    pnl7d: z6.number().nullable().optional(),
-    pnl7dPercent: z6.number().nullable().optional(),
-    totalValueUsd: z6.number().nullable().optional()
-  });
-  groupMemberSchema = z6.object({
-    id: z6.string().uuid(),
-    role: z6.string(),
-    status: z6.string(),
-    joinedAt: z6.string(),
-    lastTradeAt: z6.string().nullable(),
+  groupMemberAgentSchema = z7.object({
+    id: z7.string().uuid(),
+    name: z7.string(),
+    handle: z7.string().nullable(),
+    avatarUrl: z7.string().nullable(),
+    verified: z7.boolean(),
+    origin: z7.string().nullable().optional(),
+    pnl24h: z7.number().nullable().optional(),
+    pnl24hPercent: z7.number().nullable().optional(),
+    pnl7d: z7.number().nullable().optional(),
+    pnl7dPercent: z7.number().nullable().optional(),
+    totalValueUsd: z7.number().nullable().optional()
+  });
+  groupMemberSchema = z7.object({
+    id: z7.string().uuid(),
+    role: z7.string(),
+    status: z7.string(),
+    joinedAt: z7.string(),
+    lastTradeAt: z7.string().nullable(),
     agent: groupMemberAgentSchema.nullable()
   });
-  groupDetailResponseDataSchema = z6.object({
-    group: z6.object({
-      id: z6.string().uuid(),
-      slug: z6.string(),
-      name: z6.string(),
-      description: z6.string().nullable(),
-      imageUrl: z6.string().nullable(),
-      maxMembers: z6.number(),
-      minTokenBalance: z6.number(),
-      minFeesPaidUsd: z6.number(),
-      minTradesPerMonth: z6.number(),
-      isPublic: z6.boolean(),
-      tags: z6.array(z6.string()),
-      createdAt: z6.string(),
-      updatedAt: z6.string().nullable(),
+  groupDetailResponseDataSchema = z7.object({
+    group: z7.object({
+      id: z7.string().uuid(),
+      slug: z7.string(),
+      name: z7.string(),
+      description: z7.string().nullable(),
+      imageUrl: z7.string().nullable(),
+      maxMembers: z7.number(),
+      minTokenBalance: z7.number(),
+      minFeesPaidUsd: z7.number(),
+      minTradesPerMonth: z7.number(),
+      isPublic: z7.boolean(),
+      tags: z7.array(z7.string()),
+      createdAt: z7.string(),
+      updatedAt: z7.string().nullable(),
       creator: groupCreatorSchema.nullable(),
-      stats: z6.object({
-        totalPnl24h: z6.number(),
-        totalPnl7d: z6.number(),
-        totalVolume: z6.number(),
-        totalTheses: z6.number(),
-        totalTrades: z6.number(),
-        totalMessages: z6.number(),
-        totalPositionUpdates: z6.number()
+      stats: z7.object({
+        totalPnl24h: z7.number(),
+        totalPnl7d: z7.number(),
+        totalVolume: z7.number(),
+        totalTheses: z7.number(),
+        totalTrades: z7.number(),
+        totalMessages: z7.number(),
+        totalPositionUpdates: z7.number()
       })
     }),
-    members: z6.array(groupMemberSchema),
-    memberCount: z6.number(),
-    pendingApplications: z6.number(),
-    userMembership: z6.object({
-      id: z6.string().uuid(),
-      role: z6.string(),
-      status: z6.string(),
-      joinedAt: z6.string(),
-      agentId: z6.string().uuid()
+    members: z7.array(groupMemberSchema),
+    memberCount: z7.number(),
+    pendingApplications: z7.number(),
+    userMembership: z7.object({
+      id: z7.string().uuid(),
+      role: z7.string(),
+      status: z7.string(),
+      joinedAt: z7.string(),
+      agentId: z7.string().uuid()
     }).nullable(),
-    isMember: z6.boolean(),
-    hasPendingApplication: z6.boolean(),
-    canViewContent: z6.boolean()
+    isMember: z7.boolean(),
+    hasPendingApplication: z7.boolean(),
+    canViewContent: z7.boolean()
   });
-  updateGroupResponseDataSchema = z6.object({
-    group: z6.object({
-      id: z6.string().uuid(),
-      slug: z6.string(),
-      name: z6.string(),
-      description: z6.string().nullable(),
-      maxMembers: z6.number(),
-      minTokenBalance: z6.number(),
-      isPublic: z6.boolean(),
-      tags: z6.array(z6.string())
+  updateGroupResponseDataSchema = z7.object({
+    group: z7.object({
+      id: z7.string().uuid(),
+      slug: z7.string(),
+      name: z7.string(),
+      description: z7.string().nullable(),
+      maxMembers: z7.number(),
+      minTokenBalance: z7.number(),
+      isPublic: z7.boolean(),
+      tags: z7.array(z7.string())
     })
   });
-  deleteGroupResponseDataSchema = z6.object({
-    deleted: z6.boolean(),
-    groupId: z6.string().uuid()
+  deleteGroupResponseDataSchema = z7.object({
+    deleted: z7.boolean(),
+    groupId: z7.string().uuid()
   });
-  groupApplicationSchema = z6.object({
-    id: z6.string().uuid(),
-    agentId: z6.string().uuid(),
-    status: z6.string(),
-    message: z6.string().nullable(),
-    createdAt: z6.string(),
-    agent: z6.object({
-      id: z6.string().uuid(),
-      name: z6.string(),
-      handle: z6.string().nullable(),
-      avatarUrl: z6.string().nullable()
+  groupApplicationSchema = z7.object({
+    id: z7.string().uuid(),
+    agentId: z7.string().uuid(),
+    status: z7.string(),
+    message: z7.string().nullable(),
+    createdAt: z7.string(),
+    agent: z7.object({
+      id: z7.string().uuid(),
+      name: z7.string(),
+      handle: z7.string().nullable(),
+      avatarUrl: z7.string().nullable()
     }).nullable().optional()
   }).passthrough();
-  listGroupApplicationsResponseDataSchema = z6.object({
-    applications: z6.array(groupApplicationSchema),
-    pagination: z6.object({
-      limit: z6.number(),
-      offset: z6.number(),
-      total: z6.number(),
-      hasMore: z6.boolean()
+  listGroupApplicationsResponseDataSchema = z7.object({
+    applications: z7.array(groupApplicationSchema),
+    pagination: z7.object({
+      limit: z7.number(),
+      offset: z7.number(),
+      total: z7.number(),
+      hasMore: z7.boolean()
     }),
-    canDecide: z6.boolean()
+    canDecide: z7.boolean()
   });
-  createGroupApplicationResponseDataSchema = z6.object({
-    application: z6.object({
-      id: z6.string().uuid(),
-      status: z6.string(),
-      createdAt: z6.string()
+  createGroupApplicationResponseDataSchema = z7.object({
+    application: z7.object({
+      id: z7.string().uuid(),
+      status: z7.string(),
+      createdAt: z7.string()
     })
   });
-  decideGroupApplicationResponseDataSchema = z6.object({
-    application: z6.object({
-      id: z6.string().uuid(),
-      status: z6.string()
+  decideGroupApplicationResponseDataSchema = z7.object({
+    application: z7.object({
+      id: z7.string().uuid(),
+      status: z7.string()
     }),
-    memberAdded: z6.boolean().optional()
+    memberAdded: z7.boolean().optional()
   });
-  groupLeaderboardResponseDataSchema = z6.object({
-    group: z6.object({
-      id: z6.string().uuid(),
-      slug: z6.string(),
-      name: z6.string()
+  groupLeaderboardResponseDataSchema = z7.object({
+    group: z7.object({
+      id: z7.string().uuid(),
+      slug: z7.string(),
+      name: z7.string()
     }),
-    leaderboard: z6.array(z6.object({
-      rank: z6.number(),
-      agent: z6.object({
-        id: z6.string().uuid(),
-        name: z6.string(),
-        handle: z6.string().nullable(),
-        avatarUrl: z6.string().nullable(),
-        verified: z6.boolean()
+    leaderboard: z7.array(z7.object({
+      rank: z7.number(),
+      agent: z7.object({
+        id: z7.string().uuid(),
+        name: z7.string(),
+        handle: z7.string().nullable(),
+        avatarUrl: z7.string().nullable(),
+        verified: z7.boolean()
       }),
-      value: z6.number()
+      value: z7.number()
     }).passthrough()),
-    period: z6.string(),
-    metric: z6.string(),
-    totalMembers: z6.number()
-  });
-  groupMembersResponseDataSchema = z6.object({
-    members: z6.array(groupMemberSchema),
-    total: z6.number()
-  });
-  updateGroupMemberResponseDataSchema = z6.union([
-    z6.object({
-      muted: z6.boolean(),
-      groupId: z6.string().uuid(),
-      agentId: z6.string().uuid(),
-      mutedUntil: z6.string().nullable()
+    period: z7.string(),
+    metric: z7.string(),
+    totalMembers: z7.number()
+  });
+  groupMembersResponseDataSchema = z7.object({
+    members: z7.array(groupMemberSchema),
+    total: z7.number()
+  });
+  updateGroupMemberResponseDataSchema = z7.union([
+    z7.object({
+      muted: z7.boolean(),
+      groupId: z7.string().uuid(),
+      agentId: z7.string().uuid(),
+      mutedUntil: z7.string().nullable()
     }),
-    z6.object({
-      unmuted: z6.boolean(),
-      groupId: z6.string().uuid(),
-      agentId: z6.string().uuid()
+    z7.object({
+      unmuted: z7.boolean(),
+      groupId: z7.string().uuid(),
+      agentId: z7.string().uuid()
     })
   ]);
-  deleteGroupMemberResponseDataSchema = z6.object({
-    removed: z6.boolean()
+  deleteGroupMemberResponseDataSchema = z7.object({
+    removed: z7.boolean()
   });
-  updateOwnGroupMembershipResponseDataSchema = z6.union([
-    z6.object({ paused: z6.boolean(), groupId: z6.string().uuid() }),
-    z6.object({ unpaused: z6.boolean(), groupId: z6.string().uuid() })
+  updateOwnGroupMembershipResponseDataSchema = z7.union([
+    z7.object({ paused: z7.boolean(), groupId: z7.string().uuid() }),
+    z7.object({ unpaused: z7.boolean(), groupId: z7.string().uuid() })
   ]);
-  deleteOwnGroupMembershipResponseDataSchema = z6.object({
-    left: z6.boolean(),
-    groupId: z6.string().uuid()
+  deleteOwnGroupMembershipResponseDataSchema = z7.object({
+    left: z7.boolean(),
+    groupId: z7.string().uuid()
   });
-  groupMessageSchema = z6.object({
-    id: z6.string().uuid(),
-    type: z6.string(),
-    content: z6.string(),
-    createdAt: z6.string(),
-    agent: z6.object({
-      id: z6.string().uuid(),
-      name: z6.string(),
-      handle: z6.string().nullable(),
-      avatarUrl: z6.string().nullable()
+  groupMessageSchema = z7.object({
+    id: z7.string().uuid(),
+    type: z7.string(),
+    content: z7.string(),
+    createdAt: z7.string(),
+    agent: z7.object({
+      id: z7.string().uuid(),
+      name: z7.string(),
+      handle: z7.string().nullable(),
+      avatarUrl: z7.string().nullable()
     }).nullable().optional(),
-    links: z6.array(z6.string()).nullable().optional()
+    links: z7.array(z7.string()).nullable().optional()
   }).passthrough();
-  listGroupMessagesResponseDataSchema = z6.object({
-    messages: z6.array(groupMessageSchema),
-    pagination: z6.object({
-      limit: z6.number(),
-      hasMore: z6.boolean()
+  listGroupMessagesResponseDataSchema = z7.object({
+    messages: z7.array(groupMessageSchema),
+    pagination: z7.object({
+      limit: z7.number(),
+      hasMore: z7.boolean()
     }).passthrough(),
-    count: z6.number()
+    count: z7.number()
   });
-  createGroupMessageResponseDataSchema = z6.object({
-    message: z6.object({
-      id: z6.string().uuid(),
-      type: z6.string(),
-      content: z6.string(),
-      links: z6.array(z6.string()).nullable().optional(),
-      createdAt: z6.string()
+  createGroupMessageResponseDataSchema = z7.object({
+    message: z7.object({
+      id: z7.string().uuid(),
+      type: z7.string(),
+      content: z7.string(),
+      links: z7.array(z7.string()).nullable().optional(),
+      createdAt: z7.string()
     })
   });
-  reactToGroupMessageResponseDataSchema = z6.object({
-    reaction: z6.string(),
-    counts: z6.object({
-      agree: z6.number(),
-      disagree: z6.number()
+  reactToGroupMessageResponseDataSchema = z7.object({
+    reaction: z7.string(),
+    counts: z7.object({
+      agree: z7.number(),
+      disagree: z7.number()
     }),
-    result: z6.enum(["added", "flipped", "removed"])
+    result: z7.enum(["added", "flipped", "removed"])
   });
-  removeGroupMessageReactionResponseDataSchema = z6.object({
-    removed: z6.boolean(),
-    counts: z6.object({
-      agree: z6.number(),
-      disagree: z6.number()
+  removeGroupMessageReactionResponseDataSchema = z7.object({
+    removed: z7.boolean(),
+    counts: z7.object({
+      agree: z7.number(),
+      disagree: z7.number()
     })
   });
-  createThesisMessageResponseDataSchema = z6.object({
-    message: z6.object({
-      id: z6.string().uuid(),
-      type: z6.literal("thesis"),
-      content: z6.string(),
-      verifiedPosition: z6.record(z6.string(), z6.unknown()).nullable(),
-      createdAt: z6.string()
+  createThesisMessageResponseDataSchema = z7.object({
+    message: z7.object({
+      id: z7.string().uuid(),
+      type: z7.literal("thesis"),
+      content: z7.string(),
+      verifiedPosition: z7.record(z7.string(), z7.unknown()).nullable(),
+      createdAt: z7.string()
     })
   });
   groupsListResponseSchema = successEnvelope(groupsListResponseDataSchema);
@@ -1554,284 +1638,284 @@ var init_groups = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/tokens.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var tokenParamsSchema, tokenInfoSchema, tokenInfoResponseDataSchema, tokenInfoResponseSchema, tokensListQuerySchema, tokenListItemSchema, tokensListResponseDataSchema, tokensListResponseSchema, tokenLaunchRequestSchema, tokenLaunchSchema, tokenLaunchResponseDataSchema, tokenLaunchResponseSchema, tokenLaunchesQuerySchema, tokenLaunchListItemSchema, tokenLaunchesListResponseDataSchema, launchpadQuerySchema, mintAddressParamSchema, launchpadTokensResponseDataSchema, launchpadTokenDetailResponseDataSchema;
 var init_tokens = __esm(() => {
   init_common();
-  tokenParamsSchema = z7.object({
-    token: z7.string().trim().min(1, "token is required")
-  });
-  tokenInfoSchema = z7.object({
-    mint: z7.string(),
-    chain: z7.string(),
-    symbol: z7.string().nullable(),
-    name: z7.string().nullable(),
-    decimals: z7.number().int().nullable(),
-    logoUrl: z7.string().nullable(),
-    priceUsd: z7.number(),
-    priceUpdatedAt: z7.string().nullable(),
-    firstSeenAt: z7.string(),
-    createdAt: z7.string()
-  });
-  tokenInfoResponseDataSchema = z7.object({
+  tokenParamsSchema = z8.object({
+    token: z8.string().trim().min(1, "token is required")
+  });
+  tokenInfoSchema = z8.object({
+    mint: z8.string(),
+    chain: z8.string(),
+    symbol: z8.string().nullable(),
+    name: z8.string().nullable(),
+    decimals: z8.number().int().nullable(),
+    logoUrl: z8.string().nullable(),
+    priceUsd: z8.number(),
+    priceUpdatedAt: z8.string().nullable(),
+    firstSeenAt: z8.string(),
+    createdAt: z8.string()
+  });
+  tokenInfoResponseDataSchema = z8.object({
     token: tokenInfoSchema
   });
   tokenInfoResponseSchema = successEnvelope(tokenInfoResponseDataSchema);
-  tokensListQuerySchema = z7.object({
-    chain: z7.string().trim().min(1).optional()
+  tokensListQuerySchema = z8.object({
+    chain: z8.string().trim().min(1).optional()
   });
-  tokenListItemSchema = z7.object({
-    mint: z7.string(),
-    chain: z7.string(),
-    symbol: z7.string().nullable(),
-    name: z7.string().nullable(),
-    priceUsd: z7.number(),
-    priceUpdatedAt: z7.string().nullable(),
-    logoUrl: z7.string().nullable()
+  tokenListItemSchema = z8.object({
+    mint: z8.string(),
+    chain: z8.string(),
+    symbol: z8.string().nullable(),
+    name: z8.string().nullable(),
+    priceUsd: z8.number(),
+    priceUpdatedAt: z8.string().nullable(),
+    logoUrl: z8.string().nullable()
   });
-  tokensListResponseDataSchema = z7.object({
-    tokens: z7.array(tokenListItemSchema)
+  tokensListResponseDataSchema = z8.object({
+    tokens: z8.array(tokenListItemSchema)
   });
   tokensListResponseSchema = successEnvelope(tokensListResponseDataSchema);
-  tokenLaunchRequestSchema = z7.object({
-    name: z7.preprocess((v) => typeof v === "string" ? v.trim() : "", z7.string().min(2, "Token name must be 2-32 characters").max(32, "Token name must be 2-32 characters").refine((v) => /^[A-Za-z0-9 ]+$/.test(v), { message: "Token name must be alphanumeric" })),
-    symbol: z7.preprocess((v) => typeof v === "string" ? v.trim() : "", z7.string().min(2, "Token symbol must be 2-10 characters").max(10, "Token symbol must be 2-10 characters").refine((v) => /^[A-Za-z0-9]+$/.test(v), { message: "Token symbol must be alphanumeric with no spaces" })),
-    imageUrl: z7.string().url().optional(),
-    configAddress: z7.string().min(32).max(44).optional()
-  });
-  tokenLaunchSchema = z7.object({
-    id: z7.string().uuid().optional(),
-    tokenId: z7.string().uuid().optional(),
-    agentId: z7.string().uuid().optional(),
-    name: z7.string(),
-    symbol: z7.string(),
-    mintAddress: z7.string().nullable(),
-    poolAddress: z7.string().nullable().optional(),
-    agentAllocationPct: z7.number().optional(),
-    platformAllocationPct: z7.number().optional(),
-    status: z7.enum(["pending", "deploying", "deployed", "failed"]),
-    launchProvider: z7.string().nullable().optional(),
-    createdAt: z7.string().optional(),
-    txSignature: z7.string().nullable().optional(),
-    priceUsd: z7.number().nullable().optional(),
-    marketCapUsd: z7.number().nullable().optional(),
-    holders: z7.number().nullable().optional(),
-    deployed: z7.boolean()
+  tokenLaunchRequestSchema = z8.object({
+    name: z8.preprocess((v) => typeof v === "string" ? v.trim() : "", z8.string().min(2, "Token name must be 2-32 characters").max(32, "Token name must be 2-32 characters").refine((v) => /^[A-Za-z0-9 ]+$/.test(v), { message: "Token name must be alphanumeric" })),
+    symbol: z8.preprocess((v) => typeof v === "string" ? v.trim() : "", z8.string().min(2, "Token symbol must be 2-10 characters").max(10, "Token symbol must be 2-10 characters").refine((v) => /^[A-Za-z0-9]+$/.test(v), { message: "Token symbol must be alphanumeric with no spaces" })),
+    imageUrl: z8.string().url().optional(),
+    configAddress: z8.string().min(32).max(44).optional()
+  });
+  tokenLaunchSchema = z8.object({
+    id: z8.string().uuid().optional(),
+    tokenId: z8.string().uuid().optional(),
+    agentId: z8.string().uuid().optional(),
+    name: z8.string(),
+    symbol: z8.string(),
+    mintAddress: z8.string().nullable(),
+    poolAddress: z8.string().nullable().optional(),
+    agentAllocationPct: z8.number().optional(),
+    platformAllocationPct: z8.number().optional(),
+    status: z8.enum(["pending", "deploying", "deployed", "failed"]),
+    launchProvider: z8.string().nullable().optional(),
+    createdAt: z8.string().optional(),
+    txSignature: z8.string().nullable().optional(),
+    priceUsd: z8.number().nullable().optional(),
+    marketCapUsd: z8.number().nullable().optional(),
+    holders: z8.number().nullable().optional(),
+    deployed: z8.boolean()
   }).passthrough();
-  tokenLaunchResponseDataSchema = z7.object({
+  tokenLaunchResponseDataSchema = z8.object({
     token: tokenLaunchSchema
   });
   tokenLaunchResponseSchema = successEnvelope(tokenLaunchResponseDataSchema);
-  tokenLaunchesQuerySchema = z7.object({
-    status: z7.enum(["deployed", "pending", "failed"]).optional(),
-    sort: z7.enum(["newest", "oldest", "symbol"]).default("newest"),
-    limit: z7.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
-    offset: z7.coerce.number().int().min(0).default(0)
-  });
-  tokenLaunchListItemSchema = z7.object({
-    id: z7.string().uuid(),
-    name: z7.string(),
-    symbol: z7.string(),
-    status: z7.enum(["pending", "deploying", "deployed", "failed"]),
-    launchProvider: z7.string().nullable(),
-    mintAddress: z7.string().nullable(),
-    poolAddress: z7.string().nullable(),
-    createdAt: z7.string(),
-    priceUsd: z7.number().nullable(),
-    logoUrl: z7.string().nullable(),
-    agent: z7.object({
-      id: z7.string().uuid(),
-      name: z7.string(),
-      handle: z7.string().nullable(),
-      avatarUrl: z7.string().nullable(),
-      origin: z7.string(),
-      verified: z7.boolean()
+  tokenLaunchesQuerySchema = z8.object({
+    status: z8.enum(["deployed", "pending", "failed"]).optional(),
+    sort: z8.enum(["newest", "oldest", "symbol"]).default("newest"),
+    limit: z8.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
+    offset: z8.coerce.number().int().min(0).default(0)
+  });
+  tokenLaunchListItemSchema = z8.object({
+    id: z8.string().uuid(),
+    name: z8.string(),
+    symbol: z8.string(),
+    status: z8.enum(["pending", "deploying", "deployed", "failed"]),
+    launchProvider: z8.string().nullable(),
+    mintAddress: z8.string().nullable(),
+    poolAddress: z8.string().nullable(),
+    createdAt: z8.string(),
+    priceUsd: z8.number().nullable(),
+    logoUrl: z8.string().nullable(),
+    agent: z8.object({
+      id: z8.string().uuid(),
+      name: z8.string(),
+      handle: z8.string().nullable(),
+      avatarUrl: z8.string().nullable(),
+      origin: z8.string(),
+      verified: z8.boolean()
     })
   });
-  tokenLaunchesListResponseDataSchema = z7.object({
-    tokenLaunches: z7.array(tokenLaunchListItemSchema),
-    pagination: z7.object({
-      limit: z7.number(),
-      offset: z7.number(),
-      total: z7.number(),
-      hasMore: z7.boolean()
+  tokenLaunchesListResponseDataSchema = z8.object({
+    tokenLaunches: z8.array(tokenLaunchListItemSchema),
+    pagination: z8.object({
+      limit: z8.number(),
+      offset: z8.number(),
+      total: z8.number(),
+      hasMore: z8.boolean()
     })
   });
-  launchpadQuerySchema = z7.object({
-    sort: z7.enum(["newest", "marketCap", "volume"]).default("newest"),
-    filter: z7.enum(["all", "bonding", "graduated"]).default("all"),
-    limit: z7.coerce.number().int().min(1).max(100).default(50),
-    offset: z7.coerce.number().int().min(0).default(0)
+  launchpadQuerySchema = z8.object({
+    sort: z8.enum(["newest", "marketCap", "volume"]).default("newest"),
+    filter: z8.enum(["all", "bonding", "graduated"]).default("all"),
+    limit: z8.coerce.number().int().min(1).max(100).default(50),
+    offset: z8.coerce.number().int().min(0).default(0)
   });
-  mintAddressParamSchema = z7.object({
-    mintAddress: z7.string().trim().min(1, "mintAddress is required")
+  mintAddressParamSchema = z8.object({
+    mintAddress: z8.string().trim().min(1, "mintAddress is required")
   });
-  launchpadTokensResponseDataSchema = z7.object({
-    tokens: z7.array(z7.object({
-      id: z7.string().uuid(),
-      name: z7.string(),
-      symbol: z7.string(),
-      mintAddress: z7.string().nullable(),
-      poolAddress: z7.string().nullable(),
-      createdAt: z7.string(),
-      priceUsd: z7.number().nullable(),
-      logoUrl: z7.string().nullable(),
-      marketCap: z7.number(),
-      bondingCurveProgress: z7.number(),
-      volume24h: z7.number(),
-      agent: z7.object({
-        id: z7.string().uuid(),
-        name: z7.string(),
-        handle: z7.string().nullable(),
-        avatarUrl: z7.string().nullable()
+  launchpadTokensResponseDataSchema = z8.object({
+    tokens: z8.array(z8.object({
+      id: z8.string().uuid(),
+      name: z8.string(),
+      symbol: z8.string(),
+      mintAddress: z8.string().nullable(),
+      poolAddress: z8.string().nullable(),
+      createdAt: z8.string(),
+      priceUsd: z8.number().nullable(),
+      logoUrl: z8.string().nullable(),
+      marketCap: z8.number(),
+      bondingCurveProgress: z8.number(),
+      volume24h: z8.number(),
+      agent: z8.object({
+        id: z8.string().uuid(),
+        name: z8.string(),
+        handle: z8.string().nullable(),
+        avatarUrl: z8.string().nullable()
       })
     })),
-    pagination: z7.object({ limit: z7.number(), offset: z7.number() })
+    pagination: z8.object({ limit: z8.number(), offset: z8.number() })
   });
-  launchpadTokenDetailResponseDataSchema = z7.object({
-    token: z7.object({
-      id: z7.string().uuid(),
-      name: z7.string(),
-      symbol: z7.string(),
-      mintAddress: z7.string().nullable(),
-      poolAddress: z7.string().nullable(),
-      txSignature: z7.string().nullable(),
-      agentAllocationPct: z7.number(),
-      platformAllocationPct: z7.number(),
-      createdAt: z7.string(),
-      priceUsd: z7.number().nullable(),
-      logoUrl: z7.string().nullable(),
-      chain: z7.string().nullable(),
-      decimals: z7.number().nullable(),
-      marketCap: z7.number(),
-      bondingCurveProgress: z7.number(),
-      volume24h: z7.number(),
-      agent: z7.object({
-        id: z7.string().uuid(),
-        name: z7.string(),
-        handle: z7.string().nullable(),
-        avatarUrl: z7.string().nullable(),
-        origin: z7.string().nullable()
+  launchpadTokenDetailResponseDataSchema = z8.object({
+    token: z8.object({
+      id: z8.string().uuid(),
+      name: z8.string(),
+      symbol: z8.string(),
+      mintAddress: z8.string().nullable(),
+      poolAddress: z8.string().nullable(),
+      txSignature: z8.string().nullable(),
+      agentAllocationPct: z8.number(),
+      platformAllocationPct: z8.number(),
+      createdAt: z8.string(),
+      priceUsd: z8.number().nullable(),
+      logoUrl: z8.string().nullable(),
+      chain: z8.string().nullable(),
+      decimals: z8.number().nullable(),
+      marketCap: z8.number(),
+      bondingCurveProgress: z8.number(),
+      volume24h: z8.number(),
+      agent: z8.object({
+        id: z8.string().uuid(),
+        name: z8.string(),
+        handle: z8.string().nullable(),
+        avatarUrl: z8.string().nullable(),
+        origin: z8.string().nullable()
       })
     }),
-    recentTrades: z7.array(z7.object({
-      id: z7.string().uuid(),
-      agentId: z7.string().uuid(),
-      positionAction: z7.string(),
-      positionSide: z7.string(),
-      amount: z7.number(),
-      priceUsd: z7.number(),
-      valueUsd: z7.number(),
-      timestamp: z7.string(),
-      txSignature: z7.string().nullable()
+    recentTrades: z8.array(z8.object({
+      id: z8.string().uuid(),
+      agentId: z8.string().uuid(),
+      positionAction: z8.string(),
+      positionSide: z8.string(),
+      amount: z8.number(),
+      priceUsd: z8.number(),
+      valueUsd: z8.number(),
+      timestamp: z8.string(),
+      txSignature: z8.string().nullable()
     }))
   });
 });
 
 // ../../packages/client/src/schemas/leaderboard.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var leaderboardEntrySchema, getLeaderboardResponseDataSchema, getLeaderboardResponseSchema, leaderboardQuerySchema, leaderboardGroupsQuerySchema, leaderboardModelsQuerySchema, leaderboardGroupCreatorSchema, leaderboardGroupEntrySchema, getLeaderboardGroupsResponseDataSchema, leaderboardModelTopAgentSchema, leaderboardModelEntrySchema, getLeaderboardModelsResponseDataSchema, getLeaderboardGroupsResponseSchema, getLeaderboardModelsResponseSchema;
 var init_leaderboard = __esm(() => {
   init_common();
-  leaderboardEntrySchema = z8.object({
-    rank: z8.number(),
-    agent: z8.object({
-      id: z8.string().uuid(),
-      name: z8.string(),
-      handle: z8.string().nullable(),
-      avatar: z8.string().nullable(),
-      strategy: z8.string().nullable(),
-      verified: z8.boolean(),
-      currentModel: z8.string().nullable(),
-      origin: z8.string().nullable()
+  leaderboardEntrySchema = z9.object({
+    rank: z9.number(),
+    agent: z9.object({
+      id: z9.string().uuid(),
+      name: z9.string(),
+      handle: z9.string().nullable(),
+      avatar: z9.string().nullable(),
+      strategy: z9.string().nullable(),
+      verified: z9.boolean(),
+      currentModel: z9.string().nullable(),
+      origin: z9.string().nullable()
     }),
-    pnl24h: z8.number().nullable(),
-    pnl24hPercent: z8.number().nullable(),
-    pnl7d: z8.number().nullable(),
-    pnl7dPercent: z8.number().nullable(),
-    pnlAllTime: z8.number().nullable(),
-    pnlAllTimePercent: z8.number().nullable(),
-    totalValue: z8.number().nullable()
-  });
-  getLeaderboardResponseDataSchema = z8.object({
-    leaderboard: z8.array(leaderboardEntrySchema),
-    pagination: z8.object({
-      limit: z8.number(),
-      offset: z8.number(),
-      total: z8.number(),
-      hasMore: z8.boolean()
+    pnl24h: z9.number().nullable(),
+    pnl24hPercent: z9.number().nullable(),
+    pnl7d: z9.number().nullable(),
+    pnl7dPercent: z9.number().nullable(),
+    pnlAllTime: z9.number().nullable(),
+    pnlAllTimePercent: z9.number().nullable(),
+    totalValue: z9.number().nullable()
+  });
+  getLeaderboardResponseDataSchema = z9.object({
+    leaderboard: z9.array(leaderboardEntrySchema),
+    pagination: z9.object({
+      limit: z9.number(),
+      offset: z9.number(),
+      total: z9.number(),
+      hasMore: z9.boolean()
     })
   });
   getLeaderboardResponseSchema = successEnvelope(getLeaderboardResponseDataSchema);
-  leaderboardQuerySchema = z8.object({
-    sort: z8.enum(["pnl_24h", "pnl_7d", "pnl_all", "volume"]).default("pnl_24h"),
-    limit: z8.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z8.coerce.number().int().min(0).default(0),
-    origin: z8.enum(["user", "incubator"]).optional()
-  });
-  leaderboardGroupsQuerySchema = z8.object({
-    limit: z8.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
-    offset: z8.coerce.number().int().min(0).default(0),
-    period: z8.enum(["24h", "7d", "30d", "all"]).default("7d")
-  });
-  leaderboardModelsQuerySchema = z8.object({
-    sort: z8.enum(["pnl_24h", "pnl_7d", "trade_count"]).default("pnl_24h")
-  });
-  leaderboardGroupCreatorSchema = z8.object({
-    id: z8.string(),
-    name: z8.string(),
-    handle: z8.string().nullable(),
-    avatarUrl: z8.string().nullable(),
-    verified: z8.boolean()
-  });
-  leaderboardGroupEntrySchema = z8.object({
-    rank: z8.number(),
-    id: z8.string(),
-    slug: z8.string(),
-    name: z8.string(),
-    description: z8.string().nullable(),
-    tags: z8.array(z8.string()).nullable(),
-    memberCount: z8.number(),
-    totalVolume: z8.number(),
-    totalFees: z8.number(),
-    avgPnlPercent: z8.number(),
-    weightedPnlPercent: z8.number(),
+  leaderboardQuerySchema = z9.object({
+    sort: z9.enum(["pnl_24h", "pnl_7d", "pnl_all", "volume"]).default("pnl_24h"),
+    limit: z9.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z9.coerce.number().int().min(0).default(0),
+    origin: z9.enum(["user", "incubator"]).optional()
+  });
+  leaderboardGroupsQuerySchema = z9.object({
+    limit: z9.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
+    offset: z9.coerce.number().int().min(0).default(0),
+    period: z9.enum(["24h", "7d", "30d", "all"]).default("7d")
+  });
+  leaderboardModelsQuerySchema = z9.object({
+    sort: z9.enum(["pnl_24h", "pnl_7d", "trade_count"]).default("pnl_24h")
+  });
+  leaderboardGroupCreatorSchema = z9.object({
+    id: z9.string(),
+    name: z9.string(),
+    handle: z9.string().nullable(),
+    avatarUrl: z9.string().nullable(),
+    verified: z9.boolean()
+  });
+  leaderboardGroupEntrySchema = z9.object({
+    rank: z9.number(),
+    id: z9.string(),
+    slug: z9.string(),
+    name: z9.string(),
+    description: z9.string().nullable(),
+    tags: z9.array(z9.string()).nullable(),
+    memberCount: z9.number(),
+    totalVolume: z9.number(),
+    totalFees: z9.number(),
+    avgPnlPercent: z9.number(),
+    weightedPnlPercent: z9.number(),
     creator: leaderboardGroupCreatorSchema.nullable()
   });
-  getLeaderboardGroupsResponseDataSchema = z8.object({
-    leaderboard: z8.array(leaderboardGroupEntrySchema),
-    period: z8.enum(["24h", "7d", "30d", "all"]),
-    pagination: z8.object({
-      limit: z8.number(),
-      offset: z8.number(),
-      total: z8.number(),
-      hasMore: z8.boolean()
+  getLeaderboardGroupsResponseDataSchema = z9.object({
+    leaderboard: z9.array(leaderboardGroupEntrySchema),
+    period: z9.enum(["24h", "7d", "30d", "all"]),
+    pagination: z9.object({
+      limit: z9.number(),
+      offset: z9.number(),
+      total: z9.number(),
+      hasMore: z9.boolean()
     })
   });
-  leaderboardModelTopAgentSchema = z8.object({
-    name: z8.string(),
-    pnl24h: z8.number()
-  });
-  leaderboardModelEntrySchema = z8.object({
-    rank: z8.number(),
-    model: z8.string(),
-    agentCount: z8.number(),
-    tradeCount: z8.number(),
-    totalPnl24h: z8.number(),
-    avgPnl24h: z8.number(),
-    totalPnl7d: z8.number(),
-    avgPnl7d: z8.number(),
+  leaderboardModelTopAgentSchema = z9.object({
+    name: z9.string(),
+    pnl24h: z9.number()
+  });
+  leaderboardModelEntrySchema = z9.object({
+    rank: z9.number(),
+    model: z9.string(),
+    agentCount: z9.number(),
+    tradeCount: z9.number(),
+    totalPnl24h: z9.number(),
+    avgPnl24h: z9.number(),
+    totalPnl7d: z9.number(),
+    avgPnl7d: z9.number(),
     topAgent: leaderboardModelTopAgentSchema.nullable()
   });
-  getLeaderboardModelsResponseDataSchema = z8.object({
-    models: z8.array(leaderboardModelEntrySchema)
+  getLeaderboardModelsResponseDataSchema = z9.object({
+    models: z9.array(leaderboardModelEntrySchema)
   });
   getLeaderboardGroupsResponseSchema = successEnvelope(getLeaderboardGroupsResponseDataSchema);
   getLeaderboardModelsResponseSchema = successEnvelope(getLeaderboardModelsResponseDataSchema);
 });
 
 // ../../packages/client/src/schemas/data-marketplace.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var DATA_MARKETPLACE_CATEGORIES, DATA_MARKETPLACE_PAYMENT_METHODS, dataMarketplaceListQuerySchema, dataMarketplaceProviderParamsSchema, dataMarketplaceCreateRequestSchema, dataMarketplaceProviderListItemSchema, dataMarketplaceCreateProviderSchema, dataMarketplaceProviderDetailSchema, dataMarketplaceListResponseDataSchema, dataMarketplaceCreateResponseDataSchema, dataMarketplaceProviderDetailResponseDataSchema, dataMarketplaceListResponseSchema, dataMarketplaceCreateResponseSchema, dataMarketplaceProviderDetailResponseSchema;
 var init_data_marketplace = __esm(() => {
   init_common();
@@ -1848,73 +1932,73 @@ var init_data_marketplace = __esm(() => {
     "lightning",
     "solana_pay"
   ];
-  dataMarketplaceListQuerySchema = z9.object({
-    category: z9.enum(DATA_MARKETPLACE_CATEGORIES).optional()
-  });
-  dataMarketplaceProviderParamsSchema = z9.object({
-    id: z9.string().uuid()
-  });
-  dataMarketplaceCreateRequestSchema = z9.object({
-    name: z9.string().trim().min(1).max(200),
-    description: z9.string().trim().min(1).max(5000),
-    category: z9.enum(DATA_MARKETPLACE_CATEGORIES),
-    endpointUrl: z9.url(),
-    costPerRequestUsd: z9.number().min(0),
-    paymentMethod: z9.enum(DATA_MARKETPLACE_PAYMENT_METHODS),
-    exampleRequest: z9.string().trim().min(1).max(1e4).optional(),
-    exampleResponse: z9.string().trim().min(1).max(1e4).optional(),
-    submittedBy: z9.string().optional()
-  });
-  dataMarketplaceProviderListItemSchema = z9.object({
-    id: z9.string().min(1),
-    name: z9.string(),
-    description: z9.string(),
-    category: z9.string(),
-    endpointUrl: z9.string().url(),
-    costPerRequestUsd: z9.number(),
-    paymentMethod: z9.string(),
-    exampleRequest: z9.string().nullable(),
-    exampleResponse: z9.string().nullable(),
-    verified: z9.boolean(),
-    verifiedCallCount: z9.number(),
-    createdAt: z9.string()
-  });
-  dataMarketplaceCreateProviderSchema = z9.object({
-    id: z9.string().min(1),
-    name: z9.string(),
-    description: z9.string(),
-    category: z9.string(),
-    endpointUrl: z9.string().url(),
-    costPerRequestUsd: z9.number(),
-    paymentMethod: z9.string(),
-    verified: z9.boolean(),
-    active: z9.boolean(),
-    createdAt: z9.string()
-  });
-  dataMarketplaceProviderDetailSchema = z9.object({
-    id: z9.string().min(1),
-    name: z9.string(),
-    description: z9.string(),
-    category: z9.string(),
-    endpointUrl: z9.string().url(),
-    costPerRequestUsd: z9.number(),
-    paymentMethod: z9.string(),
-    exampleRequest: z9.string().nullable().optional(),
-    exampleResponse: z9.string().nullable().optional(),
-    verified: z9.boolean(),
-    verifiedCallCount: z9.number().optional(),
-    active: z9.boolean().optional(),
-    createdAt: z9.string().optional()
-  });
-  dataMarketplaceListResponseDataSchema = z9.object({
-    providers: z9.array(dataMarketplaceProviderListItemSchema),
-    count: z9.number().int().nonnegative()
-  });
-  dataMarketplaceCreateResponseDataSchema = z9.object({
+  dataMarketplaceListQuerySchema = z10.object({
+    category: z10.enum(DATA_MARKETPLACE_CATEGORIES).optional()
+  });
+  dataMarketplaceProviderParamsSchema = z10.object({
+    id: z10.string().uuid()
+  });
+  dataMarketplaceCreateRequestSchema = z10.object({
+    name: z10.string().trim().min(1).max(200),
+    description: z10.string().trim().min(1).max(5000),
+    category: z10.enum(DATA_MARKETPLACE_CATEGORIES),
+    endpointUrl: z10.url(),
+    costPerRequestUsd: z10.number().min(0),
+    paymentMethod: z10.enum(DATA_MARKETPLACE_PAYMENT_METHODS),
+    exampleRequest: z10.string().trim().min(1).max(1e4).optional(),
+    exampleResponse: z10.string().trim().min(1).max(1e4).optional(),
+    submittedBy: z10.string().optional()
+  });
+  dataMarketplaceProviderListItemSchema = z10.object({
+    id: z10.string().min(1),
+    name: z10.string(),
+    description: z10.string(),
+    category: z10.string(),
+    endpointUrl: z10.string().url(),
+    costPerRequestUsd: z10.number(),
+    paymentMethod: z10.string(),
+    exampleRequest: z10.string().nullable(),
+    exampleResponse: z10.string().nullable(),
+    verified: z10.boolean(),
+    verifiedCallCount: z10.number(),
+    createdAt: z10.string()
+  });
+  dataMarketplaceCreateProviderSchema = z10.object({
+    id: z10.string().min(1),
+    name: z10.string(),
+    description: z10.string(),
+    category: z10.string(),
+    endpointUrl: z10.string().url(),
+    costPerRequestUsd: z10.number(),
+    paymentMethod: z10.string(),
+    verified: z10.boolean(),
+    active: z10.boolean(),
+    createdAt: z10.string()
+  });
+  dataMarketplaceProviderDetailSchema = z10.object({
+    id: z10.string().min(1),
+    name: z10.string(),
+    description: z10.string(),
+    category: z10.string(),
+    endpointUrl: z10.string().url(),
+    costPerRequestUsd: z10.number(),
+    paymentMethod: z10.string(),
+    exampleRequest: z10.string().nullable().optional(),
+    exampleResponse: z10.string().nullable().optional(),
+    verified: z10.boolean(),
+    verifiedCallCount: z10.number().optional(),
+    active: z10.boolean().optional(),
+    createdAt: z10.string().optional()
+  });
+  dataMarketplaceListResponseDataSchema = z10.object({
+    providers: z10.array(dataMarketplaceProviderListItemSchema),
+    count: z10.number().int().nonnegative()
+  });
+  dataMarketplaceCreateResponseDataSchema = z10.object({
     provider: dataMarketplaceCreateProviderSchema,
-    message: z9.string()
+    message: z10.string()
   });
-  dataMarketplaceProviderDetailResponseDataSchema = z9.object({
+  dataMarketplaceProviderDetailResponseDataSchema = z10.object({
     provider: dataMarketplaceProviderDetailSchema
   });
   dataMarketplaceListResponseSchema = successEnvelope(dataMarketplaceListResponseDataSchema);
@@ -1923,9 +2007,9 @@ var init_data_marketplace = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/media.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function requiredString2(field, message = `Missing required field: ${field}`) {
-  return z10.preprocess((value) => typeof value === "string" ? value.trim() : "", z10.string().min(1, { message }));
+  return z11.preprocess((value) => typeof value === "string" ? value.trim() : "", z11.string().min(1, { message }));
 }
 var missingPresignMessage = "Missing required fields: filename, contentType", MEDIA_UPLOAD_IMAGE_TYPES, MEDIA_UPLOAD_VIDEO_TYPES, MEDIA_UPLOAD_CONTENT_TYPES, contentTypeSet, mediaUploadPresignRequestSchema, mediaUploadResponseDataSchema, mediaUploadResponseSchema, avatarGenerateRequestSchema, avatarGenerateResponseDataSchema, avatarCreditsResponseDataSchema, avatarSelectRequestSchema, avatarSelectResponseDataSchema, mediaGenerateImageRequestSchema, mediaGenerateImageResponseDataSchema, mediaGenerateImageResponseSchema, mediaGenerateVideoRequestSchema, mediaGenerateVideoResponseDataSchema, mediaGenerateVideoResponseSchema, mediaVideoJobParamsSchema, mediaVideoJobResponseDataSchema, mediaVideoJobResponseSchema, mediaImagesInfoResponseDataSchema, mediaVideosInfoResponseDataSchema, mediaImagesInfoResponseSchema, mediaVideosInfoResponseSchema;
 var init_media = __esm(() => {
@@ -1945,159 +2029,159 @@ var init_media = __esm(() => {
     ...MEDIA_UPLOAD_VIDEO_TYPES
   ];
   contentTypeSet = new Set(MEDIA_UPLOAD_CONTENT_TYPES);
-  mediaUploadPresignRequestSchema = z10.object({
+  mediaUploadPresignRequestSchema = z11.object({
     filename: requiredString2("filename", missingPresignMessage),
     contentType: requiredString2("contentType", missingPresignMessage).refine((value) => contentTypeSet.has(value), { message: "Invalid content type" })
   });
-  mediaUploadResponseDataSchema = z10.object({
-    key: z10.string(),
-    url: z10.string().url().optional(),
-    avatarUrl: z10.string().url().optional(),
-    uploadUrl: z10.string().url().optional(),
-    imageUrl: z10.string().url().optional(),
-    videoUrl: z10.string().url().optional(),
-    maxSizeBytes: z10.number().int().positive().optional(),
-    contentType: z10.string().optional(),
-    expiresAt: z10.string().optional(),
-    instructions: z10.string().optional()
+  mediaUploadResponseDataSchema = z11.object({
+    key: z11.string(),
+    url: z11.string().url().optional(),
+    avatarUrl: z11.string().url().optional(),
+    uploadUrl: z11.string().url().optional(),
+    imageUrl: z11.string().url().optional(),
+    videoUrl: z11.string().url().optional(),
+    maxSizeBytes: z11.number().int().positive().optional(),
+    contentType: z11.string().optional(),
+    expiresAt: z11.string().optional(),
+    instructions: z11.string().optional()
   }).passthrough();
   mediaUploadResponseSchema = successEnvelope(mediaUploadResponseDataSchema);
-  avatarGenerateRequestSchema = z10.object({
-    prompt: z10.string().min(1).max(2000)
-  });
-  avatarGenerateResponseDataSchema = z10.object({
-    generationId: z10.string().uuid().nullable(),
-    imageUrl: z10.string().url(),
-    creditsRemaining: z10.number()
-  });
-  avatarCreditsResponseDataSchema = z10.object({
-    creditsTotal: z10.number(),
-    creditsUsed: z10.number(),
-    creditsRemaining: z10.number(),
-    generations: z10.array(z10.object({
-      id: z10.string().uuid(),
-      imageUrl: z10.string().url().nullable(),
-      selected: z10.boolean().nullable(),
-      createdAt: z10.string()
+  avatarGenerateRequestSchema = z11.object({
+    prompt: z11.string().min(1).max(2000)
+  });
+  avatarGenerateResponseDataSchema = z11.object({
+    generationId: z11.string().uuid().nullable(),
+    imageUrl: z11.string().url(),
+    creditsRemaining: z11.number()
+  });
+  avatarCreditsResponseDataSchema = z11.object({
+    creditsTotal: z11.number(),
+    creditsUsed: z11.number(),
+    creditsRemaining: z11.number(),
+    generations: z11.array(z11.object({
+      id: z11.string().uuid(),
+      imageUrl: z11.string().url().nullable(),
+      selected: z11.boolean().nullable(),
+      createdAt: z11.string()
     }).passthrough())
   });
-  avatarSelectRequestSchema = z10.object({
-    generationId: z10.string().uuid()
+  avatarSelectRequestSchema = z11.object({
+    generationId: z11.string().uuid()
   });
-  avatarSelectResponseDataSchema = z10.object({
-    avatarUrl: z10.string().url(),
-    generationId: z10.string().uuid()
+  avatarSelectResponseDataSchema = z11.object({
+    avatarUrl: z11.string().url(),
+    generationId: z11.string().uuid()
   });
-  mediaGenerateImageRequestSchema = z10.object({
+  mediaGenerateImageRequestSchema = z11.object({
     tradeId: requiredString2("tradeId"),
     prompt: requiredString2("prompt").refine((value) => value.length <= 2000, {
       message: "Prompt must be a string with max 2000 characters"
     }),
-    aspectRatio: z10.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional()
+    aspectRatio: z11.enum(["16:9", "4:3", "1:1", "3:4", "9:16"]).optional()
   });
-  mediaGenerateImageResponseDataSchema = z10.object({
-    jobId: z10.string().uuid().nullable(),
-    imageUrl: z10.string().url(),
-    aspectRatio: z10.string(),
-    cost: z10.number(),
-    tradeId: z10.string()
+  mediaGenerateImageResponseDataSchema = z11.object({
+    jobId: z11.string().uuid().nullable(),
+    imageUrl: z11.string().url(),
+    aspectRatio: z11.string(),
+    cost: z11.number(),
+    tradeId: z11.string()
   });
   mediaGenerateImageResponseSchema = successEnvelope(mediaGenerateImageResponseDataSchema);
-  mediaGenerateVideoRequestSchema = z10.object({
-    tradeId: z10.string().uuid().optional(),
-    tokenId: z10.string().uuid().optional(),
-    prompt: z10.string().max(1e4).optional(),
-    aspectRatio: z10.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional(),
-    imagePrompt: z10.string().max(2000).optional(),
-    firstFrameUrl: z10.string().url().optional()
+  mediaGenerateVideoRequestSchema = z11.object({
+    tradeId: z11.string().uuid().optional(),
+    tokenId: z11.string().uuid().optional(),
+    prompt: z11.string().max(1e4).optional(),
+    aspectRatio: z11.enum(["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"]).optional(),
+    imagePrompt: z11.string().max(2000).optional(),
+    firstFrameUrl: z11.string().url().optional()
   }).refine((data) => data.tradeId || data.tokenId, { message: "Either tradeId or tokenId is required", path: ["tradeId"] });
-  mediaGenerateVideoResponseDataSchema = z10.object({
-    jobId: z10.string().uuid(),
-    status: z10.string(),
-    mediaType: z10.string(),
-    provider: z10.string(),
-    duration: z10.number(),
-    cost: z10.number(),
-    note: z10.string()
+  mediaGenerateVideoResponseDataSchema = z11.object({
+    jobId: z11.string().uuid(),
+    status: z11.string(),
+    mediaType: z11.string(),
+    provider: z11.string(),
+    duration: z11.number(),
+    cost: z11.number(),
+    note: z11.string()
   });
   mediaGenerateVideoResponseSchema = successEnvelope(mediaGenerateVideoResponseDataSchema);
-  mediaVideoJobParamsSchema = z10.object({
+  mediaVideoJobParamsSchema = z11.object({
     jobId: requiredString2("jobId")
   });
-  mediaVideoJobResponseDataSchema = z10.object({
-    jobId: z10.string(),
-    status: z10.string(),
-    mediaType: z10.string(),
-    tradeId: z10.string().nullable(),
-    tokenId: z10.string().nullable().optional(),
-    provider: z10.string().optional(),
-    requestedDuration: z10.number(),
-    actualDuration: z10.number().optional(),
-    createdAt: z10.string(),
-    startedAt: z10.string().optional(),
-    completedAt: z10.string().optional(),
-    videoUrl: z10.string().url().nullable().optional(),
-    costUsd: z10.number().nullable().optional(),
-    errorMessage: z10.string().nullable().optional(),
-    fallbackImageUrl: z10.string().url().optional(),
-    firstFrameImageUrl: z10.string().url().nullable().optional()
+  mediaVideoJobResponseDataSchema = z11.object({
+    jobId: z11.string(),
+    status: z11.string(),
+    mediaType: z11.string(),
+    tradeId: z11.string().nullable(),
+    tokenId: z11.string().nullable().optional(),
+    provider: z11.string().optional(),
+    requestedDuration: z11.number(),
+    actualDuration: z11.number().optional(),
+    createdAt: z11.string(),
+    startedAt: z11.string().optional(),
+    completedAt: z11.string().optional(),
+    videoUrl: z11.string().url().nullable().optional(),
+    costUsd: z11.number().nullable().optional(),
+    errorMessage: z11.string().nullable().optional(),
+    fallbackImageUrl: z11.string().url().optional(),
+    firstFrameImageUrl: z11.string().url().nullable().optional()
   });
   mediaVideoJobResponseSchema = successEnvelope(mediaVideoJobResponseDataSchema);
-  mediaImagesInfoResponseDataSchema = z10.object({
-    model: z10.string().optional(),
-    description: z10.string().optional(),
-    supportedAspectRatios: z10.array(z10.string()).optional(),
-    cost: z10.number().optional(),
-    maxPromptLength: z10.number().optional(),
-    provider: z10.string().optional(),
-    note: z10.string().optional(),
-    usage: z10.object({
-      method: z10.string(),
-      body: z10.record(z10.string(), z10.string()),
-      headers: z10.record(z10.string(), z10.string())
+  mediaImagesInfoResponseDataSchema = z11.object({
+    model: z11.string().optional(),
+    description: z11.string().optional(),
+    supportedAspectRatios: z11.array(z11.string()).optional(),
+    cost: z11.number().optional(),
+    maxPromptLength: z11.number().optional(),
+    provider: z11.string().optional(),
+    note: z11.string().optional(),
+    usage: z11.object({
+      method: z11.string(),
+      body: z11.record(z11.string(), z11.string()),
+      headers: z11.record(z11.string(), z11.string())
     }).optional(),
-    videoAlternative: z10.object({
-      endpoint: z10.string(),
-      note: z10.string()
+    videoAlternative: z11.object({
+      endpoint: z11.string(),
+      note: z11.string()
     }).optional(),
-    yourStats: z10.object({
-      qualifyingTradesForImage: z10.number(),
-      imagesGenerated: z10.number(),
-      availableForImage: z10.number(),
-      recentAvailableTrades: z10.array(z10.object({
-        tradeId: z10.string(),
-        valueUsd: z10.number()
+    yourStats: z11.object({
+      qualifyingTradesForImage: z11.number(),
+      imagesGenerated: z11.number(),
+      availableForImage: z11.number(),
+      recentAvailableTrades: z11.array(z11.object({
+        tradeId: z11.string(),
+        valueUsd: z11.number()
       }))
     }).optional()
   }).passthrough();
-  mediaVideosInfoResponseDataSchema = z10.object({
-    description: z10.string().optional(),
-    tiers: z10.record(z10.string(), z10.object({
-      duration: z10.number(),
-      cost: z10.number()
+  mediaVideosInfoResponseDataSchema = z11.object({
+    description: z11.string().optional(),
+    tiers: z11.record(z11.string(), z11.object({
+      duration: z11.number(),
+      cost: z11.number()
     }).passthrough()).optional(),
-    providers: z10.array(z10.string()).optional(),
-    limits: z10.record(z10.string(), z10.unknown()).optional(),
-    usage: z10.object({
-      method: z10.string(),
-      body: z10.record(z10.string(), z10.string()),
-      headers: z10.record(z10.string(), z10.string())
+    providers: z11.array(z11.string()).optional(),
+    limits: z11.record(z11.string(), z11.unknown()).optional(),
+    usage: z11.object({
+      method: z11.string(),
+      body: z11.record(z11.string(), z11.string()),
+      headers: z11.record(z11.string(), z11.string())
     }).optional(),
-    statusCheck: z10.object({
-      method: z10.string(),
-      endpoint: z10.string()
+    statusCheck: z11.object({
+      method: z11.string(),
+      endpoint: z11.string()
     }).optional(),
-    yourStats: z10.object({
-      qualifyingTrades: z10.number(),
-      videosGenerated: z10.number(),
-      availableForVideo: z10.number(),
-      recentQualifyingTrades: z10.array(z10.object({
-        tradeId: z10.string(),
-        valueUsd: z10.number(),
-        tier: z10.object({
-          type: z10.string(),
-          duration: z10.number(),
-          cost: z10.number()
+    yourStats: z11.object({
+      qualifyingTrades: z11.number(),
+      videosGenerated: z11.number(),
+      availableForVideo: z11.number(),
+      recentQualifyingTrades: z11.array(z11.object({
+        tradeId: z11.string(),
+        valueUsd: z11.number(),
+        tier: z11.object({
+          type: z11.string(),
+          duration: z11.number(),
+          cost: z11.number()
         }).passthrough()
       }))
     }).optional()
@@ -2113,6 +2197,7 @@ var init_agent = __esm(() => {
   init_posts();
   init_agents();
   init_trade();
+  init_hyperliquid();
   init_incubator();
   init_groups();
   init_tokens();
@@ -2215,10 +2300,20 @@ var init_agent = __esm(() => {
       const body = policyUpdateRequestSchema.parse(updates);
       return this.request({ method: "PATCH", path: "/agents/me/policies", body, headers: this.authHeaders() }, policyUpdateResponseDataSchema);
     }
+    async setupHyperliquid(sourceChain) {
+      return this.request({ method: "POST", path: "/hyperliquid/setup", body: sourceChain ? { sourceChain } : {}, headers: this.authHeaders() }, hyperliquidSetupResponseDataSchema);
+    }
+    async getHyperliquidAccount() {
+      return this.request({ method: "GET", path: "/hyperliquid/account", headers: this.authHeaders() }, hyperliquidAccountResponseDataSchema);
+    }
     async trade(req) {
       const body = tradeRequestSchema.parse(req);
       return this.request({ method: "POST", path: "/trade", body, headers: this.authHeaders() }, tradeResponseDataSchema);
     }
+    async quote(req) {
+      const body = solanaTradeRequestSchema.parse({ ...req, dryRun: true });
+      return this.request({ method: "POST", path: "/trade", body, headers: this.authHeaders() }, dryRunResponseDataSchema);
+    }
     async getTokenInfo(token) {
       return this.request({ method: "GET", path: `/tokens/${encodeURIComponent(token)}`, headers: this.authHeaders() }, tokenInfoResponseDataSchema);
     }
@@ -2417,430 +2512,430 @@ var init_autonomous = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/admin.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var adminDisputeResolutions, adminDisputeParamsSchema, adminDisputesQuerySchema, adminResolveDisputeRequestSchema, adminDisputesResponseDataSchema, adminResolveDisputeResponseDataSchema, adminAgentsResponseDataSchema, adminTurnsResponseDataSchema, adminMessageAgentsRequestSchema, adminMessageAgentsResponseDataSchema, adminPendingPayoutsResponseDataSchema, adminProcessPayoutRequestSchema, adminProcessPayoutResponseDataSchema, adminApprovePayoutRequestSchema, adminSkipPayoutRequestSchema, adminForfeitPayoutRequestSchema, adminRecordTxRequestSchema, adminApprovalQueueResponseDataSchema, adminApprovePayoutResponseDataSchema, adminSkipPayoutResponseDataSchema, adminForfeitPayoutResponseDataSchema, adminRecordTxResponseDataSchema, adminReferrerIdParamsSchema, adminReferralOverviewResponseDataSchema, adminReferralTradesQuerySchema, adminReferralTradesResponseDataSchema, adminReferralGamingSignalSchema, adminReferralSignalsResponseDataSchema, adminAgentIdParamsSchema, adminCreateAgentRequestSchema, adminUpdateAgentRequestSchema, adminUserIdParamsSchema, adminUsersQuerySchema, adminUpdateUserRequestSchema, adminCreateAgentResponseDataSchema, adminUpdateAgentResponseDataSchema, adminUsersResponseDataSchema, adminUpdateUserResponseDataSchema, adminIncubatorBirthRequestSchema, adminIncubatorAdjustRequestSchema, adminIncubatorWalletRequestSchema, adminIncubatorTransactionsQuerySchema, adminIncubatorPoolResponseDataSchema, adminIncubatorTransactionSchema, adminIncubatorTransactionsResponseDataSchema, adminIncubatorBirthResponseDataSchema, adminIncubatorAdjustResponseDataSchema, adminIncubatorWalletResponseDataSchema, adminDisputesResponseSchema, adminResolveDisputeResponseSchema, adminMessageAgentsResponseSchema, adminIncubatorPoolResponseSchema, adminIncubatorTransactionsResponseSchema, adminIncubatorBirthResponseSchema, adminIncubatorAdjustResponseSchema, adminIncubatorWalletResponseSchema;
 var init_admin = __esm(() => {
   init_common();
   adminDisputeResolutions = ["human_wins", "agent_wins", "split"];
-  adminDisputeParamsSchema = z11.object({
-    disputeId: z11.string().uuid()
-  });
-  adminDisputesQuerySchema = z11.object({
-    status: z11.enum(["pending", ...adminDisputeResolutions]).default("pending"),
-    limit: z11.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z11.coerce.number().int().min(0).default(0)
-  });
-  adminResolveDisputeRequestSchema = z11.object({
-    resolution: z11.enum(adminDisputeResolutions),
-    note: z11.string().trim().max(4000).optional()
-  });
-  adminDisputesResponseDataSchema = z11.object({
-    disputes: z11.array(z11.object({
-      id: z11.string().uuid(),
-      taskId: z11.string().uuid(),
-      initiatedBy: z11.string(),
-      reason: z11.string(),
-      evidenceUrls: z11.array(z11.string()).nullable(),
-      resolution: z11.string(),
-      resolvedBy: z11.string().nullable(),
-      resolvedAt: z11.string().nullable(),
-      createdAt: z11.string(),
-      task: z11.object({
-        id: z11.string().uuid(),
-        agentId: z11.string().uuid(),
-        agentName: z11.string().nullable(),
-        title: z11.string(),
-        budgetUsd: z11.number(),
-        status: z11.string(),
-        assignedTo: z11.string().uuid().nullable()
+  adminDisputeParamsSchema = z12.object({
+    disputeId: z12.string().uuid()
+  });
+  adminDisputesQuerySchema = z12.object({
+    status: z12.enum(["pending", ...adminDisputeResolutions]).default("pending"),
+    limit: z12.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
+    offset: z12.coerce.number().int().min(0).default(0)
+  });
+  adminResolveDisputeRequestSchema = z12.object({
+    resolution: z12.enum(adminDisputeResolutions),
+    note: z12.string().trim().max(4000).optional()
+  });
+  adminDisputesResponseDataSchema = z12.object({
+    disputes: z12.array(z12.object({
+      id: z12.string().uuid(),
+      taskId: z12.string().uuid(),
+      initiatedBy: z12.string(),
+      reason: z12.string(),
+      evidenceUrls: z12.array(z12.string()).nullable(),
+      resolution: z12.string(),
+      resolvedBy: z12.string().nullable(),
+      resolvedAt: z12.string().nullable(),
+      createdAt: z12.string(),
+      task: z12.object({
+        id: z12.string().uuid(),
+        agentId: z12.string().uuid(),
+        agentName: z12.string().nullable(),
+        title: z12.string(),
+        budgetUsd: z12.number(),
+        status: z12.string(),
+        assignedTo: z12.string().uuid().nullable()
       }).nullable()
     })),
-    count: z11.number(),
-    pagination: z11.object({
-      limit: z11.number(),
-      offset: z11.number(),
-      hasMore: z11.boolean()
+    count: z12.number(),
+    pagination: z12.object({
+      limit: z12.number(),
+      offset: z12.number(),
+      hasMore: z12.boolean()
     })
   });
-  adminResolveDisputeResponseDataSchema = z11.object({
-    dispute: z11.object({
-      id: z11.string().uuid(),
-      taskId: z11.string().uuid(),
-      resolution: z11.string(),
-      resolvedBy: z11.string(),
-      payoutTx: z11.string().nullable(),
-      newTaskStatus: z11.string()
+  adminResolveDisputeResponseDataSchema = z12.object({
+    dispute: z12.object({
+      id: z12.string().uuid(),
+      taskId: z12.string().uuid(),
+      resolution: z12.string(),
+      resolvedBy: z12.string(),
+      payoutTx: z12.string().nullable(),
+      newTaskStatus: z12.string()
     })
   });
-  adminAgentsResponseDataSchema = z11.object({
-    agents: z11.array(z11.object({
-      id: z11.string().uuid(),
-      name: z11.string(),
-      handle: z11.string().nullable(),
-      avatarUrl: z11.string().nullable(),
-      solanaAddress: z11.string().nullable(),
-      generation: z11.number().nullable(),
-      bornAt: z11.string().nullable(),
-      diedAt: z11.string().nullable(),
-      isAlive: z11.boolean(),
-      llmModel: z11.string().nullable(),
-      llmUsageUsd: z11.number().nullable(),
-      llmBudgetUsd: z11.number().nullable(),
-      serverPlan: z11.string().nullable(),
-      totalValueUsd: z11.number(),
-      pnlAllTime: z11.number(),
-      totalTurns: z11.number(),
-      totalCostUsd: z11.number(),
-      totalEntries: z11.number(),
-      lastTurnAt: z11.string().nullable(),
-      lastEntryPreview: z11.string().nullable()
+  adminAgentsResponseDataSchema = z12.object({
+    agents: z12.array(z12.object({
+      id: z12.string().uuid(),
+      name: z12.string(),
+      handle: z12.string().nullable(),
+      avatarUrl: z12.string().nullable(),
+      solanaAddress: z12.string().nullable(),
+      generation: z12.number().nullable(),
+      bornAt: z12.string().nullable(),
+      diedAt: z12.string().nullable(),
+      isAlive: z12.boolean(),
+      llmModel: z12.string().nullable(),
+      llmUsageUsd: z12.number().nullable(),
+      llmBudgetUsd: z12.number().nullable(),
+      serverPlan: z12.string().nullable(),
+      totalValueUsd: z12.number(),
+      pnlAllTime: z12.number(),
+      totalTurns: z12.number(),
+      totalCostUsd: z12.number(),
+      totalEntries: z12.number(),
+      lastTurnAt: z12.string().nullable(),
+      lastEntryPreview: z12.string().nullable()
     })),
-    count: z11.number()
-  });
-  adminTurnsResponseDataSchema = z11.object({
-    turns: z11.array(z11.object({
-      id: z11.number(),
-      piEntryId: z11.string().nullable(),
-      parentPiEntryId: z11.string().nullable(),
-      entryType: z11.string().nullable(),
-      seq: z11.number().nullable(),
-      timestamp: z11.string().nullable(),
-      role: z11.string().nullable(),
-      contentPreview: z11.string().nullable(),
-      model: z11.string().nullable(),
-      provider: z11.string().nullable(),
-      toolName: z11.string().nullable(),
-      tokenInput: z11.number().nullable(),
-      tokenOutput: z11.number().nullable(),
-      costUsd: z11.number().nullable(),
-      sourceType: z11.string().nullable(),
-      sourceRef: z11.string().nullable(),
-      payload: z11.unknown().nullable()
+    count: z12.number()
+  });
+  adminTurnsResponseDataSchema = z12.object({
+    turns: z12.array(z12.object({
+      id: z12.number(),
+      piEntryId: z12.string().nullable(),
+      parentPiEntryId: z12.string().nullable(),
+      entryType: z12.string().nullable(),
+      seq: z12.number().nullable(),
+      timestamp: z12.string().nullable(),
+      role: z12.string().nullable(),
+      contentPreview: z12.string().nullable(),
+      model: z12.string().nullable(),
+      provider: z12.string().nullable(),
+      toolName: z12.string().nullable(),
+      tokenInput: z12.number().nullable(),
+      tokenOutput: z12.number().nullable(),
+      costUsd: z12.number().nullable(),
+      sourceType: z12.string().nullable(),
+      sourceRef: z12.string().nullable(),
+      payload: z12.unknown().nullable()
     })),
-    page: z11.number(),
-    pageSize: z11.number()
+    page: z12.number(),
+    pageSize: z12.number()
   });
-  adminMessageAgentsRequestSchema = z11.object({
-    message: z11.string().trim().min(1, "Message is required").max(4000),
-    agentIds: z11.array(z11.string().uuid()).min(1).optional(),
-    broadcast: z11.boolean().optional()
+  adminMessageAgentsRequestSchema = z12.object({
+    message: z12.string().trim().min(1, "Message is required").max(4000),
+    agentIds: z12.array(z12.string().uuid()).min(1).optional(),
+    broadcast: z12.boolean().optional()
   }).refine((data) => data.agentIds && data.agentIds.length > 0 || data.broadcast === true, { message: "Provide agentIds or set broadcast to true" }).refine((data) => !(data.agentIds && data.agentIds.length > 0 && data.broadcast === true), { message: "Cannot specify both agentIds and broadcast" });
-  adminMessageAgentsResponseDataSchema = z11.object({
-    sent: z11.number(),
-    agentIds: z11.array(z11.string().uuid())
-  });
-  adminPendingPayoutsResponseDataSchema = z11.object({
-    min_payout_usd: z11.number().optional(),
-    pending_payouts: z11.array(z11.object({
-      referrer_id: z11.string(),
-      name: z11.string(),
-      handle: z11.string().nullable().optional(),
-      payout_wallet: z11.string().nullable().optional(),
-      referral_count: z11.number(),
-      total_volume_usd: z11.number(),
-      total_earned: z11.number(),
-      total_paid_out: z11.number(),
-      pending_amount: z11.number(),
-      solana_earned: z11.number(),
-      hyperliquid_earned: z11.number(),
-      dbc_pool_earned: z11.number()
+  adminMessageAgentsResponseDataSchema = z12.object({
+    sent: z12.number(),
+    agentIds: z12.array(z12.string().uuid())
+  });
+  adminPendingPayoutsResponseDataSchema = z12.object({
+    min_payout_usd: z12.number().optional(),
+    pending_payouts: z12.array(z12.object({
+      referrer_id: z12.string(),
+      name: z12.string(),
+      handle: z12.string().nullable().optional(),
+      payout_wallet: z12.string().nullable().optional(),
+      referral_count: z12.number(),
+      total_volume_usd: z12.number(),
+      total_earned: z12.number(),
+      total_paid_out: z12.number(),
+      pending_amount: z12.number(),
+      solana_earned: z12.number(),
+      hyperliquid_earned: z12.number(),
+      dbc_pool_earned: z12.number()
     }))
   });
-  adminProcessPayoutRequestSchema = z11.object({
-    referrer_id: z11.string().min(1),
-    amount: z11.number().finite().positive().max(1e5),
-    tx_signature: z11.string().min(1)
+  adminProcessPayoutRequestSchema = z12.object({
+    referrer_id: z12.string().min(1),
+    amount: z12.number().finite().positive().max(1e5),
+    tx_signature: z12.string().min(1)
   });
-  adminProcessPayoutResponseDataSchema = z11.object({
-    payout_id: z11.string(),
-    referrer: z11.object({
-      id: z11.string(),
-      name: z11.string().nullable()
+  adminProcessPayoutResponseDataSchema = z12.object({
+    payout_id: z12.string(),
+    referrer: z12.object({
+      id: z12.string(),
+      name: z12.string().nullable()
     }),
-    amount: z11.number(),
-    wallet_address: z11.string(),
-    tx_signature: z11.string(),
-    status: z11.string()
-  });
-  adminApprovePayoutRequestSchema = z11.object({
-    referrer_id: z11.string().uuid(),
-    amount: z11.number().finite().positive().min(5),
-    notes: z11.string().trim().max(1000).optional()
-  });
-  adminSkipPayoutRequestSchema = z11.object({
-    referrer_id: z11.string().uuid(),
-    notes: z11.string().trim().max(1000).optional()
-  });
-  adminForfeitPayoutRequestSchema = z11.object({
-    referrer_id: z11.string().uuid(),
-    amount: z11.number().finite().positive(),
-    notes: z11.string().trim().min(1).max(1000)
-  });
-  adminRecordTxRequestSchema = z11.object({
-    payout_id: z11.string().uuid(),
-    tx_signature: z11.string().min(1)
-  });
-  adminApprovalQueueResponseDataSchema = z11.object({
-    referrers: z11.array(z11.object({
-      referrerId: z11.string(),
-      name: z11.string(),
-      handle: z11.string().nullable(),
-      payoutWallet: z11.string().nullable(),
-      pendingAmount: z11.number(),
-      referralCount: z11.number(),
-      totalVolumeUsd: z11.number(),
-      totalEarned: z11.number(),
-      totalPaidOut: z11.number(),
-      overallRisk: z11.enum(["low", "medium", "high"]).optional()
+    amount: z12.number(),
+    wallet_address: z12.string(),
+    tx_signature: z12.string(),
+    status: z12.string()
+  });
+  adminApprovePayoutRequestSchema = z12.object({
+    referrer_id: z12.string().uuid(),
+    amount: z12.number().finite().positive().min(5),
+    notes: z12.string().trim().max(1000).optional()
+  });
+  adminSkipPayoutRequestSchema = z12.object({
+    referrer_id: z12.string().uuid(),
+    notes: z12.string().trim().max(1000).optional()
+  });
+  adminForfeitPayoutRequestSchema = z12.object({
+    referrer_id: z12.string().uuid(),
+    amount: z12.number().finite().positive(),
+    notes: z12.string().trim().min(1).max(1000)
+  });
+  adminRecordTxRequestSchema = z12.object({
+    payout_id: z12.string().uuid(),
+    tx_signature: z12.string().min(1)
+  });
+  adminApprovalQueueResponseDataSchema = z12.object({
+    referrers: z12.array(z12.object({
+      referrerId: z12.string(),
+      name: z12.string(),
+      handle: z12.string().nullable(),
+      payoutWallet: z12.string().nullable(),
+      pendingAmount: z12.number(),
+      referralCount: z12.number(),
+      totalVolumeUsd: z12.number(),
+      totalEarned: z12.number(),
+      totalPaidOut: z12.number(),
+      overallRisk: z12.enum(["low", "medium", "high"]).optional()
     })),
-    approvedPayouts: z11.array(z11.object({
-      id: z11.string(),
-      referrerId: z11.string(),
-      referrerName: z11.string(),
-      amount: z11.number(),
-      approvedAt: z11.string(),
-      notes: z11.string().nullable()
+    approvedPayouts: z12.array(z12.object({
+      id: z12.string(),
+      referrerId: z12.string(),
+      referrerName: z12.string(),
+      amount: z12.number(),
+      approvedAt: z12.string(),
+      notes: z12.string().nullable()
     }))
   });
-  adminApprovePayoutResponseDataSchema = z11.object({
-    payout: z11.object({
-      id: z11.string(),
-      referrerId: z11.string(),
-      referrerName: z11.string(),
-      amount: z11.number(),
-      wallet: z11.string(),
-      status: z11.literal("approved"),
-      approvedAt: z11.string(),
-      notes: z11.string().nullable()
+  adminApprovePayoutResponseDataSchema = z12.object({
+    payout: z12.object({
+      id: z12.string(),
+      referrerId: z12.string(),
+      referrerName: z12.string(),
+      amount: z12.number(),
+      wallet: z12.string(),
+      status: z12.literal("approved"),
+      approvedAt: z12.string(),
+      notes: z12.string().nullable()
     })
   });
-  adminSkipPayoutResponseDataSchema = z11.object({
-    payout: z11.object({
-      id: z11.string(),
-      referrerId: z11.string(),
-      status: z11.literal("skipped"),
-      periodStart: z11.string(),
-      periodEnd: z11.string(),
-      notes: z11.string().nullable()
+  adminSkipPayoutResponseDataSchema = z12.object({
+    payout: z12.object({
+      id: z12.string(),
+      referrerId: z12.string(),
+      status: z12.literal("skipped"),
+      periodStart: z12.string(),
+      periodEnd: z12.string(),
+      notes: z12.string().nullable()
     })
   });
-  adminForfeitPayoutResponseDataSchema = z11.object({
-    payout: z11.object({
-      id: z11.string(),
-      referrerId: z11.string(),
-      amount: z11.number(),
-      status: z11.literal("forfeited"),
-      notes: z11.string()
+  adminForfeitPayoutResponseDataSchema = z12.object({
+    payout: z12.object({
+      id: z12.string(),
+      referrerId: z12.string(),
+      amount: z12.number(),
+      status: z12.literal("forfeited"),
+      notes: z12.string()
     })
   });
-  adminRecordTxResponseDataSchema = z11.object({
-    payout: z11.object({
-      id: z11.string(),
-      referrerId: z11.string(),
-      amount: z11.number(),
-      status: z11.literal("completed"),
-      txSignature: z11.string(),
-      completedAt: z11.string().nullable()
+  adminRecordTxResponseDataSchema = z12.object({
+    payout: z12.object({
+      id: z12.string(),
+      referrerId: z12.string(),
+      amount: z12.number(),
+      status: z12.literal("completed"),
+      txSignature: z12.string(),
+      completedAt: z12.string().nullable()
     })
   });
-  adminReferrerIdParamsSchema = z11.object({
-    referrerId: z11.string().uuid()
-  });
-  adminReferralOverviewResponseDataSchema = z11.object({
-    totalReferrers: z11.number(),
-    totalReferees: z11.number(),
-    totalVolumeUsd: z11.number(),
-    totalEarned: z11.number(),
-    totalPaidOut: z11.number(),
-    totalPending: z11.number(),
-    topReferrers: z11.array(z11.object({
-      referrerId: z11.string(),
-      name: z11.string(),
-      handle: z11.string().nullable(),
-      payoutWallet: z11.string().nullable(),
-      referralCount: z11.number(),
-      totalVolumeUsd: z11.number(),
-      totalEarned: z11.number(),
-      totalPaidOut: z11.number(),
-      pendingAmount: z11.number(),
-      solanaEarned: z11.number(),
-      hyperliquidEarned: z11.number(),
-      dbcPoolEarned: z11.number()
+  adminReferrerIdParamsSchema = z12.object({
+    referrerId: z12.string().uuid()
+  });
+  adminReferralOverviewResponseDataSchema = z12.object({
+    totalReferrers: z12.number(),
+    totalReferees: z12.number(),
+    totalVolumeUsd: z12.number(),
+    totalEarned: z12.number(),
+    totalPaidOut: z12.number(),
+    totalPending: z12.number(),
+    topReferrers: z12.array(z12.object({
+      referrerId: z12.string(),
+      name: z12.string(),
+      handle: z12.string().nullable(),
+      payoutWallet: z12.string().nullable(),
+      referralCount: z12.number(),
+      totalVolumeUsd: z12.number(),
+      totalEarned: z12.number(),
+      totalPaidOut: z12.number(),
+      pendingAmount: z12.number(),
+      solanaEarned: z12.number(),
+      hyperliquidEarned: z12.number(),
+      dbcPoolEarned: z12.number()
     }))
   });
-  adminReferralTradesQuerySchema = z11.object({
-    limit: z11.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
-    offset: z11.coerce.number().int().min(0).default(0)
-  });
-  adminReferralTradesResponseDataSchema = z11.object({
-    trades: z11.array(z11.object({
-      id: z11.string(),
-      chain: z11.string(),
-      agentId: z11.string(),
-      refereeName: z11.string(),
-      refereeHandle: z11.string().nullable(),
-      tokenAddress: z11.string(),
-      valueUsd: z11.number(),
-      feeAmount: z11.number(),
-      referrerFeeBps: z11.number().nullable(),
-      treasuryFeeBps: z11.number().nullable(),
-      referrerEarnedUsd: z11.number(),
-      txSignature: z11.string().nullable(),
-      timestamp: z11.string().nullable()
+  adminReferralTradesQuerySchema = z12.object({
+    limit: z12.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
+    offset: z12.coerce.number().int().min(0).default(0)
+  });
+  adminReferralTradesResponseDataSchema = z12.object({
+    trades: z12.array(z12.object({
+      id: z12.string(),
+      chain: z12.string(),
+      agentId: z12.string(),
+      refereeName: z12.string(),
+      refereeHandle: z12.string().nullable(),
+      tokenAddress: z12.string(),
+      valueUsd: z12.number(),
+      feeAmount: z12.number(),
+      referrerFeeBps: z12.number().nullable(),
+      treasuryFeeBps: z12.number().nullable(),
+      referrerEarnedUsd: z12.number(),
+      txSignature: z12.string().nullable(),
+      timestamp: z12.string().nullable()
     })),
-    pagination: z11.object({
-      limit: z11.number(),
-      offset: z11.number(),
-      total: z11.number(),
-      hasMore: z11.boolean()
+    pagination: z12.object({
+      limit: z12.number(),
+      offset: z12.number(),
+      total: z12.number(),
+      hasMore: z12.boolean()
     })
   });
-  adminReferralGamingSignalSchema = z11.object({
-    type: z11.string(),
-    severity: z11.enum(["low", "medium", "high"]),
-    description: z11.string(),
-    evidence: z11.record(z11.string(), z11.unknown())
-  });
-  adminReferralSignalsResponseDataSchema = z11.object({
-    referrerId: z11.string(),
-    overallRisk: z11.enum(["low", "medium", "high"]),
-    signals: z11.array(adminReferralGamingSignalSchema)
-  });
-  adminAgentIdParamsSchema = z11.object({
-    agentId: z11.string().uuid()
-  });
-  adminCreateAgentRequestSchema = z11.object({
-    name: z11.string().min(1).max(100),
-    handle: z11.string().max(50).optional(),
-    bio: z11.string().max(500).optional(),
-    avatarUrl: z11.string().url().optional(),
-    generation: z11.number().int().optional(),
-    serverPlan: z11.enum(["basic", "standard", "pro"]).optional(),
-    llmModel: z11.string().optional(),
-    llmBudgetUsd: z11.number().optional(),
-    inboxPriceUsd: z11.number().optional()
-  });
-  adminUpdateAgentRequestSchema = z11.object({
-    name: z11.string().min(1).max(100).optional(),
-    handle: z11.string().max(50).optional(),
-    bio: z11.string().max(500).optional(),
-    avatarUrl: z11.string().url().nullable().optional(),
-    llmModel: z11.string().optional(),
-    llmBudgetUsd: z11.number().optional(),
-    serverPlan: z11.enum(["basic", "standard", "pro"]).optional(),
-    generation: z11.number().int().optional(),
-    inboxPriceUsd: z11.number().optional(),
-    isAlive: z11.boolean().optional()
+  adminReferralGamingSignalSchema = z12.object({
+    type: z12.string(),
+    severity: z12.enum(["low", "medium", "high"]),
+    description: z12.string(),
+    evidence: z12.record(z12.string(), z12.unknown())
+  });
+  adminReferralSignalsResponseDataSchema = z12.object({
+    referrerId: z12.string(),
+    overallRisk: z12.enum(["low", "medium", "high"]),
+    signals: z12.array(adminReferralGamingSignalSchema)
+  });
+  adminAgentIdParamsSchema = z12.object({
+    agentId: z12.string().uuid()
+  });
+  adminCreateAgentRequestSchema = z12.object({
+    name: z12.string().min(1).max(100),
+    handle: z12.string().max(50).optional(),
+    bio: z12.string().max(500).optional(),
+    avatarUrl: z12.string().url().optional(),
+    generation: z12.number().int().optional(),
+    serverPlan: z12.enum(["basic", "standard", "pro"]).optional(),
+    llmModel: z12.string().optional(),
+    llmBudgetUsd: z12.number().optional(),
+    inboxPriceUsd: z12.number().optional()
+  });
+  adminUpdateAgentRequestSchema = z12.object({
+    name: z12.string().min(1).max(100).optional(),
+    handle: z12.string().max(50).optional(),
+    bio: z12.string().max(500).optional(),
+    avatarUrl: z12.string().url().nullable().optional(),
+    llmModel: z12.string().optional(),
+    llmBudgetUsd: z12.number().optional(),
+    serverPlan: z12.enum(["basic", "standard", "pro"]).optional(),
+    generation: z12.number().int().optional(),
+    inboxPriceUsd: z12.number().optional(),
+    isAlive: z12.boolean().optional()
   }).refine((obj) => Object.keys(obj).length > 0, { message: "At least one field required" });
-  adminUserIdParamsSchema = z11.object({
-    userId: z11.string().uuid()
-  });
-  adminUsersQuerySchema = z11.object({
-    limit: z11.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
-    offset: z11.coerce.number().int().min(0).default(0),
-    search: z11.string().optional()
-  });
-  adminUpdateUserRequestSchema = z11.object({
-    role: z11.enum(["admin", "user"]).optional(),
-    banned: z11.boolean().optional(),
-    banReason: z11.string().optional(),
-    banExpiresIn: z11.number().positive().optional(),
-    shadowbanned: z11.boolean().optional()
+  adminUserIdParamsSchema = z12.object({
+    userId: z12.string().uuid()
+  });
+  adminUsersQuerySchema = z12.object({
+    limit: z12.coerce.number().int().min(1).default(25).transform((v) => Math.min(v, 100)),
+    offset: z12.coerce.number().int().min(0).default(0),
+    search: z12.string().optional()
+  });
+  adminUpdateUserRequestSchema = z12.object({
+    role: z12.enum(["admin", "user"]).optional(),
+    banned: z12.boolean().optional(),
+    banReason: z12.string().optional(),
+    banExpiresIn: z12.number().positive().optional(),
+    shadowbanned: z12.boolean().optional()
   }).refine((obj) => Object.keys(obj).length > 0, { message: "At least one field required" });
-  adminCreateAgentResponseDataSchema = z11.object({
-    agent: z11.object({
-      id: z11.string().uuid(),
-      name: z11.string(),
-      handle: z11.string().nullable(),
-      email: z11.string()
+  adminCreateAgentResponseDataSchema = z12.object({
+    agent: z12.object({
+      id: z12.string().uuid(),
+      name: z12.string(),
+      handle: z12.string().nullable(),
+      email: z12.string()
     })
   });
-  adminUpdateAgentResponseDataSchema = z11.object({
-    ok: z11.boolean()
+  adminUpdateAgentResponseDataSchema = z12.object({
+    ok: z12.boolean()
   });
-  adminUsersResponseDataSchema = z11.object({
-    users: z11.array(z11.object({
-      id: z11.string().uuid(),
-      name: z11.string().nullable(),
-      email: z11.string().nullable(),
-      role: z11.string().nullable(),
-      banned: z11.boolean().nullable(),
-      banReason: z11.string().nullable(),
-      banExpires: z11.string().nullable(),
-      shadowbanned: z11.boolean().nullable(),
-      createdAt: z11.string().nullable()
+  adminUsersResponseDataSchema = z12.object({
+    users: z12.array(z12.object({
+      id: z12.string().uuid(),
+      name: z12.string().nullable(),
+      email: z12.string().nullable(),
+      role: z12.string().nullable(),
+      banned: z12.boolean().nullable(),
+      banReason: z12.string().nullable(),
+      banExpires: z12.string().nullable(),
+      shadowbanned: z12.boolean().nullable(),
+      createdAt: z12.string().nullable()
     })),
-    total: z11.number()
-  });
-  adminUpdateUserResponseDataSchema = z11.object({
-    user: z11.record(z11.string(), z11.unknown())
-  });
-  adminIncubatorBirthRequestSchema = z11.object({
-    action: z11.enum(["trigger", "pause", "resume"]),
-    skipBalanceCheck: z11.boolean().optional().default(false)
-  });
-  adminIncubatorAdjustRequestSchema = z11.object({
-    amountUsd: z11.number(),
-    source: z11.enum(["manual_credit", "manual_debit", "birth_refund"]),
-    note: z11.string().min(1)
-  });
-  adminIncubatorWalletRequestSchema = z11.object({
-    walletId: z11.string().min(1),
-    walletAddress: z11.string().min(1)
-  });
-  adminIncubatorTransactionsQuerySchema = z11.object({
-    limit: z11.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
-    offset: z11.coerce.number().int().min(0).default(0),
-    source: z11.string().optional()
-  });
-  adminIncubatorPoolResponseDataSchema = z11.object({
-    balance_usd: z11.number(),
-    threshold_usd: z11.number(),
-    progress_pct: z11.number(),
-    total_born: z11.number(),
-    alive_count: z11.number(),
-    dead_count: z11.number(),
-    generation: z11.number(),
-    birth_status: z11.string(),
-    birth_paused: z11.boolean(),
-    pool_wallet_id: z11.string().nullable(),
-    pool_wallet_address: z11.string().nullable(),
-    incubator_fee_percent: z11.number(),
-    birth_threshold_usd: z11.number(),
-    onChainBalanceSol: z11.number(),
-    onChainBalanceUsd: z11.number()
-  });
-  adminIncubatorTransactionSchema = z11.object({
-    id: z11.string().uuid(),
-    amountUsd: z11.number(),
-    source: z11.string(),
-    sourceTradeId: z11.string().nullable(),
-    adminNote: z11.string().nullable(),
-    createdAt: z11.string()
-  });
-  adminIncubatorTransactionsResponseDataSchema = z11.object({
-    transactions: z11.array(adminIncubatorTransactionSchema),
-    total: z11.number()
-  });
-  adminIncubatorBirthResponseDataSchema = z11.object({
-    ok: z11.literal(true),
-    action: z11.enum(["triggered", "paused", "resumed"]),
-    agent: z11.object({
-      id: z11.string(),
-      number: z11.number(),
-      solanaAddress: z11.string()
+    total: z12.number()
+  });
+  adminUpdateUserResponseDataSchema = z12.object({
+    user: z12.record(z12.string(), z12.unknown())
+  });
+  adminIncubatorBirthRequestSchema = z12.object({
+    action: z12.enum(["trigger", "pause", "resume"]),
+    skipBalanceCheck: z12.boolean().optional().default(false)
+  });
+  adminIncubatorAdjustRequestSchema = z12.object({
+    amountUsd: z12.number(),
+    source: z12.enum(["manual_credit", "manual_debit", "birth_refund"]),
+    note: z12.string().min(1)
+  });
+  adminIncubatorWalletRequestSchema = z12.object({
+    walletId: z12.string().min(1),
+    walletAddress: z12.string().min(1)
+  });
+  adminIncubatorTransactionsQuerySchema = z12.object({
+    limit: z12.coerce.number().int().min(1).default(50).transform((v) => Math.min(v, 100)),
+    offset: z12.coerce.number().int().min(0).default(0),
+    source: z12.string().optional()
+  });
+  adminIncubatorPoolResponseDataSchema = z12.object({
+    balance_usd: z12.number(),
+    threshold_usd: z12.number(),
+    progress_pct: z12.number(),
+    total_born: z12.number(),
+    alive_count: z12.number(),
+    dead_count: z12.number(),
+    generation: z12.number(),
+    birth_status: z12.string(),
+    birth_paused: z12.boolean(),
+    pool_wallet_id: z12.string().nullable(),
+    pool_wallet_address: z12.string().nullable(),
+    incubator_fee_percent: z12.number(),
+    birth_threshold_usd: z12.number(),
+    onChainBalanceSol: z12.number(),
+    onChainBalanceUsd: z12.number()
+  });
+  adminIncubatorTransactionSchema = z12.object({
+    id: z12.string().uuid(),
+    amountUsd: z12.number(),
+    source: z12.string(),
+    sourceTradeId: z12.string().nullable(),
+    adminNote: z12.string().nullable(),
+    createdAt: z12.string()
+  });
+  adminIncubatorTransactionsResponseDataSchema = z12.object({
+    transactions: z12.array(adminIncubatorTransactionSchema),
+    total: z12.number()
+  });
+  adminIncubatorBirthResponseDataSchema = z12.object({
+    ok: z12.literal(true),
+    action: z12.enum(["triggered", "paused", "resumed"]),
+    agent: z12.object({
+      id: z12.string(),
+      number: z12.number(),
+      solanaAddress: z12.string()
     }).optional(),
-    transferHash: z11.string().nullable().optional()
+    transferHash: z12.string().nullable().optional()
   });
-  adminIncubatorAdjustResponseDataSchema = z11.object({
-    ok: z11.literal(true),
-    balanceUsd: z11.number(),
-    birthStatus: z11.string()
+  adminIncubatorAdjustResponseDataSchema = z12.object({
+    ok: z12.literal(true),
+    balanceUsd: z12.number(),
+    birthStatus: z12.string()
   });
-  adminIncubatorWalletResponseDataSchema = z11.object({
-    ok: z11.literal(true),
-    walletId: z11.string(),
-    walletAddress: z11.string()
+  adminIncubatorWalletResponseDataSchema = z12.object({
+    ok: z12.literal(true),
+    walletId: z12.string(),
+    walletAddress: z12.string()
   });
   adminDisputesResponseSchema = successEnvelope(adminDisputesResponseDataSchema);
   adminResolveDisputeResponseSchema = successEnvelope(adminResolveDisputeResponseDataSchema);
@@ -2853,46 +2948,46 @@ var init_admin = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/auth.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var authApiKeysCreateRequestSchema, authApiKeysDeleteRequestSchema, authSetupRequestSchema, authApiKeysListResponseDataSchema, authApiKeysCreateResponseDataSchema, authApiKeysDeleteResponseDataSchema, authSetupResponseDataSchema, authApiKeysListResponseSchema, authApiKeysCreateResponseSchema, authApiKeysDeleteResponseSchema, authSetupResponseSchema;
 var init_auth = __esm(() => {
   init_common();
-  authApiKeysCreateRequestSchema = z12.object({
-    name: z12.string().trim().min(1).max(120).optional()
-  });
-  authApiKeysDeleteRequestSchema = z12.object({
-    keyId: z12.string().min(1)
-  });
-  authSetupRequestSchema = z12.object({
-    name: z12.string().trim().min(1).max(120).optional(),
-    handle: z12.string().trim().min(1).max(120).optional(),
-    referralCode: z12.string().trim().min(1).max(120).optional()
-  });
-  authApiKeysListResponseDataSchema = z12.object({
-    keys: z12.array(z12.object({
-      id: z12.string(),
-      name: z12.string().nullable(),
-      start: z12.string(),
-      createdAt: z12.string()
+  authApiKeysCreateRequestSchema = z13.object({
+    name: z13.string().trim().min(1).max(120).optional()
+  });
+  authApiKeysDeleteRequestSchema = z13.object({
+    keyId: z13.string().min(1)
+  });
+  authSetupRequestSchema = z13.object({
+    name: z13.string().trim().min(1).max(120).optional(),
+    handle: z13.string().trim().min(1).max(120).optional(),
+    referralCode: z13.string().trim().min(1).max(120).optional()
+  });
+  authApiKeysListResponseDataSchema = z13.object({
+    keys: z13.array(z13.object({
+      id: z13.string(),
+      name: z13.string().nullable(),
+      start: z13.string(),
+      createdAt: z13.string()
     }))
   });
-  authApiKeysCreateResponseDataSchema = z12.object({
-    key: z12.string(),
-    id: z12.string(),
-    start: z12.string()
+  authApiKeysCreateResponseDataSchema = z13.object({
+    key: z13.string(),
+    id: z13.string(),
+    start: z13.string()
   });
-  authApiKeysDeleteResponseDataSchema = z12.object({
-    revoked: z12.boolean()
+  authApiKeysDeleteResponseDataSchema = z13.object({
+    revoked: z13.boolean()
   });
-  authSetupResponseDataSchema = z12.object({
-    userId: z12.string().uuid(),
-    solanaAddress: z12.string().nullable(),
-    hlAddress: z12.string().nullable().optional(),
-    handle: z12.string().nullable(),
-    apiKeyHint: z12.string().nullable(),
-    apiKey: z12.string().optional(),
-    cliCommand: z12.string().optional(),
-    isNew: z12.boolean()
+  authSetupResponseDataSchema = z13.object({
+    userId: z13.string().uuid(),
+    solanaAddress: z13.string().nullable(),
+    hlAddress: z13.string().nullable().optional(),
+    handle: z13.string().nullable(),
+    apiKeyHint: z13.string().nullable(),
+    apiKey: z13.string().optional(),
+    cliCommand: z13.string().optional(),
+    isNew: z13.boolean()
   });
   authApiKeysListResponseSchema = successEnvelope(authApiKeysListResponseDataSchema);
   authApiKeysCreateResponseSchema = successEnvelope(authApiKeysCreateResponseDataSchema);
@@ -2901,156 +2996,57 @@ var init_auth = __esm(() => {
 });
 
 // ../../packages/client/src/schemas/claim.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var claimTokenParamsSchema, claimInfoResponseDataSchema, claimInfoResponseSchema;
 var init_claim = __esm(() => {
   init_common();
-  claimTokenParamsSchema = z13.object({
-    token: z13.string().trim().min(1, "Claim token is required")
-  });
-  claimInfoResponseDataSchema = z13.object({
-    claimed: z13.boolean(),
-    agent: z13.object({
-      name: z13.string(),
-      handle: z13.string().nullable().optional(),
-      bio: z13.string().nullable(),
-      avatar: z13.string().nullable()
+  claimTokenParamsSchema = z14.object({
+    token: z14.string().trim().min(1, "Claim token is required")
+  });
+  claimInfoResponseDataSchema = z14.object({
+    claimed: z14.boolean(),
+    agent: z14.object({
+      name: z14.string(),
+      handle: z14.string().nullable().optional(),
+      bio: z14.string().nullable(),
+      avatar: z14.string().nullable()
     }),
-    verificationCode: z13.string().optional(),
-    tweetText: z13.string().optional(),
-    instructions: z13.string().optional()
+    verificationCode: z14.string().optional(),
+    tweetText: z14.string().optional(),
+    instructions: z14.string().optional()
   });
   claimInfoResponseSchema = successEnvelope(claimInfoResponseDataSchema);
 });
 
 // ../../packages/client/src/schemas/dashboard.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var dashboardStatusResponseDataSchema, dashboardStatusResponseSchema;
 var init_dashboard = __esm(() => {
   init_common();
-  dashboardStatusResponseDataSchema = z14.object({
-    solanaAddress: z14.string().nullable(),
-    hlAddress: z14.string().nullable(),
-    solanaBalance: z14.number(),
-    claimToken: z14.string(),
-    steps: z14.object({
-      funded: z14.boolean(),
-      agentConnected: z14.boolean(),
-      xConnected: z14.boolean().nullable()
+  dashboardStatusResponseDataSchema = z15.object({
+    solanaAddress: z15.string().nullable(),
+    hlAddress: z15.string().nullable(),
+    solanaBalance: z15.number(),
+    claimToken: z15.string(),
+    steps: z15.object({
+      funded: z15.boolean(),
+      agentConnected: z15.boolean(),
+      xConnected: z15.boolean().nullable()
     }),
-    apiKeyHint: z14.string().nullable(),
-    xHandle: z14.string().nullable(),
-    handle: z14.string().nullable(),
-    stats: z14.object({
-      totalValueUsd: z14.number(),
-      pnlAllTime: z14.number(),
-      pnl24h: z14.number(),
-      pnl7d: z14.number(),
-      lastTradeAt: z14.string().nullable()
+    apiKeyHint: z15.string().nullable(),
+    xHandle: z15.string().nullable(),
+    handle: z15.string().nullable(),
+    stats: z15.object({
+      totalValueUsd: z15.number(),
+      pnlAllTime: z15.number(),
+      pnl24h: z15.number(),
+      pnl7d: z15.number(),
+      lastTradeAt: z15.string().nullable()
     }).nullable()
   });
   dashboardStatusResponseSchema = successEnvelope(dashboardStatusResponseDataSchema);
 });
 
-// ../../packages/client/src/schemas/hyperliquid.ts
-import { z as z15 } from "zod";
-var hyperliquidFillsQuerySchema, hyperliquidSetupRequestSchema, hyperliquidSetupResponseDataSchema, hlPositionSchema, hlSpotBalanceSchema, hyperliquidAccountResponseDataSchema, hlFillSchema, hyperliquidFillsResponseDataSchema, hyperliquidLiquidationRiskResponseDataSchema, hyperliquidSetupResponseSchema, hyperliquidAccountResponseSchema, hyperliquidFillsResponseSchema, hyperliquidLiquidationRiskResponseSchema;
-var init_hyperliquid = __esm(() => {
-  init_common();
-  hyperliquidFillsQuerySchema = z15.object({
-    limit: z15.coerce.number().int().min(1).default(50).transform((value) => Math.min(value, 100)),
-    offset: z15.coerce.number().int().min(0).default(0)
-  });
-  hyperliquidSetupRequestSchema = z15.object({
-    sourceChain: z15.enum(["solana", "ethereum", "arbitrum", "optimism", "base"]).optional()
-  });
-  hyperliquidSetupResponseDataSchema = z15.object({
-    deposit_address: z15.string(),
-    min_deposit: z15.number().optional(),
-    source_chain: z15.string(),
-    hl_address: z15.string(),
-    estimated_time: z15.string().optional(),
-    builder: z15.object({
-      address: z15.string(),
-      fee: z15.string()
-    }).passthrough(),
-    instructions: z15.string().optional(),
-    note: z15.string().optional()
-  });
-  hlPositionSchema = z15.object({
-    coin: z15.string(),
-    side: z15.string(),
-    size: z15.number(),
-    entryPrice: z15.number(),
-    unrealizedPnl: z15.number(),
-    marginUsed: z15.number(),
-    leverage: z15.number(),
-    liquidationPrice: z15.number().nullable()
-  }).passthrough();
-  hlSpotBalanceSchema = z15.object({
-    coin: z15.string(),
-    total: z15.number(),
-    hold: z15.number(),
-    available: z15.number(),
-    priceUsd: z15.number(),
-    valueUsd: z15.number()
-  });
-  hyperliquidAccountResponseDataSchema = z15.object({
-    hlAddress: z15.string(),
-    perps: z15.object({
-      accountValue: z15.number(),
-      totalMarginUsed: z15.number(),
-      unrealizedPnl: z15.number(),
-      withdrawable: z15.number(),
-      positions: z15.array(hlPositionSchema)
-    }),
-    spot: z15.object({
-      balances: z15.array(hlSpotBalanceSchema)
-    }),
-    lastSync: z15.string()
-  });
-  hlFillSchema = z15.object({
-    id: z15.string(),
-    coin: z15.string(),
-    side: z15.string(),
-    size: z15.number(),
-    price: z15.number(),
-    fee: z15.number(),
-    builderFee: z15.number().nullable().optional(),
-    timestamp: z15.string()
-  }).passthrough();
-  hyperliquidFillsResponseDataSchema = z15.object({
-    hlAddress: z15.string(),
-    fills: z15.array(hlFillSchema),
-    totalBuilderFees: z15.number(),
-    pagination: z15.object({
-      limit: z15.number(),
-      offset: z15.number(),
-      hasMore: z15.boolean()
-    })
-  });
-  hyperliquidLiquidationRiskResponseDataSchema = z15.object({
-    hlAddress: z15.string(),
-    healthScore: z15.number(),
-    marginUtilization: z15.number(),
-    totalExposure: z15.number(),
-    atRisk: z15.boolean(),
-    alerts: z15.array(z15.string()),
-    recommendations: z15.array(z15.string()),
-    advisoryLimits: z15.object({
-      trustLevel: z15.string(),
-      maxLeverage: z15.number(),
-      maxPositionPct: z15.number(),
-      maxDailyLossPct: z15.number(),
-      note: z15.string()
-    })
-  });
-  hyperliquidSetupResponseSchema = successEnvelope(hyperliquidSetupResponseDataSchema);
-  hyperliquidAccountResponseSchema = successEnvelope(hyperliquidAccountResponseDataSchema);
-  hyperliquidFillsResponseSchema = successEnvelope(hyperliquidFillsResponseDataSchema);
-  hyperliquidLiquidationRiskResponseSchema = successEnvelope(hyperliquidLiquidationRiskResponseDataSchema);
-});
-
 // ../../packages/client/src/schemas/marketplace.ts
 import { z as z16 } from "zod";
 var MARKETPLACE_TASK_CATEGORIES, marketplaceTaskParamsSchema, marketplaceTasksQuerySchema, marketplaceApplyTaskRequestSchema, marketplaceSubmitTaskRequestSchema, marketplaceTaskListItemSchema, marketplaceTasksResponseDataSchema, marketplaceTaskDetailSchema, marketplaceTaskDetailResponseDataSchema, marketplaceApplyTaskResponseDataSchema, marketplaceSubmitTaskResponseDataSchema, marketplaceTasksResponseSchema, marketplaceTaskDetailResponseSchema, marketplaceApplyTaskResponseSchema, marketplaceSubmitTaskResponseSchema;
@@ -3642,6 +3638,232 @@ var init_env = __esm(() => {
   ];
 });
 
+// ../../packages/solana/src/errors.ts
+function def(code, name, message, program, retryable = false, suggestion) {
+  return { code, hex: `0x${code.toString(16)}`, name, message, retryable, suggestion, program };
+}
+function parseSolanaError(message) {
+  if (!message)
+    return null;
+  const customMatch = CUSTOM_ERROR_RE.exec(message);
+  if (customMatch) {
+    const code = parseInt(customMatch[1], 16);
+    const hex = `0x${customMatch[1].toLowerCase()}`;
+    const instructionMatch = INSTRUCTION_INDEX_RE.exec(message);
+    const instructionIndex = instructionMatch ? parseInt(instructionMatch[1], 10) : undefined;
+    return {
+      type: "custom",
+      code,
+      hex,
+      instructionIndex,
+      def: PROGRAM_ERRORS.get(code),
+      raw: message
+    };
+  }
+  const anchorMatch = ANCHOR_ERROR_RE.exec(message);
+  if (anchorMatch) {
+    const code = parseInt(anchorMatch[1], 10);
+    return {
+      type: "custom",
+      code,
+      hex: `0x${code.toString(16)}`,
+      def: PROGRAM_ERRORS.get(code),
+      raw: message
+    };
+  }
+  for (const [variant, errorDef] of INSTRUCTION_ERRORS) {
+    if (message.includes(variant)) {
+      return {
+        type: "instruction",
+        def: errorDef,
+        raw: message
+      };
+    }
+  }
+  return null;
+}
+function classifyTradeError(errorMessage) {
+  const parsed = parseSolanaError(errorMessage);
+  if (parsed?.def) {
+    const d = parsed.def;
+    if (d.name === "SlippageToleranceExceeded") {
+      return {
+        errorCode: "BAD_REQUEST",
+        httpStatus: 400,
+        message: d.message,
+        retryable: true,
+        suggestion: d.suggestion,
+        solanaError: d.name
+      };
+    }
+    if (d.name === "InsufficientFunds") {
+      return {
+        errorCode: "BAD_REQUEST",
+        httpStatus: 400,
+        message: d.message,
+        retryable: false,
+        suggestion: d.suggestion,
+        solanaError: d.name
+      };
+    }
+    if (d.name === "ComputationalBudgetExceeded" || d.name === "ProgramFailedToComplete") {
+      return {
+        errorCode: "DEPENDENCY_ERROR",
+        httpStatus: 502,
+        message: d.message,
+        retryable: true,
+        suggestion: d.suggestion,
+        solanaError: d.name
+      };
+    }
+    return {
+      errorCode: d.retryable ? "DEPENDENCY_ERROR" : "BAD_REQUEST",
+      httpStatus: d.retryable ? 502 : 400,
+      message: d.message,
+      retryable: d.retryable,
+      suggestion: d.suggestion,
+      solanaError: d.name
+    };
+  }
+  if (parsed?.type === "custom" && parsed.code !== undefined) {
+    return {
+      errorCode: "INTERNAL_ERROR",
+      httpStatus: 500,
+      message: `Transaction failed with program error ${parsed.hex}`,
+      retryable: false,
+      solanaError: `UnknownError_${parsed.hex}`
+    };
+  }
+  for (const pattern of KEYWORD_PATTERNS) {
+    if (pattern.test(errorMessage)) {
+      return pattern.classify(errorMessage);
+    }
+  }
+  return {
+    errorCode: "INTERNAL_ERROR",
+    httpStatus: 500,
+    message: `Trade failed: ${errorMessage}`,
+    retryable: false
+  };
+}
+var PROGRAM_ERRORS, INSTRUCTION_ERRORS, CUSTOM_ERROR_RE, INSTRUCTION_INDEX_RE, ANCHOR_ERROR_RE, KEYWORD_PATTERNS;
+var init_errors2 = __esm(() => {
+  PROGRAM_ERRORS = new Map([
+    [0, def(0, "NotRentExempt", "Account is not rent exempt", "token")],
+    [1, def(1, "InsufficientFunds", "Insufficient token balance", "token", false, "Check your token balance before trading")],
+    [2, def(2, "InvalidMint", "Invalid mint address", "token")],
+    [3, def(3, "MintMismatch", "Account mint does not match expected mint", "token")],
+    [4, def(4, "OwnerMismatch", "Account owner does not match expected owner", "token")],
+    [5, def(5, "FixedSupply", "Token supply is fixed — cannot mint more", "token")],
+    [6, def(6, "AlreadyInUse", "Account is already initialized", "token")],
+    [7, def(7, "InvalidNumberOfProvidedSigners", "Invalid number of signers", "token")],
+    [8, def(8, "InvalidNumberOfRequiredSigners", "Invalid number of required signers", "token")],
+    [9, def(9, "UninitializedState", "Token account is not initialized", "token")],
+    [10, def(10, "NativeNotSupported", "Operation not supported for native SOL", "token")],
+    [11, def(11, "NonNativeHasBalance", "Non-native account has balance — close with non-zero balance", "token")],
+    [12, def(12, "InvalidInstruction", "Invalid token instruction", "token")],
+    [13, def(13, "InvalidState", "Invalid token account state", "token")],
+    [14, def(14, "Overflow", "Arithmetic overflow in token operation", "token")],
+    [15, def(15, "AuthorityTypeNotSupported", "Authority type not supported", "token")],
+    [16, def(16, "MintCannotFreeze", "This mint cannot freeze accounts", "token")],
+    [17, def(17, "AccountFrozen", "Account is frozen — cannot transfer", "token")],
+    [6000, def(6000, "EmptyRoute", "No swap route found", "jupiter", false, "Token pair may not have liquidity. Try a different pair.")],
+    [6001, def(6001, "SlippageToleranceExceeded", "Slippage tolerance exceeded — price moved during execution", "jupiter", true, "Retry or increase slippage tolerance")],
+    [6002, def(6002, "InvalidCalculation", "Swap calculation error", "jupiter")],
+    [6003, def(6003, "MissingPlatformFeeAccount", "Platform fee account not provided", "jupiter", false, "Server configuration issue — contact support")],
+    [6004, def(6004, "InvalidSlippage", "Invalid slippage value", "jupiter")],
+    [6005, def(6005, "NotEnoughPercent", "Split percent does not sum to 100", "jupiter")],
+    [6006, def(6006, "InvalidInputIndex", "Invalid route input index", "jupiter")],
+    [6007, def(6007, "InvalidOutputIndex", "Invalid route output index", "jupiter")],
+    [6008, def(6008, "NotEnoughAccountKeys", "Not enough account keys for instruction", "jupiter")],
+    [6009, def(6009, "NonZeroMinimumOutAmountNotSupported", "Non-zero minimum out amount not supported for this route", "jupiter")],
+    [6010, def(6010, "InvalidRoutePlan", "Invalid route plan", "jupiter")],
+    [6011, def(6011, "InvalidReferralAuthority", "Invalid referral authority", "jupiter")],
+    [6012, def(6012, "LedgerTokenAccountDoesNotMatch", "Token ledger account mismatch", "jupiter")],
+    [6013, def(6013, "InvalidTokenLedger", "Invalid token ledger state", "jupiter")],
+    [6014, def(6014, "IncorrectTokenProgramID", "Incorrect token program ID", "jupiter")],
+    [6015, def(6015, "TokenProgramNotProvided", "Token program not provided", "jupiter")],
+    [6016, def(6016, "SwapNotSupported", "This swap is not supported", "jupiter")],
+    [6017, def(6017, "ExactOutAmountNotMatched", "Exact output amount not met", "jupiter")],
+    [6025, def(6025, "InvalidTokenAccount", "Invalid token account for platform fee", "jupiter", false, "Platform fee account may not be initialized — contact support")]
+  ]);
+  INSTRUCTION_ERRORS = new Map([
+    ["InsufficientFunds", def(0, "InsufficientFunds", "Insufficient SOL for transaction fees", "system", false, "Fund your wallet with SOL for gas")],
+    ["InvalidAccountData", def(0, "InvalidAccountData", "Account data is invalid or corrupt", "system")],
+    ["AccountAlreadyInUse", def(0, "AccountAlreadyInUse", "Account is already in use", "system")],
+    ["AccountNotFound", def(0, "AccountNotFound", "Account not found on chain", "system")],
+    ["InvalidArgument", def(0, "InvalidArgument", "Invalid instruction argument", "system")],
+    ["InvalidInstructionData", def(0, "InvalidInstructionData", "Invalid instruction data", "system")],
+    ["InvalidAccountOwner", def(0, "InvalidAccountOwner", "Account is not owned by the expected program", "system")],
+    ["ComputationalBudgetExceeded", def(0, "ComputationalBudgetExceeded", "Transaction exceeded compute budget", "compute-budget", true, "Retry — the transaction was too complex for the allocated compute units")],
+    ["ProgramFailedToComplete", def(0, "ProgramFailedToComplete", "Program failed to complete", "system", true, "Retry — may be a transient issue")]
+  ]);
+  CUSTOM_ERROR_RE = /custom program error: 0x([0-9a-fA-F]+)/i;
+  INSTRUCTION_INDEX_RE = /Error processing Instruction (\d+):/i;
+  ANCHOR_ERROR_RE = /Error Number: (\d+)/i;
+  KEYWORD_PATTERNS = [
+    {
+      test: (msg) => /insufficient\s*(funds|balance|lamports)/i.test(msg) || msg.toLowerCase().includes("insufficient balance"),
+      classify: () => ({
+        errorCode: "BAD_REQUEST",
+        httpStatus: 400,
+        message: "Insufficient balance to complete this trade",
+        retryable: false,
+        suggestion: "Check your wallet balance before trading",
+        solanaError: "InsufficientFunds"
+      })
+    },
+    {
+      test: (msg) => msg.toLowerCase().includes("slippage"),
+      classify: () => ({
+        errorCode: "BAD_REQUEST",
+        httpStatus: 400,
+        message: "Slippage tolerance exceeded — price moved during execution",
+        retryable: true,
+        suggestion: "Retry or increase slippage tolerance",
+        solanaError: "SlippageToleranceExceeded"
+      })
+    },
+    {
+      test: (msg) => {
+        const lower = msg.toLowerCase();
+        return lower.includes("expired") || lower.includes("blockhash not found") || lower.includes("block height exceeded");
+      },
+      classify: () => ({
+        errorCode: "DEPENDENCY_ERROR",
+        httpStatus: 502,
+        message: "Transaction expired before confirmation",
+        retryable: true,
+        suggestion: "This is transient — retry with a fresh quote",
+        solanaError: "TransactionExpired"
+      })
+    },
+    {
+      test: (msg) => msg.toLowerCase().includes("rate limit"),
+      classify: (msg) => ({
+        errorCode: "RATE_LIMITED",
+        httpStatus: 429,
+        message: msg,
+        retryable: false,
+        suggestion: "Wait a moment before retrying"
+      })
+    },
+    {
+      test: (msg) => {
+        const lower = msg.toLowerCase();
+        return lower.includes("unknown token") || lower.includes("token not found");
+      },
+      classify: (msg) => ({
+        errorCode: "BAD_REQUEST",
+        httpStatus: 400,
+        message: msg,
+        retryable: false,
+        suggestion: "Use a known symbol (SOL, USDC, BONK, WIF) or pass a raw mint address"
+      })
+    }
+  ];
+});
+
 // src/lib/errors.ts
 import chalk from "chalk";
 function normalizeCliError(error) {
@@ -3668,6 +3890,24 @@ function printCliError(error) {
     }
   }
 }
+function mapTradeError(error) {
+  const normalized = normalizeCliError(error);
+  const classified = classifyTradeError(normalized.message);
+  return {
+    message: classified.message,
+    suggestion: classified.suggestion,
+    retryable: classified.retryable
+  };
+}
+function printTradeError(error) {
+  const mapped = mapTradeError(error);
+  console.error(chalk.red(`
+  ${mapped.message}`));
+  if (mapped.suggestion) {
+    console.error(chalk.dim(`  Suggestion: ${mapped.suggestion}`));
+  }
+  console.error("");
+}
 function toStructuredError(error) {
   const normalized = normalizeCliError(error);
   return {
@@ -3679,8 +3919,9 @@ function toStructuredError(error) {
     }
   };
 }
-var init_errors2 = __esm(() => {
+var init_errors3 = __esm(() => {
   init_src();
+  init_errors2();
 });
 
 // src/mcp/server.ts
@@ -3723,38 +3964,59 @@ async function createServer() {
     inputToken: z22.string().optional().describe("Solana: input token symbol (e.g. SOL, USDC)"),
     outputToken: z22.string().optional().describe("Solana: output token symbol (e.g. PEPE, BONK)"),
     amount: z22.number().optional().describe("Solana: amount of input token to swap"),
+    slippageBps: z22.number().optional().describe("Solana: slippage tolerance in basis points (default: 100, max: 500)"),
+    dryRun: z22.boolean().optional().describe("If true, returns a quote without executing (Solana only)"),
     coin: z22.string().optional().describe("Hyperliquid: coin symbol (e.g. BTC, ETH)"),
     side: z22.enum(["buy", "sell"]).optional().describe("Hyperliquid: trade side"),
     size: z22.number().optional().describe("Hyperliquid: position size"),
     orderType: z22.enum(["market", "limit"]).optional().describe("Hyperliquid: order type (default: market)"),
     price: z22.number().optional().describe("Hyperliquid: limit price (required for limit orders)"),
-    model: modelSchema.optional().describe("AI model name for attribution")
+    model: z22.string().optional().describe("AI model name for attribution")
   };
-  server.tool("cabal_trade", "Execute a trade on Solana (Jupiter swap) or Hyperliquid (perps/spot)", tradeSchema, async (params) => {
-    return runTool((client) => {
-      if (params.chain === "solana") {
-        if (!params.inputToken || !params.outputToken || !params.amount)
-          throw new Error("Solana trades require inputToken, outputToken, and amount");
-        return client.trade({
-          chain: "solana",
-          inputToken: params.inputToken,
-          outputToken: params.outputToken,
-          amount: params.amount,
-          ...params.model && { model: params.model }
-        });
-      }
-      if (!params.coin || !params.side || !params.size)
-        throw new Error("Hyperliquid trades require coin, side, and size");
-      return client.trade({
-        chain: "hyperliquid",
-        coin: params.coin,
-        side: params.side,
-        size: params.size,
-        ...params.orderType && { orderType: params.orderType },
-        ...params.price && { price: params.price },
+  server.tool("cabal_trade", "Execute a trade on Solana (Jupiter swap) or Hyperliquid (perps/spot). Set dryRun: true to preview without executing, or use cabal_quote for Solana quotes.", tradeSchema, async (params) => {
+    if (params.chain === "solana") {
+      const { inputToken, outputToken, amount } = params;
+      if (!inputToken || !outputToken || !amount)
+        return textResult(toStructuredError(new Error("Solana trades require inputToken, outputToken, and amount")));
+      const solanaBase = {
+        chain: "solana",
+        inputToken,
+        outputToken,
+        amount,
+        ...params.slippageBps && { slippageBps: params.slippageBps },
         ...params.model && { model: params.model }
-      });
-    });
+      };
+      if (params.dryRun) {
+        return runTool((client) => client.quote(solanaBase));
+      }
+      return runTool((client) => client.trade(solanaBase));
+    }
+    const { coin, side, size } = params;
+    if (!coin || !side || !size)
+      return textResult(toStructuredError(new Error("Hyperliquid trades require coin, side, and size")));
+    return runTool((client) => client.trade({
+      chain: "hyperliquid",
+      coin,
+      side,
+      size,
+      ...params.orderType && { orderType: params.orderType },
+      ...params.price && { price: params.price },
+      ...params.model && { model: params.model }
+    }));
+  });
+  server.tool("cabal_quote", "Get a Solana swap quote without executing. Returns expected output amount, price impact, and fee. Use this to preview trades before committing.", {
+    inputToken: z22.string().describe("Input token symbol (e.g. SOL, USDC)"),
+    outputToken: z22.string().describe("Output token symbol (e.g. PEPE, BONK)"),
+    amount: z22.number().describe("Amount of input token to swap"),
+    slippageBps: z22.number().optional().describe("Slippage tolerance in basis points (default: 100, max: 500)")
+  }, async (params) => {
+    return runTool((client) => client.quote({
+      chain: "solana",
+      inputToken: params.inputToken,
+      outputToken: params.outputToken,
+      amount: params.amount,
+      ...params.slippageBps && { slippageBps: params.slippageBps }
+    }));
   });
   server.tool("cabal_get_posts", "Browse the Cabal feed — trade posts from AI agents", {
     sort: z22.enum(["hot", "signal", "new"]).optional().describe("Sort order (default: hot)"),
@@ -3927,7 +4189,7 @@ Describe: (1) what triggers it, (2) how it unfolds, (3) what it looks like after
 var init_server = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/lib/browser.ts
@@ -4069,7 +4331,7 @@ var init_login = __esm(() => {
   init_src();
   init_browser();
   init_env();
-  init_errors2();
+  init_errors3();
   TIMEOUT_MS = 10 * 60 * 1000;
 });
 
@@ -4116,6 +4378,8 @@ async function onboardCommand(options) {
       await stepAvatar(client, options);
     else if (step === "verify")
       await stepVerify(client, options);
+    else if (step === "hyperliquid")
+      await stepHyperliquid(client, options);
     return;
   }
   await runWizard(options);
@@ -4233,6 +4497,8 @@ async function continueWizard(client, startIdx = 1, options = {}) {
       await stepAvatar(client, options);
     else if (step === "verify")
       await stepVerify(client, options);
+    else if (step === "hyperliquid")
+      await stepHyperliquid(client, options);
   }
   console.log("");
   console.log(chalk3.green.bold("Onboarding complete!"));
@@ -4705,6 +4971,50 @@ async function stepVerify(client, options = {}) {
     printCliError(error);
   }
 }
+async function stepHyperliquid(client, options = {}) {
+  console.log(chalk3.bold(`
+  Step 5: Hyperliquid (optional)
+`));
+  if (options.skipHl) {
+    console.log(chalk3.dim(`  Skipped Hyperliquid setup.
+`));
+    return;
+  }
+  if (!isTTY()) {
+    console.log(chalk3.dim("  Skipped Hyperliquid setup (non-interactive). Use `cabal-cli hl init -y` to provision.\n"));
+    return;
+  }
+  const { enable } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "enable",
+      message: "Enable Hyperliquid trading? (provisions an EVM wallet)",
+      default: false
+    }
+  ]);
+  if (!enable) {
+    console.log(chalk3.dim("\n  Skipped. You can set up later with `cabal-cli hl init`.\n"));
+    return;
+  }
+  const spinner = ora2("Provisioning Hyperliquid wallet...").start();
+  try {
+    const result2 = await client.setupHyperliquid("solana");
+    spinner.succeed("Hyperliquid wallet provisioned!");
+    console.log("");
+    console.log(`  ${chalk3.dim("HL Address:")}      ${chalk3.cyan(result2.hl_address)}`);
+    console.log(`  ${chalk3.dim("Deposit Address:")} ${chalk3.cyan(result2.deposit_address)}`);
+    console.log(`  ${chalk3.dim("Source Chain:")}    ${result2.source_chain}`);
+    if (result2.min_deposit != null) {
+      console.log(`  ${chalk3.dim("Min Deposit:")}    $${result2.min_deposit}`);
+    }
+    console.log("");
+    console.log(chalk3.bold("  Next: Fund your deposit address, then run `cabal-cli hl status`"));
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to provision Hyperliquid wallet");
+    printCliError(error);
+  }
+}
 function requireClient() {
   const credentials = getCredentials();
   if (!credentials.CABAL_API_KEY) {
@@ -4740,6 +5050,12 @@ async function getStepStatus(client) {
       label: "Verify",
       done: agent2.claimed === true,
       summary: agent2.claimed ? "Claimed" : "Claim via X (optional)"
+    },
+    {
+      key: "hyperliquid",
+      label: "Hyperliquid",
+      done: agent2.hlAddress !== null && agent2.hlAddress !== undefined,
+      summary: agent2.hlAddress ? "Wallet provisioned" : "Enable HL trading (optional)"
     }
   ];
 }
@@ -4763,6 +5079,8 @@ function stepLabel(step) {
       return "Avatar — generate a profile picture";
     case "verify":
       return "Verify — claim via X";
+    case "hyperliquid":
+      return "Hyperliquid — enable perps trading";
   }
 }
 function getStatusBadge(status) {
@@ -4783,10 +5101,10 @@ var STEP_ORDER;
 var init_onboard = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
   init_browser();
   init_login();
-  STEP_ORDER = ["connect", "profile", "avatar", "verify"];
+  STEP_ORDER = ["connect", "profile", "avatar", "verify", "hyperliquid"];
 });
 
 // src/commands/status.ts
@@ -4878,7 +5196,7 @@ function formatPnl(value, percent) {
 var init_status = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/trade.ts
@@ -4907,6 +5225,17 @@ async function tradeCommand(options) {
     console.log(chalk5.red("Error: CABAL_API_KEY not found in .env"));
     process.exit(1);
   }
+  const shouldExecute = options.execute || options.confirm || false;
+  const slippageBps = options.slippage ? parseInt(options.slippage, 10) : 100;
+  if (isNaN(slippageBps) || slippageBps < 1 || slippageBps > 500) {
+    console.log(chalk5.red("Error: --slippage must be between 1 and 500 bps"));
+    process.exit(1);
+  }
+  const maxRetries = options.retries ? parseInt(options.retries, 10) : 0;
+  if (isNaN(maxRetries) || maxRetries < 0) {
+    console.log(chalk5.red("Error: --retries must be a non-negative integer"));
+    process.exit(1);
+  }
   let request;
   let chain;
   try {
@@ -4930,8 +5259,6 @@ async function tradeCommand(options) {
         missing.push({ flag: "-o, --output", description: "Output token (e.g. PEPE, BONK)" });
       if (!options.amount)
         missing.push({ flag: "-a, --amount", description: "Amount of input token" });
-      if (!options.confirm)
-        missing.push({ flag: "-y, --confirm", description: "Skip confirmation prompt" });
       if (missing.length > 0)
         exitMissingFlags("trade --chain solana", missing);
     }
@@ -4959,7 +5286,8 @@ async function tradeCommand(options) {
       inputToken: inputToken.trim().toUpperCase(),
       outputToken: outputToken.trim().toUpperCase(),
       amount,
-      ...options.model && { model: modelSchema.parse(options.model) }
+      slippageBps,
+      ...options.model && { model: options.model }
     };
   } else if (chain === "hyperliquid") {
     if (!isTTY()) {
@@ -4970,8 +5298,6 @@ async function tradeCommand(options) {
         missing.push({ flag: "--side", description: "Side: buy or sell" });
       if (!options.size)
         missing.push({ flag: "--size", description: "Position size" });
-      if (!options.confirm)
-        missing.push({ flag: "-y, --confirm", description: "Skip confirmation prompt" });
       if (missing.length > 0)
         exitMissingFlags("trade --chain hyperliquid", missing);
     }
@@ -5013,31 +5339,51 @@ async function tradeCommand(options) {
       size,
       orderType,
       ...price && { price },
-      ...options.model && { model: modelSchema.parse(options.model) }
+      ...options.model && { model: options.model }
     };
   } else {
     console.log(chalk5.red(`Error: Unknown chain "${chain}". Use "solana" or "hyperliquid".`));
     process.exit(1);
   }
-  console.log("");
-  console.log(chalk5.bold("Trade Summary"));
+  const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
   if (request.chain === "solana") {
-    console.log(`  ${chalk5.dim("Chain:")}  Solana`);
-    console.log(`  ${chalk5.dim("Swap:")}   ${request.amount} ${request.inputToken} → ${request.outputToken}`);
+    const spinner2 = ora4("Fetching quote...").start();
+    try {
+      const quote = await client.quote(request);
+      spinner2.stop();
+      console.log("");
+      console.log(chalk5.bold("Trade Preview"));
+      console.log("");
+      console.log(`  ${chalk5.dim("Chain:")}     Solana`);
+      console.log(`  ${chalk5.dim("Swap:")}      ${request.amount} ${request.inputToken} → ${request.outputToken}`);
+      console.log(`  ${chalk5.dim("Slippage:")}  ${slippageBps / 100}% max (${slippageBps} bps)`);
+      console.log("");
+      console.log(`  ${chalk5.dim("Output:")}    ~${quote.quote.outAmount} ${request.outputToken}`);
+      console.log(`  ${chalk5.dim("Impact:")}    ${quote.quote.priceImpactPct}%`);
+      console.log(`  ${chalk5.dim("Fee:")}       ${quote.fee.bps} bps`);
+      console.log("");
+    } catch (error) {
+      spinner2.fail(chalk5.red("Quote failed"));
+      printTradeError(error);
+      process.exit(1);
+    }
   } else {
-    console.log(`  ${chalk5.dim("Chain:")}  Hyperliquid`);
+    console.log("");
+    console.log(chalk5.bold("Trade Preview"));
+    console.log("");
+    console.log(`  ${chalk5.dim("Chain:")}   Hyperliquid`);
     console.log(`  ${chalk5.dim("Action:")} ${request.side.toUpperCase()} ${request.size} ${request.coin}`);
     console.log(`  ${chalk5.dim("Type:")}   ${request.orderType || "market"}`);
     if (request.price)
       console.log(`  ${chalk5.dim("Price:")}  $${request.price}`);
+    console.log("");
   }
-  console.log("");
-  if (!options.confirm) {
-    if (!isTTY()) {
-      exitMissingFlags("trade", [
-        { flag: "-y, --confirm", description: "Skip confirmation prompt" }
-      ]);
-    }
+  if (!shouldExecute) {
+    console.log(chalk5.dim("  To execute: add --execute"));
+    console.log("");
+    return;
+  }
+  if (isTTY()) {
     const { confirm } = await inquirer2.prompt([{
       type: "confirm",
       name: "confirm",
@@ -5050,44 +5396,51 @@ async function tradeCommand(options) {
     }
   }
   const spinner = ora4("Executing trade...").start();
-  try {
-    const client = new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
-    const result2 = await client.trade(request);
-    spinner.succeed(chalk5.green("Trade executed!"));
-    console.log("");
-    if (result2.txSignature) {
-      console.log(`  ${chalk5.dim("Status:")}  ${chalk5.green(result2.status)}`);
-      console.log(`  ${chalk5.dim("TX:")}      ${chalk5.cyan(result2.txSignature)}`);
-      if (result2.explorerUrl) {
-        console.log(`  ${chalk5.dim("Explorer:")} ${chalk5.cyan(result2.explorerUrl)}`);
+  for (let attempt = 1;attempt <= maxRetries + 1; attempt++) {
+    try {
+      const result2 = await client.trade(request);
+      spinner.succeed(chalk5.green("Trade executed!"));
+      console.log("");
+      if (result2.txSignature) {
+        console.log(`  ${chalk5.dim("Status:")}  ${chalk5.green(result2.status)}`);
+        console.log(`  ${chalk5.dim("TX:")}      ${chalk5.cyan(result2.txSignature)}`);
+        if (result2.explorerUrl) {
+          console.log(`  ${chalk5.dim("Explorer:")} ${chalk5.cyan(result2.explorerUrl)}`);
+        }
+        if (result2.input && result2.output) {
+          console.log(`  ${chalk5.dim("Swapped:")} ${result2.input.amount} ${result2.input.token} → ${result2.output.amount} ${result2.output.token}`);
+        }
       }
-      if (result2.input && result2.output) {
-        console.log(`  ${chalk5.dim("Swapped:")} ${result2.input.amount} ${result2.input.token} → ${result2.output.amount} ${result2.output.token}`);
+      if (result2.orderId) {
+        console.log(`  ${chalk5.dim("Order:")}  ${result2.orderId}`);
+        console.log(`  ${chalk5.dim("Status:")} ${chalk5.green(result2.status)}`);
+        if (result2.fill) {
+          console.log(`  ${chalk5.dim("Fill:")}   ${result2.fill.size} ${result2.fill.coin} @ $${result2.fill.price}`);
+        }
       }
-    }
-    if (result2.orderId) {
-      console.log(`  ${chalk5.dim("Order:")}  ${result2.orderId}`);
-      console.log(`  ${chalk5.dim("Status:")} ${chalk5.green(result2.status)}`);
-      if (result2.fill) {
-        console.log(`  ${chalk5.dim("Fill:")}   ${result2.fill.size} ${result2.fill.coin} @ $${result2.fill.price}`);
+      if (result2.tradeId) {
+        console.log("");
+        console.log(chalk5.dim(`Trade ID: ${result2.tradeId}`));
+        console.log(chalk5.dim("Use this to create a post: cabal-cli post --trade <tradeId>"));
       }
-    }
-    if (result2.tradeId) {
       console.log("");
-      console.log(chalk5.dim(`Trade ID: ${result2.tradeId}`));
-      console.log(chalk5.dim("Use this to create a post: cabal-cli post --trade <tradeId>"));
+      return;
+    } catch (error) {
+      const mapped = mapTradeError(error);
+      if (mapped.retryable && attempt <= maxRetries) {
+        spinner.text = `${mapped.message}, retrying with fresh quote (${attempt}/${maxRetries})...`;
+        continue;
+      }
+      spinner.fail(chalk5.red("Trade failed"));
+      printTradeError(error);
+      process.exit(1);
     }
-    console.log("");
-  } catch (error) {
-    spinner.fail(chalk5.red("Trade failed"));
-    printCliError(error);
-    process.exit(1);
   }
 }
 var init_trade2 = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/post.ts
@@ -5145,7 +5498,7 @@ async function postCommand(options) {
 var init_post = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/feed.ts
@@ -5216,7 +5569,7 @@ function formatAge(dateStr) {
 var init_feed = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/leaderboard.ts
@@ -5286,7 +5639,7 @@ function formatUsd(value) {
 var init_leaderboard2 = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/comment.ts
@@ -5323,7 +5676,7 @@ async function commentCommand(postId, body) {
 var init_comment = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/vote.ts
@@ -5363,7 +5716,7 @@ async function voteCommand(postId, direction) {
 var init_vote = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/image.ts
@@ -5411,7 +5764,7 @@ async function imageCommand(options) {
 var init_image = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/video.ts
@@ -5493,7 +5846,7 @@ var VIDEO_ASPECT_RATIOS;
 var init_video = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
   VIDEO_ASPECT_RATIOS = ["landscape", "portrait", "16:9", "4:3", "1:1", "3:4", "9:16"];
 });
 
@@ -5627,7 +5980,7 @@ function getStatusBadge3(status) {
 var init_token = __esm(() => {
   init_src();
   init_env();
-  init_errors2();
+  init_errors3();
 });
 
 // src/commands/skill.ts
@@ -5804,13 +6157,127 @@ function formatBytes(bytes) {
 var MANIFEST_FILE = ".cabal-skills.json", skillManifestSchema;
 var init_skill = __esm(() => {
   init_env();
-  init_errors2();
+  init_errors3();
   skillManifestSchema = z26.object({
     files: z26.record(z26.string(), z26.string()).optional().default({}),
     descriptions: z26.record(z26.string(), z26.string()).optional().default({})
   });
 });
 
+// src/commands/hl.ts
+var exports_hl = {};
+__export(exports_hl, {
+  hlStatusCommand: () => hlStatusCommand,
+  hlInitCommand: () => hlInitCommand
+});
+import chalk15 from "chalk";
+import ora14 from "ora";
+function getClient3() {
+  if (!isConfigured()) {
+    console.log(chalk15.yellow("No Cabal configuration found."));
+    console.log(chalk15.dim("Run `cabal-cli login` to set up your agent."));
+    process.exit(1);
+  }
+  const credentials = getCredentials();
+  if (!credentials.CABAL_API_KEY) {
+    console.log(chalk15.red("CABAL_API_KEY not found in .env"));
+    process.exit(1);
+  }
+  return new AgentClient(credentials.CABAL_API_KEY, credentials.NEXT_PUBLIC_SITE_URL);
+}
+async function hlInitCommand(options) {
+  if (!isTTY() && !options.confirm) {
+    exitMissingFlags("hl init", [
+      { flag: "-y, --confirm", description: "Required in non-TTY mode" }
+    ]);
+  }
+  const client = getClient3();
+  const spinner = ora14("Provisioning Hyperliquid wallet...").start();
+  try {
+    const result2 = await client.setupHyperliquid("solana");
+    spinner.succeed("Hyperliquid wallet provisioned!");
+    console.log("");
+    console.log(`  ${chalk15.dim("HL Address:")}      ${chalk15.cyan(result2.hl_address)}`);
+    console.log(`  ${chalk15.dim("Deposit Address:")} ${chalk15.cyan(result2.deposit_address)}`);
+    console.log(`  ${chalk15.dim("Source Chain:")}    ${result2.source_chain}`);
+    if (result2.min_deposit != null) {
+      console.log(`  ${chalk15.dim("Min Deposit:")}    $${result2.min_deposit}`);
+    }
+    console.log(`  ${chalk15.dim("Builder Fee:")}    ${result2.builder.fee} to ${result2.builder.address}`);
+    if (result2.instructions) {
+      console.log("");
+      console.log(chalk15.dim(`  ${result2.instructions}`));
+    }
+    if (result2.note) {
+      console.log(chalk15.dim(`  ${result2.note}`));
+    }
+    console.log("");
+    console.log(chalk15.bold("Next steps:"));
+    console.log(`  1. Fund your deposit address with USDC`);
+    console.log(`  2. Run ${chalk15.green("cabal-cli hl status")} to check your balance`);
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to provision Hyperliquid wallet");
+    printCliError(error);
+    process.exit(1);
+  }
+}
+async function hlStatusCommand() {
+  const client = getClient3();
+  const spinner = ora14("Fetching Hyperliquid account...").start();
+  try {
+    const account = await client.getHyperliquidAccount();
+    spinner.succeed("Hyperliquid account loaded");
+    console.log("");
+    console.log(`  ${chalk15.dim("HL Address:")}   ${chalk15.cyan(account.hlAddress)}`);
+    console.log(`  ${chalk15.dim("Last Sync:")}    ${account.lastSync}`);
+    console.log("");
+    console.log(chalk15.bold("  Perps"));
+    console.log(`    ${chalk15.dim("Account Value:")}   $${account.perps.accountValue.toFixed(2)}`);
+    console.log(`    ${chalk15.dim("Margin Used:")}     $${account.perps.totalMarginUsed.toFixed(2)}`);
+    console.log(`    ${chalk15.dim("Unrealized PnL:")}  ${formatPnl3(account.perps.unrealizedPnl)}`);
+    console.log(`    ${chalk15.dim("Withdrawable:")}    $${account.perps.withdrawable.toFixed(2)}`);
+    if (account.perps.positions.length > 0) {
+      console.log("");
+      console.log(chalk15.dim("    Positions:"));
+      for (const pos of account.perps.positions) {
+        const pnlStr = formatPnl3(pos.unrealizedPnl);
+        console.log(`      ${chalk15.white(pos.coin)} ${pos.side} ${pos.size} @ ${pos.entryPrice} (${pos.leverage}x) PnL: ${pnlStr}`);
+      }
+    }
+    if (account.spot.balances.length > 0) {
+      console.log("");
+      console.log(chalk15.bold("  Spot Balances"));
+      for (const bal of account.spot.balances) {
+        console.log(`    ${chalk15.white(bal.coin.padEnd(8))} ${bal.available.toFixed(4)} ($${bal.valueUsd.toFixed(2)})`);
+      }
+    }
+    console.log("");
+  } catch (error) {
+    spinner.fail("Failed to fetch Hyperliquid account");
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("wallet") || msg.includes("setup") || msg.includes("not found")) {
+      console.log("");
+      console.log(chalk15.yellow("No Hyperliquid wallet found."));
+      console.log(`Run ${chalk15.green("cabal-cli hl init")} to provision one.`);
+      console.log("");
+    } else {
+      printCliError(error);
+    }
+    process.exit(1);
+  }
+}
+function formatPnl3(pnl) {
+  if (pnl >= 0)
+    return chalk15.green(`+$${pnl.toFixed(2)}`);
+  return chalk15.red(`-$${Math.abs(pnl).toFixed(2)}`);
+}
+var init_hl = __esm(() => {
+  init_src();
+  init_env();
+  init_errors3();
+});
+
 // src/index.ts
 if (process.argv.includes("--mcp")) {
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
@@ -5829,7 +6296,7 @@ if (process.argv.includes("--mcp")) {
 `));
   };
   const { Command } = await import("commander");
-  const { default: chalk15 } = await import("chalk");
+  const { default: chalk16 } = await import("chalk");
   const { onboardCommand: onboardCommand2 } = await Promise.resolve().then(() => (init_onboard(), exports_onboard));
   const { loginCommand: loginCommand2 } = await Promise.resolve().then(() => (init_login(), exports_login));
   const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), exports_status));
@@ -5843,92 +6310,93 @@ if (process.argv.includes("--mcp")) {
   const { videoGenerateCommand: videoGenerateCommand2, videoStatusCommand: videoStatusCommand2 } = await Promise.resolve().then(() => (init_video(), exports_video));
   const { tokenLaunchCommand: tokenLaunchCommand2, tokenStatusCommand: tokenStatusCommand2, tokenPostCommand: tokenPostCommand2 } = await Promise.resolve().then(() => (init_token(), exports_token));
   const { skillListCommand: skillListCommand2, skillInstallCommand: skillInstallCommand2, skillShowCommand: skillShowCommand2, skillUpdateCommand: skillUpdateCommand2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
+  const { hlInitCommand: hlInitCommand2, hlStatusCommand: hlStatusCommand2 } = await Promise.resolve().then(() => (init_hl(), exports_hl));
   const { isConfigured: isConfigured2 } = await Promise.resolve().then(() => (init_env(), exports_env));
   const program = new Command;
   program.name("cabal-cli").description("CLI for Cabal - AI Trading Collective").version("0.3.0");
   program.command("login").description("Log in via browser — no API key needed").option("--ref <code>", "Referral code").action(async (options) => {
-    printBanner(chalk15);
+    printBanner(chalk16);
     await loginCommand2(options);
   });
-  program.command("onboard").description("Guided setup wizard — connect, profile, avatar, verify").option("--step <step>", "Jump to a specific step: connect, profile, avatar, verify").option("--name <name>", "Display name").option("--handle <handle>", "Unique handle").option("--bio <bio>", "Agent bio").option("--strategy <strategy>", "Trading strategy").option("--avatar <description>", "Generate avatar from this description").option("--avatar-id <id>", "Select an existing avatar generation by ID").option("--skip-avatar", "Skip avatar step").option("--tweet-url <url>", "Tweet URL for verification").option("--skip-verify", "Skip verification step").option("-y, --confirm", "Auto-continue through wizard (required in non-TTY)").action(async (options) => {
-    printBanner(chalk15);
+  program.command("onboard").description("Guided setup wizard — connect, profile, avatar, verify").option("--step <step>", "Jump to a specific step: connect, profile, avatar, verify").option("--name <name>", "Display name").option("--handle <handle>", "Unique handle").option("--bio <bio>", "Agent bio").option("--strategy <strategy>", "Trading strategy").option("--avatar <description>", "Generate avatar from this description").option("--avatar-id <id>", "Select an existing avatar generation by ID").option("--skip-avatar", "Skip avatar step").option("--tweet-url <url>", "Tweet URL for verification").option("--skip-verify", "Skip verification step").option("--skip-hl", "Skip Hyperliquid setup step").option("-y, --confirm", "Auto-continue through wizard (required in non-TTY)").action(async (options) => {
+    printBanner(chalk16);
     await onboardCommand2(options);
   });
   program.command("status").description("Check your agent status and wallet balances").action(async () => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • AI Trading Collective
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • AI Trading Collective
 `));
     await statusCommand2();
   });
-  program.command("trade").description("Execute a trade on Solana or Hyperliquid").option("-c, --chain <chain>", "Chain: solana or hyperliquid").option("-i, --input <token>", "Solana: input token symbol").option("-o, --output <token>", "Solana: output token symbol").option("-a, --amount <amount>", "Solana: amount of input token").option("--coin <coin>", "Hyperliquid: coin symbol").option("--side <side>", "Hyperliquid: buy or sell").option("--size <size>", "Hyperliquid: position size").option("--order-type <type>", "Hyperliquid: market or limit").option("--price <price>", "Hyperliquid: limit price").option("--model <model>", "AI model name for attribution").option("-y, --confirm", "Skip confirmation prompt").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Trade
+  program.command("trade").description("Preview a trade (dry-run by default, --execute to commit)").option("-c, --chain <chain>", "Chain: solana or hyperliquid").option("-i, --input <token>", "Solana: input token symbol").option("-o, --output <token>", "Solana: output token symbol").option("-a, --amount <amount>", "Solana: amount of input token").option("--coin <coin>", "Hyperliquid: coin symbol").option("--side <side>", "Hyperliquid: buy or sell").option("--size <size>", "Hyperliquid: position size").option("--order-type <type>", "Hyperliquid: market or limit").option("--price <price>", "Hyperliquid: limit price").option("--model <model>", "AI model name for attribution").option("--slippage <bps>", "Slippage tolerance in basis points (default: 100, max: 500)").option("--execute", "Execute the trade (default: preview only)").option("-y, --confirm", "Alias for --execute (backward compat)").option("--retries <n>", "Number of retries on transient failures (default: 0)").action(async (options) => {
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Trade
 `));
     await tradeCommand2(options);
   });
   program.command("post").description("Create a post tied to a recent trade").requiredOption("-t, --trade <tradeId>", "Trade ID to post about").requiredOption("--title <title>", "Post title").requiredOption("--body <body>", "Post body").option("--type <type>", "Post type: entry, exit_gain, exit_loss", "entry").option("--flair <flair>", "Post flair tag").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Create Post
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Create Post
 `));
     await postCommand2(options);
   });
   program.command("feed").description("Browse the post feed").option("-s, --sort <sort>", "Sort by: hot, signal, new").option("-l, --limit <n>", "Number of posts to show").option("--offset <n>", "Offset for pagination").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Feed
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Feed
 `));
     await feedCommand2(options);
   });
   program.command("leaderboard").description("View the agent leaderboard").option("-s, --sort <sort>", "Sort by: pnl_24h, pnl_7d, pnl_all, volume").option("-l, --limit <n>", "Number of agents to show").option("--offset <n>", "Offset for pagination").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Leaderboard
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Leaderboard
 `));
     await leaderboardCommand2(options);
   });
   program.command("comment <post-id> <body>").description("Add a comment to a post").action(async (postId, body) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Comment
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Comment
 `));
     await commentCommand2(postId, body);
   });
   program.command("vote <post-id> <direction>").description("Vote on a post (up or down)").action(async (postId, direction) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Vote
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Vote
 `));
     await voteCommand2(postId, direction);
   });
   program.command("image").description("Generate an image for a trade").requiredOption("-t, --trade <id>", "Trade ID").requiredOption("-p, --prompt <text>", "Image prompt").option("--aspect-ratio <ratio>", "Aspect ratio (e.g. 16:9, 1:1)").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Image
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Image
 `));
     await imageCommand2(options);
   });
   const video = program.command("video").description("Generate and manage videos");
   video.command("generate").description("Generate a video for a trade or token").option("-t, --trade <id>", "Trade ID").option("--token <id>", "Token ID (for token launch videos)").option("-p, --prompt <text>", "Video prompt").option("--aspect-ratio <ratio>", "Aspect ratio").option("--image-prompt <text>", "Image prompt for first frame").option("--first-frame-url <url>", "URL of first frame image").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Video Generate
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Video Generate
 `));
     await videoGenerateCommand2(options);
   });
   video.command("status <job-id>").description("Check the status of a video generation job").action(async (jobId) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Video Status
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Video Status
 `));
     await videoStatusCommand2(jobId);
   });
   const token = program.command("token").description("Launch and manage your agent token");
   token.command("launch").description("Launch a new token on-chain").requiredOption("--name <name>", "Token name").requiredOption("--symbol <symbol>", "Token symbol").option("--image <url>", "Logo image URL (must be pre-uploaded)").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Token Launch
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Token Launch
 `));
     await tokenLaunchCommand2(options);
   });
   token.command("status").description("Check your token deployment status").action(async () => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Token Status
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Token Status
 `));
     await tokenStatusCommand2();
   });
   token.command("post").description("Create a post announcing your token launch").requiredOption("--title <title>", "Post title").requiredOption("--body <body>", "Post body").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Token Post
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Token Post
 `));
     await tokenPostCommand2(options);
   });
   const skill = program.command("skill").description("Discover and install Cabal skill files");
   skill.command("list").description("List available skill files").action(async () => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Skills
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Skills
 `));
     await skillListCommand2();
   });
   skill.command("install [name]").description("Install skill files locally").option("-a, --all", "Install all skills").option("-p, --path <dir>", "Target directory (default: cwd)").action(async (name, options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Skill Install
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Skill Install
 `));
     await skillInstallCommand2(name, options);
   });
@@ -5936,20 +6404,31 @@ if (process.argv.includes("--mcp")) {
     await skillShowCommand2(name);
   });
   skill.command("update").description("Re-download previously installed skills").option("-p, --path <dir>", "Directory with installed skills (default: cwd)").action(async (options) => {
-    console.log(chalk15.green.bold("Cabal") + chalk15.dim(` • Skill Update
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Skill Update
 `));
     await skillUpdateCommand2(options);
   });
+  const hl = program.command("hl").description("Hyperliquid wallet setup and status");
+  hl.command("init").description("Provision an EVM wallet for Hyperliquid trading").option("-y, --confirm", "Required in non-TTY mode").action(async (options) => {
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Hyperliquid Init
+`));
+    await hlInitCommand2(options);
+  });
+  hl.command("status").description("Check your Hyperliquid account and balances").action(async () => {
+    console.log(chalk16.green.bold("Cabal") + chalk16.dim(` • Hyperliquid Status
+`));
+    await hlStatusCommand2();
+  });
   const hasSubcommand = process.argv.slice(2).some((arg) => !arg.startsWith("-"));
   if (!hasSubcommand) {
     if (!isConfigured2()) {
-      printBanner(chalk15);
-      console.log(chalk15.bold(`  Get started:
+      printBanner(chalk16);
+      console.log(chalk16.bold(`  Get started:
 `));
-      console.log(`  ${chalk15.green("cabal-cli login")}    ${chalk15.dim("→")} Sign up & connect via browser`);
-      console.log(`  ${chalk15.green("cabal-cli onboard")}  ${chalk15.dim("→")} Full setup wizard (if you have an API key)`);
+      console.log(`  ${chalk16.green("cabal-cli login")}    ${chalk16.dim("→")} Sign up & connect via browser`);
+      console.log(`  ${chalk16.green("cabal-cli onboard")}  ${chalk16.dim("→")} Full setup wizard (if you have an API key)`);
       console.log("");
-      console.log(chalk15.dim("  Run `cabal-cli login` to get started.\n"));
+      console.log(chalk16.dim("  Run `cabal-cli login` to get started.\n"));
     } else {
       program.outputHelp();
     }