@cabaltrading/cli 0.4.2 → 0.4.4

package/dist/index.js

@@ -642,7 +642,7 @@ 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 SUPPORTED_MODELS, modelSchema, solanaTradeRequestSchema, hyperliquidTradeRequestSchema, tradeRequestSchema, tradeResponseDataSchema, tradeResponseSchema, dryRunResponseDataSchema;
 var init_trade = __esm(() => {
   init_common();
   SUPPORTED_MODELS = [
@@ -712,12 +712,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 +841,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 +1277,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 +1289,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 +1373,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 +1663,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 +1957,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 +2032,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 +2054,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 +2222,7 @@ var init_agent = __esm(() => {
   init_posts();
   init_agents();
   init_trade();
+  init_hyperliquid();
   init_incubator();
   init_groups();
   init_tokens();
@@ -2215,10 +2325,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 +2537,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 +2973,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 +3021,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;
@@ -3652,21 +3673,70 @@ function normalizeCliError(error) {
       issues: error.error.issues
     };
   }
-  if (error instanceof Error) {
-    return { message: error.message };
-  }
-  return { message: "Unknown error" };
+  if (error instanceof Error) {
+    return { message: error.message };
+  }
+  return { message: "Unknown error" };
+}
+function printCliError(error) {
+  const normalized = normalizeCliError(error);
+  const codePrefix = normalized.code ? ` [${normalized.code}]` : "";
+  console.error(chalk.red(`Error${codePrefix}: ${normalized.message}`));
+  if (normalized.issues && normalized.issues.length > 0) {
+    for (const issue of normalized.issues.slice(0, 5)) {
+      const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+      console.error(chalk.dim(`  - ${path2}: ${issue.message} (${issue.code})`));
+    }
+  }
+}
+function mapTradeError(error) {
+  const normalized = normalizeCliError(error);
+  const msg = normalized.message.toLowerCase();
+  if (msg.includes("slippage") || msg.includes("0x1789") || msg.includes("6025")) {
+    return {
+      message: "Slippage exceeded — price moved too much during execution",
+      suggestion: "Retry with higher slippage: --slippage 300",
+      retryable: true
+    };
+  }
+  if (msg.includes("expired") || msg.includes("blockhash")) {
+    return {
+      message: "Transaction expired — took too long to confirm",
+      suggestion: "This is transient. Try again.",
+      retryable: true
+    };
+  }
+  if (msg.includes("insufficient balance") || msg.includes("insufficient funds") || msg.includes("0x1")) {
+    return {
+      message: "Insufficient balance",
+      suggestion: "Check your balance with: cabal-cli status",
+      retryable: false
+    };
+  }
+  if (msg.includes("rate limit")) {
+    return {
+      message: normalized.message,
+      suggestion: "Wait a moment before retrying.",
+      retryable: false
+    };
+  }
+  if (msg.includes("unknown token") || msg.includes("token not found")) {
+    return {
+      message: normalized.message,
+      suggestion: "Use a known symbol (SOL, USDC, BONK, WIF) or pass a raw mint address.",
+      retryable: false
+    };
+  }
+  return { message: normalized.message, retryable: false };
 }
-function printCliError(error) {
-  const normalized = normalizeCliError(error);
-  const codePrefix = normalized.code ? ` [${normalized.code}]` : "";
-  console.error(chalk.red(`Error${codePrefix}: ${normalized.message}`));
-  if (normalized.issues && normalized.issues.length > 0) {
-    for (const issue of normalized.issues.slice(0, 5)) {
-      const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
-      console.error(chalk.dim(`  - ${path2}: ${issue.message} (${issue.code})`));
-    }
+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);
@@ -3723,6 +3793,8 @@ 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"),
@@ -3730,31 +3802,50 @@ async function createServer() {
     price: z22.number().optional().describe("Hyperliquid: limit price (required for limit orders)"),
     model: modelSchema.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)"),
@@ -3872,7 +3963,7 @@ async function createServer() {
       const res = await fetch(`${baseUrl}/skill.json`);
       if (!res.ok)
         throw new Error(`Failed to fetch skill.json: ${res.status}`);
-      const data = await res.json();
+      const data = z22.record(z22.string(), z22.unknown()).parse(await res.json());
       return textResult(data);
     } catch (error) {
       return textResult(toStructuredError(error));
@@ -3971,15 +4062,14 @@ async function loginCommand(options = {}) {
       body: JSON.stringify(options.ref ? { referralCode: options.ref } : {})
     });
     if (!res.ok) {
-      const data2 = await res.json().catch(() => ({}));
       spinner.fail("Failed to get login code");
-      console.log(chalk2.red(`  ${data2?.error?.message || "Server error"}`));
+      console.log(chalk2.red("  Server error"));
       return false;
     }
-    const { data } = await res.json();
-    deviceCode = data.deviceCode;
-    userCode = data.userCode;
-    verificationUrl = data.verificationUrl;
+    const parsed = deviceCodeCreateResponseSchema.parse(await res.json());
+    deviceCode = parsed.data.deviceCode;
+    userCode = parsed.data.userCode;
+    verificationUrl = parsed.data.verificationUrl;
     spinner.stop();
   } catch (error) {
     spinner.fail("Failed to connect to server");
@@ -4013,7 +4103,8 @@ async function loginCommand(options = {}) {
       const res = await fetch(`${apiBase}/auth/device-code/poll?code=${deviceCode}`);
       if (!res.ok)
         continue;
-      const { data } = await res.json();
+      const parsed = deviceCodePollResponseSchema.parse(await res.json());
+      const data = parsed.data;
       if (data.status === "completed") {
         pollSpinner.succeed(chalk2.green("Logged in!"));
         console.log("");
@@ -4066,12 +4157,28 @@ function sleep(ms) {
 }
 var POLL_INTERVAL_MS = 5000, TIMEOUT_MS;
 var init_login = __esm(() => {
+  init_src();
   init_browser();
   init_env();
   init_errors2();
   TIMEOUT_MS = 10 * 60 * 1000;
 });
 
+// src/lib/tty.ts
+function isTTY() {
+  return !!process.stdin.isTTY;
+}
+function exitMissingFlags(command, missing) {
+  console.error(`Error: this command requires an interactive terminal, or provide these flags:
+`);
+  for (const { flag, description } of missing) {
+    console.error(`  ${flag.padEnd(22)} ${description}`);
+  }
+  console.error(`
+Example: cabal-cli ${command} ${missing.map((f) => f.flag + " <value>").join(" ")}`);
+  process.exit(1);
+}
+
 // src/commands/onboard.ts
 var exports_onboard = {};
 __export(exports_onboard, {
@@ -4090,21 +4197,23 @@ async function onboardCommand(options) {
       process.exit(1);
     }
     if (step === "connect") {
-      await stepConnect();
+      await stepConnect(options);
       return;
     }
     const client = requireClient();
     if (step === "profile")
-      await stepProfile(client);
+      await stepProfile(client, options);
     else if (step === "avatar")
-      await stepAvatar(client);
+      await stepAvatar(client, options);
     else if (step === "verify")
-      await stepVerify(client);
+      await stepVerify(client, options);
+    else if (step === "hyperliquid")
+      await stepHyperliquid(client, options);
     return;
   }
-  await runWizard();
+  await runWizard(options);
 }
-async function runWizard() {
+async function runWizard(options) {
   if (isConfigured()) {
     const client2 = requireClient();
     let steps;
@@ -4113,14 +4222,27 @@ async function runWizard() {
     } catch {
       console.log(chalk3.yellow(`Saved API key is invalid. Starting fresh.
 `));
-      const newClient = await stepConnect();
+      const newClient = await stepConnect(options);
       if (!newClient)
         return;
-      await continueWizard(newClient);
+      await continueWizard(newClient, 1, options);
       return;
     }
     const allDone = steps.every((s) => s.done);
     const firstIncomplete = steps.findIndex((s) => !s.done);
+    if (options.confirm) {
+      if (allDone) {
+        console.log(chalk3.green.bold("All onboarding steps already complete."));
+        return;
+      }
+      await continueWizard(client2, firstIncomplete, options);
+      return;
+    }
+    if (!isTTY()) {
+      exitMissingFlags("onboard", [
+        { flag: "-y, --confirm", description: "Auto-continue through wizard (required in non-TTY)" }
+      ]);
+    }
     printProgress(steps);
     if (allDone) {
       const { action: action2 } = await inquirer.prompt([
@@ -4136,10 +4258,10 @@ async function runWizard() {
       ]);
       if (action2 === "quit")
         return;
-      const newClient = await stepConnect();
+      const newClient = await stepConnect(options);
       if (!newClient)
         return;
-      await continueWizard(newClient);
+      await continueWizard(newClient, 1, options);
       return;
     }
     const { action } = await inquirer.prompt([
@@ -4157,25 +4279,30 @@ async function runWizard() {
     if (action === "quit")
       return;
     if (action === "reconfigure") {
-      const newClient = await stepConnect();
+      const newClient = await stepConnect(options);
       if (!newClient)
         return;
-      await continueWizard(newClient);
+      await continueWizard(newClient, 1, options);
       return;
     }
-    await continueWizard(client2, firstIncomplete);
+    await continueWizard(client2, firstIncomplete, options);
     return;
   }
-  const client = await stepConnect();
+  const client = await stepConnect(options);
   if (!client)
     return;
-  await continueWizard(client);
+  await continueWizard(client, 1, options);
 }
-async function continueWizard(client, startIdx = 1) {
+async function continueWizard(client, startIdx = 1, options = {}) {
   for (let i = startIdx;i < STEP_ORDER.length; i++) {
     const step = STEP_ORDER[i];
     console.log("");
-    if (i > startIdx) {
+    if (i > startIdx && !options.confirm) {
+      if (!isTTY()) {
+        exitMissingFlags("onboard", [
+          { flag: "-y, --confirm", description: "Auto-continue through wizard (required in non-TTY)" }
+        ]);
+      }
       const { action } = await inquirer.prompt([
         {
           type: "list",
@@ -4194,22 +4321,40 @@ async function continueWizard(client, startIdx = 1) {
         continue;
     }
     if (step === "profile")
-      await stepProfile(client);
+      await stepProfile(client, options);
     else if (step === "avatar")
-      await stepAvatar(client);
+      await stepAvatar(client, options);
     else if (step === "verify")
-      await stepVerify(client);
+      await stepVerify(client, options);
+    else if (step === "hyperliquid")
+      await stepHyperliquid(client, options);
   }
   console.log("");
   console.log(chalk3.green.bold("Onboarding complete!"));
   console.log(chalk3.dim("Run `cabal-cli status` to check your agent.\n"));
 }
-async function stepConnect(apiKeyArg) {
+async function stepConnect(options, apiKeyArg) {
   console.log(chalk3.bold(`
   Step 1: Connect
 `));
   let apiKey = apiKeyArg;
   if (!apiKey) {
+    if (isConfigured()) {
+      const creds = getCredentials();
+      if (creds.CABAL_API_KEY) {
+        try {
+          const client = new AgentClient(creds.CABAL_API_KEY, creds.NEXT_PUBLIC_SITE_URL);
+          await client.getStatus();
+          console.log(chalk3.dim(`  Already connected. Using existing API key.
+`));
+          return client;
+        } catch {}
+      }
+    }
+    if (!isTTY()) {
+      console.error("Error: No valid API key found. Run `cabal-cli login` in a terminal first.");
+      process.exit(1);
+    }
     console.log("  To connect your agent, you need an API key.");
     console.log("  If you already have one, paste it below.");
     console.log("");
@@ -4300,7 +4445,7 @@ async function stepConnect(apiKeyArg) {
     return null;
   }
 }
-async function stepProfile(client) {
+async function stepProfile(client, options = {}) {
   console.log(chalk3.bold(`
   Step 2: Profile
 `));
@@ -4315,61 +4460,86 @@ async function stepProfile(client) {
     printCliError(error);
     return;
   }
-  console.log(chalk3.dim(`  Press Enter to keep current values.
+  if (!isTTY()) {
+    const missing = [];
+    if (!options.name)
+      missing.push({ flag: "--name", description: "Display name" });
+    if (!options.handle)
+      missing.push({ flag: "--handle", description: "Unique handle" });
+    if (!options.bio)
+      missing.push({ flag: "--bio", description: "Agent bio" });
+    if (!options.strategy)
+      missing.push({ flag: "--strategy", description: "Trading strategy" });
+    if (missing.length > 0)
+      exitMissingFlags("onboard --step profile", missing);
+  }
+  let name, handle, bio, strategy;
+  if (options.name && options.handle && options.bio && options.strategy) {
+    name = options.name;
+    handle = options.handle;
+    bio = options.bio;
+    strategy = options.strategy;
+  } else {
+    console.log(chalk3.dim(`  Press Enter to keep current values.
 `));
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "name",
-      message: "Display name:",
-      default: agent2.name
-    },
-    {
-      type: "input",
-      name: "handle",
-      message: "Handle (unique):",
-      default: agent2.handle ?? undefined,
-      validate: async (input) => {
-        if (!input)
-          return true;
-        if (!/^[a-zA-Z0-9_-]+$/.test(input))
-          return "Handle must be alphanumeric with _ or -";
-        if (input.length > 120)
-          return "Handle must be 120 characters or fewer";
-        if (input === agent2.handle)
-          return true;
-        try {
-          const result2 = await client.checkHandle(input);
-          if (!result2.available)
-            return result2.reason ?? "Handle is not available";
-          return true;
-        } catch {
-          return "Could not validate handle — try again";
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "name",
+        message: "Display name:",
+        default: options.name ?? agent2.name
+      },
+      {
+        type: "input",
+        name: "handle",
+        message: "Handle (unique):",
+        default: options.handle ?? agent2.handle ?? undefined,
+        validate: async (input) => {
+          if (!input)
+            return true;
+          if (!/^[a-zA-Z0-9_-]+$/.test(input))
+            return "Handle must be alphanumeric with _ or -";
+          if (input.length > 120)
+            return "Handle must be 120 characters or fewer";
+          if (input === agent2.handle)
+            return true;
+          try {
+            const result2 = await client.checkHandle(input);
+            if (!result2.available)
+              return result2.reason ?? "Handle is not available";
+            return true;
+          } catch {
+            return "Could not validate handle — try again";
+          }
         }
+      },
+      {
+        type: "input",
+        name: "bio",
+        message: "Bio:",
+        default: options.bio ?? agent2.bio ?? undefined
+      },
+      {
+        type: "input",
+        name: "strategy",
+        message: "Strategy:",
+        default: options.strategy ?? agent2.strategy ?? undefined
       }
-    },
-    {
-      type: "input",
-      name: "bio",
-      message: "Bio:",
-      default: agent2.bio ?? undefined
-    },
-    {
-      type: "input",
-      name: "strategy",
-      message: "Strategy:",
-      default: agent2.strategy ?? undefined
-    }
-  ]);
+    ]);
+    name = answers.name;
+    handle = answers.handle;
+    bio = answers.bio;
+    strategy = answers.strategy;
+  }
   const updates = {};
-  if (answers.name && answers.name !== agent2.name)
-    updates.name = answers.name;
-  if (answers.handle && answers.handle !== agent2.handle)
-    updates.handle = answers.handle;
-  if (answers.bio && answers.bio !== agent2.bio)
-    updates.bio = answers.bio;
-  if (answers.strategy && answers.strategy !== agent2.strategy)
-    updates.strategy = answers.strategy;
+  if (name && name !== agent2.name)
+    updates.name = name;
+  if (handle && handle !== agent2.handle)
+    updates.handle = handle;
+  if (bio && bio !== agent2.bio)
+    updates.bio = bio;
+  if (strategy && strategy !== agent2.strategy)
+    updates.strategy = strategy;
   if (Object.keys(updates).length === 0) {
     console.log(chalk3.dim(`
   No changes made.
@@ -4386,10 +4556,62 @@ async function stepProfile(client) {
     printCliError(error);
   }
 }
-async function stepAvatar(client) {
+async function stepAvatar(client, options = {}) {
   console.log(chalk3.bold(`
   Step 3: Avatar
 `));
+  if (options.skipAvatar) {
+    console.log(chalk3.dim(`  Skipped avatar step.
+`));
+    return;
+  }
+  if (options.avatarId) {
+    const selectSpinner = ora2("Selecting avatar...").start();
+    try {
+      await client.selectAvatar(options.avatarId);
+      selectSpinner.succeed("Avatar updated!");
+    } catch (error) {
+      selectSpinner.fail("Failed to select avatar");
+      printCliError(error);
+    }
+    console.log("");
+    return;
+  }
+  if (options.avatar) {
+    const genSpinner = ora2("Generating avatar...").start();
+    try {
+      const result2 = await client.generateAvatar(options.avatar);
+      genSpinner.succeed("Avatar generated!");
+      console.log("");
+      if (result2.generationId) {
+        console.log(`  ${chalk3.dim("Generation ID:")} ${result2.generationId}`);
+      }
+      console.log(`  ${chalk3.dim("Image URL:")}     ${chalk3.cyan(result2.imageUrl)}`);
+      console.log(`  ${chalk3.dim("Credits left:")}  ${result2.creditsRemaining}`);
+      if (result2.generationId) {
+        const selectSpinner = ora2("Setting avatar...").start();
+        try {
+          await client.selectAvatar(result2.generationId);
+          selectSpinner.succeed("Avatar set!");
+        } catch (err2) {
+          selectSpinner.fail("Failed to set avatar");
+          printCliError(err2);
+        }
+      }
+    } catch (error) {
+      genSpinner.fail("Failed to generate avatar");
+      printCliError(error);
+    }
+    console.log("");
+    return;
+  }
+  if (!isTTY()) {
+    exitMissingFlags("onboard --step avatar", [
+      { flag: "--avatar", description: "Generate avatar from this description" },
+      { flag: "--avatar-id", description: "Select an existing avatar generation by ID" },
+      { flag: "--skip-avatar", description: "Skip avatar step entirely" }
+    ]);
+  }
   const spinner = ora2("Fetching avatar credits...").start();
   try {
     const credits = await client.getAvatarCredits();
@@ -4504,20 +4726,36 @@ async function stepAvatar(client) {
     printCliError(error);
   }
 }
-async function stepVerify(client) {
+async function stepVerify(client, options = {}) {
   console.log(chalk3.bold(`
   Step 4: Verify (optional)
 `));
-  console.log("  Claim your agent by tweeting a verification post.");
-  console.log(`  ${chalk3.dim("Dashboard:")} ${chalk3.cyan(DASHBOARD_URL)}`);
-  console.log("");
-  const { tweetUrl } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "tweetUrl",
-      message: "Tweet URL (or press Enter to skip):"
-    }
-  ]);
+  if (options.skipVerify) {
+    console.log(chalk3.dim(`  Skipped verification.
+`));
+    return;
+  }
+  let tweetUrl;
+  if (options.tweetUrl) {
+    tweetUrl = options.tweetUrl;
+  } else if (!isTTY()) {
+    exitMissingFlags("onboard --step verify", [
+      { flag: "--tweet-url", description: "Tweet URL for verification" },
+      { flag: "--skip-verify", description: "Skip verification step" }
+    ]);
+  } else {
+    console.log("  Claim your agent by tweeting a verification post.");
+    console.log(`  ${chalk3.dim("Dashboard:")} ${chalk3.cyan(DASHBOARD_URL)}`);
+    console.log("");
+    const answer = await inquirer.prompt([
+      {
+        type: "input",
+        name: "tweetUrl",
+        message: "Tweet URL (or press Enter to skip):"
+      }
+    ]);
+    tweetUrl = answer.tweetUrl;
+  }
   if (!tweetUrl.trim()) {
     console.log(chalk3.dim("\n  Skipped verification. You can verify later with `cabal-cli onboard --step verify`.\n"));
     return;
@@ -4562,6 +4800,50 @@ async function stepVerify(client) {
     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) {
@@ -4597,6 +4879,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)"
     }
   ];
 }
@@ -4620,6 +4908,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) {
@@ -4643,7 +4933,7 @@ var init_onboard = __esm(() => {
   init_errors2();
   init_browser();
   init_login();
-  STEP_ORDER = ["connect", "profile", "avatar", "verify"];
+  STEP_ORDER = ["connect", "profile", "avatar", "verify", "hyperliquid"];
 });
 
 // src/commands/status.ts
@@ -4747,6 +5037,13 @@ import chalk5 from "chalk";
 import ora4 from "ora";
 import inquirer2 from "inquirer";
 import { z as z23 } from "zod";
+async function promptOrFlag(flagValue, promptFn) {
+  if (flagValue !== undefined)
+    return flagValue;
+  if (!isTTY())
+    throw new Error("__missing_flag__");
+  return promptFn();
+}
 async function tradeCommand(options) {
   if (!isConfigured()) {
     console.log(chalk5.red("Error: No API key found. Run `cabal-cli init` first."));
@@ -4757,68 +5054,112 @@ 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;
-  const chain = options.chain || (await inquirer2.prompt([{
-    type: "list",
-    name: "chain",
-    message: "Chain:",
-    choices: ["solana", "hyperliquid"]
-  }])).chain;
+  let chain;
+  try {
+    chain = await promptOrFlag(options.chain, async () => (await inquirer2.prompt([{
+      type: "list",
+      name: "chain",
+      message: "Chain:",
+      choices: ["solana", "hyperliquid"]
+    }])).chain);
+  } catch {
+    exitMissingFlags("trade", [
+      { flag: "-c, --chain", description: "Chain: solana or hyperliquid" }
+    ]);
+  }
   if (chain === "solana") {
-    const inputToken = options.input || (await inquirer2.prompt([{
+    if (!isTTY()) {
+      const missing = [];
+      if (!options.input)
+        missing.push({ flag: "-i, --input", description: "Input token (e.g. SOL, USDC)" });
+      if (!options.output)
+        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 (missing.length > 0)
+        exitMissingFlags("trade --chain solana", missing);
+    }
+    const inputToken = await promptOrFlag(options.input, async () => (await inquirer2.prompt([{
       type: "input",
       name: "value",
       message: "Input token (e.g. SOL, USDC):",
       validate: (v) => v.trim() ? true : "Required"
-    }])).value;
-    const outputToken = options.output || (await inquirer2.prompt([{
+    }])).value);
+    const outputToken = await promptOrFlag(options.output, async () => (await inquirer2.prompt([{
       type: "input",
       name: "value",
       message: "Output token (e.g. PEPE, BONK):",
       validate: (v) => v.trim() ? true : "Required"
-    }])).value;
-    const amount = options.amount ? parseFloat(options.amount) : parseFloat((await inquirer2.prompt([{
+    }])).value);
+    const amountStr = options.amount ?? await promptOrFlag(undefined, async () => (await inquirer2.prompt([{
       type: "input",
       name: "value",
       message: `Amount of ${inputToken} to swap:`,
       validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
     }])).value);
+    const amount = parseFloat(amountStr);
     request = {
       chain: "solana",
       inputToken: inputToken.trim().toUpperCase(),
       outputToken: outputToken.trim().toUpperCase(),
       amount,
+      slippageBps,
       ...options.model && { model: modelSchema.parse(options.model) }
     };
   } else if (chain === "hyperliquid") {
-    const coin = options.coin || (await inquirer2.prompt([{
+    if (!isTTY()) {
+      const missing = [];
+      if (!options.coin)
+        missing.push({ flag: "--coin", description: "Coin symbol (e.g. BTC, ETH)" });
+      if (!options.side)
+        missing.push({ flag: "--side", description: "Side: buy or sell" });
+      if (!options.size)
+        missing.push({ flag: "--size", description: "Position size" });
+      if (missing.length > 0)
+        exitMissingFlags("trade --chain hyperliquid", missing);
+    }
+    const coin = await promptOrFlag(options.coin, async () => (await inquirer2.prompt([{
       type: "input",
       name: "value",
       message: "Coin (e.g. BTC, ETH):",
       validate: (v) => v.trim() ? true : "Required"
-    }])).value;
-    const rawSide = options.side || (await inquirer2.prompt([{
+    }])).value);
+    const rawSide = await promptOrFlag(options.side, async () => (await inquirer2.prompt([{
       type: "list",
       name: "value",
       message: "Side:",
       choices: ["buy", "sell"]
-    }])).value;
+    }])).value);
     const side = z23.enum(["buy", "sell"]).parse(rawSide);
-    const size = options.size ? parseFloat(options.size) : parseFloat((await inquirer2.prompt([{
+    const sizeStr = options.size ?? await promptOrFlag(undefined, async () => (await inquirer2.prompt([{
       type: "input",
       name: "value",
       message: "Size:",
       validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
     }])).value);
+    const size = parseFloat(sizeStr);
     const orderType = z23.enum(["limit", "market"]).parse(options.orderType || "market");
     let price;
     if (orderType === "limit") {
-      price = options.price ? parseFloat(options.price) : parseFloat((await inquirer2.prompt([{
+      const priceStr = options.price ?? await promptOrFlag(undefined, async () => (await inquirer2.prompt([{
         type: "input",
         name: "value",
         message: "Limit price:",
         validate: (v) => parseFloat(v) > 0 ? true : "Must be a positive number"
       }])).value);
+      price = parseFloat(priceStr);
     }
     request = {
       chain: "hyperliquid",
@@ -4833,62 +5174,96 @@ async function tradeCommand(options) {
     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("");
-  const { confirm } = await inquirer2.prompt([{
-    type: "confirm",
-    name: "confirm",
-    message: "Execute this trade?",
-    default: false
-  }]);
-  if (!confirm) {
-    console.log(chalk5.dim("Trade cancelled."));
+  if (!shouldExecute) {
+    console.log(chalk5.dim("  To execute: add --execute"));
+    console.log("");
     return;
   }
+  if (isTTY()) {
+    const { confirm } = await inquirer2.prompt([{
+      type: "confirm",
+      name: "confirm",
+      message: "Execute this trade?",
+      default: false
+    }]);
+    if (!confirm) {
+      console.log(chalk5.dim("Trade cancelled."));
+      return;
+    }
+  }
   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(() => {
@@ -5449,6 +5824,7 @@ import chalk14 from "chalk";
 import ora13 from "ora";
 import fs2 from "fs";
 import path2 from "path";
+import { z as z26 } from "zod";
 function getBaseUrl() {
   const creds = getCredentials();
   return creds.NEXT_PUBLIC_SITE_URL || "https://cabal.trading";
@@ -5459,8 +5835,7 @@ async function fetchSkillJson() {
   if (!res.ok) {
     throw new Error(`Failed to fetch skill manifest: ${res.status} ${res.statusText}`);
   }
-  const data = await res.json();
-  return { files: data.files || {}, descriptions: data.descriptions || {} };
+  return skillManifestSchema.parse(await res.json());
 }
 function readInstalledManifest(dir) {
   const manifestPath = path2.join(dir, MANIFEST_FILE);
@@ -5608,10 +5983,128 @@ function formatBytes(bytes) {
   const kb = bytes / 1024;
   return `${kb.toFixed(1)} KB`;
 }
-var MANIFEST_FILE = ".cabal-skills.json";
+var MANIFEST_FILE = ".cabal-skills.json", skillManifestSchema;
 var init_skill = __esm(() => {
   init_env();
   init_errors2();
+  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_errors2();
 });
 
 // src/index.ts
@@ -5632,7 +6125,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));
@@ -5646,92 +6139,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").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").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);
   });
@@ -5739,20 +6233,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();
     }