@tradejs/app 2.0.9 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/app",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "Installable Next.js UI for the TradeJS TypeScript framework: dashboards, backtests, charts, and runtime data.",
   "keywords": [
     "tradejs",
@@ -51,12 +51,12 @@
     "@emotion/react": "^11.14.0",
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/connectors": "^2.0.9",
-    "@tradejs/core": "^2.0.9",
-    "@tradejs/indicators": "^2.0.9",
-    "@tradejs/infra": "^2.0.9",
-    "@tradejs/node": "^2.0.9",
-    "@tradejs/types": "^2.0.9",
+    "@tradejs/connectors": "^2.0.11",
+    "@tradejs/core": "^2.0.11",
+    "@tradejs/indicators": "^2.0.11",
+    "@tradejs/infra": "^2.0.11",
+    "@tradejs/node": "^2.0.11",
+    "@tradejs/types": "^2.0.11",
     "@types/bcryptjs": "2.4.6",
     "@types/lodash": "4.17.24",
     "@types/node": "24.13.3",

package/src/app/api/strategies/runtime/route.ts

@@ -29,10 +29,13 @@ import { getCurrentUserName } from '#app/lib/currentUser';
 import {
   assignLegacyRuntimeTradeAccountScopes,
   buildRuntimeStrategyAnalytics,
+  buildRuntimeStrategyAiGateChanges,
   buildRuntimeStrategyIdentityKey,
   buildExchangeFallbackRuntimeTrades,
   isRuntimeTradeRecord,
+  isRuntimeStrategyLineageScope,
   resolveStrategyConfigIdentityByKey,
+  RuntimeStrategyLineageScope,
   RuntimeStrategiesResponse,
   selectTradesForWindow,
   toRuntimeTradeView,
@@ -52,6 +55,7 @@ const MIN_HOURS = 6;
 const MAX_HOURS = 24 * 90;
 const BYBIT_MAX_TIME_RANGE_MS = 7 * 24 * 60 * 60 * 1000 - 1_000;
 const EXCHANGE_REQUEST_TIMEOUT_MS = 15_000;
+const RUNTIME_LINEAGE_BASELINE_MS = 7 * 24 * 60 * 60 * 1000;
 
 const coerceHours = (value: string | null) => {
   const parsed = Number(value ?? Number.NaN);
@@ -162,6 +166,26 @@ const loadRuntimeTrades = async (
     .sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
 
+const loadRuntimeLineageScopes = async (
+  userName: string,
+  startTime: number,
+  endTime: number,
+): Promise<RuntimeStrategyLineageScope[]> =>
+  (
+    await Promise.all(
+      getRuntimeStorageDayKeys(
+        Math.max(0, startTime - RUNTIME_LINEAGE_BASELINE_MS),
+        endTime,
+      ).map((dayKey) =>
+        getHashJsonValues<RuntimeStrategyLineageScope>(
+          redisKeys.runtimeLineageScopeBucket(userName, dayKey),
+        ),
+      ),
+    )
+  )
+    .flat()
+    .filter(isRuntimeStrategyLineageScope);
+
 const buildExchangeTimeRanges = (startTime: number, endTime: number) => {
   const ranges: Array<{ startTime: number; endTime: number }> = [];
   let cursor = startTime;
@@ -380,6 +404,7 @@ export const GET = async (request: NextRequest) => {
       openPositionsSnapshot,
       runtimeDeployments,
       tradingAccounts,
+      runtimeLineageScopes,
     ] = await Promise.all([
       loadRuntimeStrategyConfigs(userName),
       loadConfiguredStrategyNames(),
@@ -400,6 +425,7 @@ export const GET = async (request: NextRequest) => {
       loadOpenPositions(connector, exchangeErrors),
       listRuntimeDeployments(userName),
       listTradingAccounts(userName),
+      loadRuntimeLineageScopes(userName, startTime, endTime),
     ]);
     const relevantTrades = selectTradesForWindow(
       runtimeTrades,
@@ -607,6 +633,13 @@ export const GET = async (request: NextRequest) => {
           stat: analytics.stat,
           summary: analytics.summary,
           orderLog: analytics.orderLog,
+          aiGateChanges: buildRuntimeStrategyAiGateChanges({
+            scopes: runtimeLineageScopes,
+            strategyName,
+            configId: identity.configId,
+            startTime,
+            endTime,
+          }),
           recentTrades: strategyTrades
             .slice(0, 8)
             .map((trade) => toRuntimeTradeView(trade, endTime)),

package/src/app/components/Strategies/RuntimeStrategyCard.tsx

@@ -2175,7 +2175,11 @@ export const RuntimeStrategyCard = ({
         </Portal>
       </Drawer.Root>
 
-      <RuntimeStrategyChart orderLog={strategy.orderLog} stat={strategy.stat} />
+      <RuntimeStrategyChart
+        orderLog={strategy.orderLog}
+        stat={strategy.stat}
+        aiGateChanges={strategy.aiGateChanges}
+      />
 
       <SimpleGrid columns={{ base: 4, md: 8 }} p={4}>
         <StatItem stat={strategy.stat} id="netProfit" title="P&L" />

package/src/app/components/Strategies/RuntimeStrategyChart.tsx

@@ -16,22 +16,25 @@ import {
 import { format } from 'date-fns';
 import { getFormatted } from '@tradejs/core/backtest';
 import type { SimpleOrderLogData, TestStat } from '@tradejs/types';
+import type { RuntimeStrategyAiGateChange } from '#app/lib/runtimeStrategies';
 
 interface RuntimeStrategyChartProps {
   orderLog: SimpleOrderLogData;
   stat: TestStat;
+  aiGateChanges: RuntimeStrategyAiGateChange[];
   height?: string | number;
 }
 
 export const RuntimeStrategyChart = ({
   orderLog,
   stat,
+  aiGateChanges,
   height = '350px',
 }: RuntimeStrategyChartProps) => {
   const chartData = useMemo(
     () => ({
       data: orderLog.map(([timestamp, amount]) => ({
-        timestamp: format(timestamp, 'dd.MM'),
+        timestamp,
         equity: amount,
       })),
       series: [
@@ -47,6 +50,7 @@ export const RuntimeStrategyChart = ({
   const chart = useChart(chartData as any);
   const { formatted: maxAmount } = getFormatted(stat, 'maxAmount');
   const { formatted: minAmount } = getFormatted(stat, 'minAmount');
+  const gateChangeColor = chart.color('purple.400');
 
   if (!orderLog.length) {
     return (
@@ -96,12 +100,40 @@ export const RuntimeStrategyChart = ({
                 position: 'bottom',
               }}
             />
-            <XAxis dataKey="timestamp" />
+            {aiGateChanges.map((change) => (
+              <ReferenceLine
+                key={`${change.timestamp}:${change.fingerprint}`}
+                x={change.timestamp}
+                stroke={gateChangeColor}
+                strokeDasharray="3 5"
+                strokeWidth={1.5}
+                label={{
+                  value: `AI-gate ${change.fingerprint.slice(0, 7)}`,
+                  fill: gateChangeColor,
+                  fontSize: 10,
+                  offset: 6,
+                  position: 'insideTopRight',
+                }}
+              />
+            ))}
+            <XAxis
+              dataKey="timestamp"
+              type="number"
+              scale="time"
+              domain={['dataMin', 'dataMax']}
+              tickFormatter={(timestamp) => format(timestamp, 'dd.MM')}
+            />
             <YAxis tickCount={10} domain={[stat.minAmount - 10, 'auto']} />
             <Tooltip
               animationDuration={100}
               cursor={false}
-              content={<Chart.Tooltip />}
+              content={
+                <Chart.Tooltip
+                  labelFormatter={(timestamp) =>
+                    format(Number(timestamp), 'dd.MM.yyyy HH:mm')
+                  }
+                />
+              }
             />
             {chart.series.map((item) => (
               <Line
@@ -111,6 +143,7 @@ export const RuntimeStrategyChart = ({
                 stroke={chart.color(item.color)}
                 strokeWidth={2}
                 dot={false}
+                activeDot={{ r: 5, strokeWidth: 2 }}
               />
             ))}
           </LineChart>

package/src/app/lib/runtimeStrategies.ts

@@ -9,6 +9,7 @@ import type {
   ExchangeEntryRecord,
   PositionPnlSnapshot,
   RuntimeTradeRecord,
+  RuntimeLineage,
   SimpleOrderLogData,
   StrategyConfig,
   TestStat,
@@ -72,6 +73,21 @@ export interface RuntimeStrategyTradeView {
   lastSyncedAt: number | null;
 }
 
+export interface RuntimeStrategyLineageScope {
+  strategy: string;
+  symbol: string;
+  runtimeConfigId?: string;
+  lineage: RuntimeLineage;
+  firstTimestamp: number;
+  lastTimestamp: number;
+}
+
+export interface RuntimeStrategyAiGateChange {
+  timestamp: number;
+  previousFingerprint: string;
+  fingerprint: string;
+}
+
 export interface RuntimeStrategyView {
   runtimeKey: string;
   strategyName: string;
@@ -89,6 +105,7 @@ export interface RuntimeStrategyView {
   stat: TestStat;
   summary: RuntimeStrategyTradeSummary;
   orderLog: SimpleOrderLogData;
+  aiGateChanges: RuntimeStrategyAiGateChange[];
   recentTrades: RuntimeStrategyTradeView[];
   orders: RuntimeStrategyTradeView[];
 }
@@ -164,6 +181,104 @@ export interface RuntimeStrategiesResponse {
   strategies: RuntimeStrategyView[];
 }
 
+export const isRuntimeStrategyLineageScope = (
+  value: unknown,
+): value is RuntimeStrategyLineageScope => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const record = value as Record<string, unknown>;
+  const lineage = record.lineage as Record<string, unknown> | undefined;
+
+  return (
+    typeof record.strategy === 'string' &&
+    typeof record.symbol === 'string' &&
+    typeof record.firstTimestamp === 'number' &&
+    Number.isFinite(record.firstTimestamp) &&
+    typeof record.lastTimestamp === 'number' &&
+    Number.isFinite(record.lastTimestamp) &&
+    lineage != null &&
+    typeof lineage.gateFingerprint === 'string' &&
+    lineage.gateFingerprint.trim().length > 0
+  );
+};
+
+export const buildRuntimeStrategyAiGateChanges = ({
+  scopes,
+  strategyName,
+  configId,
+  startTime,
+  endTime,
+}: {
+  scopes: RuntimeStrategyLineageScope[];
+  strategyName: string;
+  configId?: string;
+  startTime: number;
+  endTime: number;
+}): RuntimeStrategyAiGateChange[] => {
+  const normalizedConfigId = configId ?? 'config';
+  const observationsByTimestamp = new Map<
+    number,
+    { fingerprint: string; lastTimestamp: number }
+  >();
+
+  for (const scope of scopes) {
+    if (
+      scope.strategy !== strategyName ||
+      (scope.runtimeConfigId ?? 'config') !== normalizedConfigId ||
+      scope.firstTimestamp > endTime
+    ) {
+      continue;
+    }
+
+    const fingerprint = scope.lineage.gateFingerprint.trim();
+    const existing = observationsByTimestamp.get(scope.firstTimestamp);
+
+    // Multiple symbols are evaluated for the same strategy timestamp. If a
+    // deploy happens during that cycle, prefer the lineage that kept running
+    // afterwards instead of making the marker order depend on the symbol name.
+    if (
+      !existing ||
+      scope.lastTimestamp > existing.lastTimestamp ||
+      (scope.lastTimestamp === existing.lastTimestamp &&
+        fingerprint > existing.fingerprint)
+    ) {
+      observationsByTimestamp.set(scope.firstTimestamp, {
+        fingerprint,
+        lastTimestamp: scope.lastTimestamp,
+      });
+    }
+  }
+
+  const observations = [...observationsByTimestamp.entries()].sort(
+    ([leftTimestamp], [rightTimestamp]) => leftTimestamp - rightTimestamp,
+  );
+  const changes: RuntimeStrategyAiGateChange[] = [];
+  let currentFingerprint: string | null = null;
+
+  for (const [timestamp, observation] of observations) {
+    if (currentFingerprint == null) {
+      currentFingerprint = observation.fingerprint;
+      continue;
+    }
+    if (observation.fingerprint === currentFingerprint) {
+      continue;
+    }
+
+    if (timestamp >= startTime) {
+      changes.push({
+        timestamp,
+        previousFingerprint: currentFingerprint,
+        fingerprint: observation.fingerprint,
+      });
+    }
+    currentFingerprint = observation.fingerprint;
+  }
+
+  return changes;
+};
+
 const roundValue = (value: number, digits = 2) => {
   if (!Number.isFinite(value)) {
     return 0;