Trading System Overview

export async function runTradeWorkflow(account: Account) {
  const queryClient = new QueryClient();

  // Fetch initial data in parallel
  const [portfolio, openPositionsRaw, decisionIndex] = await Promise.all([
    queryClient.fetchQuery(portfolioQuery(account)),
    queryClient.fetchQuery(openPositionsQuery(account)),
    account.id
      ? fetchLatestDecisionIndex(account.id)
      : Promise.resolve(new Map<string, TradingDecisionWithContext>()),
  ]);

  const openPositions = enrichOpenPositions(openPositionsRaw, decisionIndex);
  const exposureSummary = summarizePositionRisk(openPositions);

  // Create invocation record and track it
  const modelInvocation = await createInvocationMutation(account.id);

  // Calculate performance metrics
  const currentPortfolioValue = parseFloat(portfolio.total);
  const performanceMetrics = await calculatePerformanceMetrics(
    account,
    currentPortfolioValue,
  );

  // Build prompts with fresh data
  const enrichedPrompt = buildTradingPrompts({
    account,
    portfolio,
    openPositions,
    exposureSummary,
    performanceMetrics,
    marketIntelligence,
    currentTime,
    variant: variantId,
    symbolActionCounts,
    competition: competitionSnapshot,
  });

  // Create and execute the agent
  const { agent } = createTradeAgent({
    account,
    systemPrompt: enrichedPrompt.systemPrompt,
    toolContext,
    onStepTelemetry: (telemetry) => capturedStepTelemetry.push(telemetry),
    rebuildUserPrompt,
  });

  const result = await executeWithRetry();

  // Update invocation with results
  await updateInvocationMutation({
    id: modelInvocation.id,
    response: responseText,
    responsePayload,
  });

  return responseText;
}

/**
 * Orders table - single source of truth for positions
 *
 * OPEN orders = active positions (shown in Positions tab)
 * CLOSED orders = completed trades (shown in Trades tab)
 *
 * Unrealized P&L is calculated live from current prices, not stored.
 * When an order is closed, exitPrice and realizedPnl are populated.
 */
export const orders = pgTable(
  "Orders",
  {
    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
    modelId: text("modelId")
      .notNull()
      .references(() => models.id),

    // Position details
    symbol: text("symbol").notNull(),
    side: orderSideEnum("side").notNull(), // LONG | SHORT
    quantity: numeric("quantity", { precision: 18, scale: 8 }).notNull(),
    leverage: numeric("leverage", { precision: 10, scale: 2 }),

    // Entry details
    entryPrice: numeric("entryPrice", { precision: 18, scale: 8 }).notNull(),

    // Exit plan (stop-loss, take-profit, confidence in the plan)
    exitPlan: jsonb("exitPlan").$type<{
      stop: number | null;
      target: number | null;
      invalidation: string | null;
      invalidationPrice: number | null;
      confidence: number | null;
      timeExit: string | null;
      cooldownUntil: string | null;
    }>(),

    // Status: OPEN = active position, CLOSED = completed trade
    status: orderStatusEnum("status").notNull().default("OPEN"),

    // Exit details (populated when closed)
    exitPrice: numeric("exitPrice", { precision: 18, scale: 8 }),
    realizedPnl: numeric("realizedPnl", { precision: 18, scale: 2 }),
    closeTrigger: text("closeTrigger"), // null | "STOP" | "TARGET"

    // Lighter exchange order indices for real SL/TP orders
    slOrderIndex: text("slOrderIndex"),
    tpOrderIndex: text("tpOrderIndex"),
    slTriggerPrice: numeric("slTriggerPrice", { precision: 18, scale: 8 }),
    tpTriggerPrice: numeric("tpTriggerPrice", { precision: 18, scale: 8 }),

    // Timestamps
    openedAt: timestamp("openedAt").defaultNow().notNull(),
    closedAt: timestamp("closedAt"),
    updatedAt: timestamp("updatedAt").defaultNow().notNull(),
  },
);

private async restorePositionsFromDb() {
  const openOrders = await getAllOpenOrders();

  for (const order of openOrders) {
    const account = this.getOrCreateAccount(order.modelId);
    const symbol = normalizeSymbol(order.symbol);
    const market = this.markets.get(symbol);
    const markPrice = market?.getMidPrice() ?? parseFloat(order.entryPrice);

    // Restore the position via a synthetic execution
    const quantity = parseFloat(order.quantity);
    const entryPrice = parseFloat(order.entryPrice);
    const leverage = order.leverage ? parseFloat(order.leverage) : 1;
    const side = order.side === "LONG" ? "buy" : "sell";

    account.applyExecution(
      symbol,
      side,
      {
        fills: [{ quantity, price: entryPrice }],
        averagePrice: entryPrice,
        totalQuantity: quantity,
        totalFees: 0,
        status: "filled",
      },
      leverage,
    );

    // Set exit plan if present
    if (order.exitPlan) {
      account.setExitPlan(symbol, order.exitPlan);
    }

    // Update mark price
    account.updateMarkPrice(symbol, markPrice);
  }
}